//对于每一个节点，返回其层次遍历序列，该序列代表一个子式，该序列也可以唯一确定一个子式
public String Test5(FinalNode1 bnode)
{
//开始层次遍历
FinalNode1 root = new FinalNode1();
FinalNode1 tempNode = new FinalNode1();
//下面这个是层次遍历字符串，唯一代表一个子式
String str = "";
//root = bnode.getNode(LaTeX);
root = bnode;
//Console.WriteLine("了："+root.zifu);
tempNode = root;//临时指向根结点
Queue <FinalNode1> q = new Queue <FinalNode1>();
q.Enqueue(root);
while (q.Count != 0)
{
//指向队列第一个字符
tempNode = q.First();
str = str + tempNode.zifu;
//第一个节点出队
q.Dequeue();
if (tempNode.left != null)
{
tempNode.left.xuhao = tempNode.xuhao * 2;
//Console.WriteLine("++++++++++++++left" + tempNode.left.xuhao);
q.Enqueue(tempNode.left);
}
if (tempNode.right != null)
{
tempNode.right.xuhao = tempNode.xuhao * 2 + 1;
//Console.WriteLine("++++++++++++++" + tempNode.right.xuhao);
q.Enqueue(tempNode.right);
}
}
//开始写了
return(str);
}
public void middlebianli(FinalNode1 a)
{
if (a.left != null)
{
middlebianli(a.left);
}
//Console.WriteLine("草泥马了什么鬼"+a.zifu);
nodeList.Add(a);
foreach (var it in nodeList)
{
//Console.WriteLine("什么鬼啊啊啊啊啊啊:"+it.zifu);
}
if (a.right != null)
{
middlebianli(a.right);
}
}
////我把第一篇论文的实验数据的子式写入数据库吧
//public void Test3()
//{
// // LaTeX，子式节点
// Dictionary<AAAAData, List<String>> dic = new Dictionary<AAAAData, List<String>>();
// StreamReader sr = new StreamReader("C:\\Users\\dell\\Desktop\\暑假\\实验数据\\1.txt", Encoding.Default);
// String read = sr.ReadLine();
// //第一步：开始读取每一个数学表达式了啊
// while (read != null)
// {
// //第二步：直接构成倒排索引吧，省的以后要是有重复的数学表达式啥的
// //对于输入进来的每一个数学公式，把它解析为各个子式
// List<AAAAData> li = new List<AAAAData>();
// li = Test4(read);
// int biaozhi = 0;//每进来一个子式，就记作一个标志
// //对于每一个子式节点，我需要插入字典，作为倒排索引
// foreach (var it in li)
// {
// //if (dic.Count == 0)
// //{
// // List<String> list = new List<string>();
// // list.Add(read);
// // dic.Add(it,list);
// // Console.WriteLine("第一个if");
// //}
// //else
// //{
// // //我去遍历字典的键值对象
// // foreach (var zidian in dic)
// // {
// // //如果字典里面的倒排索引有某一个子式了
// // if (zidian.Key.Equals(it) && (biaozhi == 0))
// // {
// // Console.WriteLine("第二个if");
// // dic[zidian.Key].Add(read);
// // biaozhi++;
// // }
// // else if(!zidian.Key.Equals(it))
// // {
// // List<String> list = new List<string>();
// // list.Add(read);
// // dic.Add(it, list);
// // }
// // }
// //}
// //==========================================================
// if (dic.Count == 0)
// {
// List<String> list = new List<string>();
// list.Add(read);
// dic.Add(it, list);
// continue;
// }
// int a = 0;//这是个判断标志，下面开始遍历，如果找到，那么a=1，没找到a=0
// AAAAData tempKey = null;//定义临时键存储文件名字
// foreach (var item in dic)
// {
// if (item.Key.Equals(it))
// {
// a = 1;
// tempKey = item.Key;//其实不用定义,因为如果找到，indexes.FileName与item.Key相等，下面那个“[]中括号”找谁不都一样么，多此一举
// break;//一旦找到说明找到了，那么就可以终止了，此时等于一加个break，否则又出bug了
// }
// }
// if (a == 1)//说明找到了
// {
// dic[tempKey].Add(read);
// }
// else if (a == 0)//说明没找到
// {
// List<String> list = new List<string>();
// list.Add(read);
// dic.Add(it, list);
// }
// //==========================================================
// }//循环里面
// read = sr.ReadLine();
// }
// ////这里把数据倒排插入数据库
// //bool panduan;
// //string sqlstr = "insert into Test1(子式,子式所在高度,数学表达式) values ('" + node + "','" + filename + "','" + path + "')";
// //panduan = DBhelper.InsertUpdateDal(sqlstr);
// //if (panduan == true)
// //{
// // Console.Write("操作成功");
// //}
// //else
// //{
// // Console.Write("操作失败");
// //}
//}
//我先试一试获取数学表达式子式
public List <AAAAData> Test4(String LaTeX)
{
//开始层次遍历
List <AAAAData> list = new List <AAAAData>();
BinaryTreeNode bnode = new BinaryTreeNode();
FinalNode1 root = new FinalNode1();
FinalNode1 tempNode = new FinalNode1();
root = bnode.getNode(LaTeX);
//Console.WriteLine("来看看第一个节点：" + root.zifu);
root.xuhao = 1;
tempNode = root;//临时指向根结点
Queue <FinalNode1> q = new Queue <FinalNode1>();
q.Enqueue(root);
//Console.WriteLine("下一个来看看第一个节点：" + q.First().zifu);
while (q.Count != 0)
{
//指向队列第一个字符
tempNode = q.First();
//Console.WriteLine("什么鬼啊下下一个来看看第一个节点：" + tempNode.zifu);
//下面这个再加个判断就行了就是if(tempNode.left == null && tempNode.right == null),tempNode就是出队节点
//=======！！！！！！！！！！！！！！这里注意：因为有根号的了，所以不能直接判断左右为空，而我根号默认是左节点！！！！！！！！！！！！！！！！！
if ((tempNode.left != null && tempNode.right != null) || (tempNode.left != null && tempNode.right == null))
{
AAAAData data = new AAAAData();
data.BTLevel = tempNode.BTreeLevel;
data.str = Test5(tempNode);
list.Add(data);
//Console.WriteLine("这里应该是根号：" + tempNode.zifu);
}
//第一个节点出队
q.Dequeue();
if (tempNode.left != null)
{
tempNode.left.xuhao = tempNode.xuhao * 2;
//Console.WriteLine("++++++++++++++left" + tempNode.left.xuhao);
q.Enqueue(tempNode.left);
}
if (tempNode.right != null)
{
tempNode.right.xuhao = tempNode.xuhao * 2 + 1;
//Console.WriteLine("++++++++++++++" + tempNode.right.xuhao);
q.Enqueue(tempNode.right);
}
}
return(list);
}
//=======================三目运算符弄一下==============================
public List <String> Test4(String LaTeX)
{
//开始层次遍历
List <String> list = new List <String>();
BinaryTreeNode bnode = new BinaryTreeNode();
FinalNode1 root = new FinalNode1();
FinalNode1 tempNode = new FinalNode1();
root = bnode.getNode(LaTeX);
//Console.WriteLine("来看看第一个节点：" + root.zifu);
root.xuhao = 1;
tempNode = root;//临时指向根结点
Queue <FinalNode1> q = new Queue <FinalNode1>();
q.Enqueue(root);
//Console.WriteLine("下一个来看看第一个节点：" + q.First().zifu);
while (q.Count != 0)
{
//指向队列第一个字符
tempNode = q.First();
//Console.WriteLine("什么鬼啊下下一个来看看第一个节点：" + tempNode.zifu);
//下面这个再加个判断就行了就是if(tempNode.left == null && tempNode.right == null),tempNode就是出队节点
//=======！！！！！！！！！！！！！！这里注意：因为有根号的了，所以不能直接判断左右为空，而我根号默认是左节点！！！！！！！！！！！！！！！！！
//第一种情况是：可交换运算符且左右都不空
if ((tempNode.left != null && tempNode.right != null && JiaoHuanOperator(tempNode.zifu)))
{
String strs1 = "";
String strs2 = "";
strs1 = Test5(tempNode.left) + tempNode.left.Flag + tempNode.zifu + tempNode.Flag + "#" + tempNode.zifu + tempNode.Flag + Test5(tempNode.right) + tempNode.right.Flag;//
strs2 = Test5(tempNode.right) + tempNode.right.Flag + tempNode.zifu + tempNode.Flag + "#" + tempNode.zifu + tempNode.Flag + Test5(tempNode.left) + tempNode.left.Flag;
list.Add(strs1);
list.Add(strs2);
//Console.WriteLine("第一种情况：" + tempNode.zifu);
//Console.WriteLine("============第一种情况=================");
}
//第二种情况是：不可交换运算符且左右都不空，类似减号
if ((tempNode.left != null && tempNode.right != null && !JiaoHuanOperator(tempNode.zifu)))
{
String strs1 = "";
strs1 = Test5(tempNode.left) + tempNode.left.Flag + tempNode.zifu + tempNode.Flag + "#" + tempNode.zifu + tempNode.Flag + Test5(tempNode.right) + tempNode.right.Flag;//
list.Add(strs1);
//Console.WriteLine("============第二种情况=================");
//Console.WriteLine("第二种情况：" + tempNode.zifu);
}
//第三种情况：类似根号形式的
if ((tempNode.left != null && tempNode.right == null && !JiaoHuanOperator(tempNode.zifu)))
{
String strs1 = "";
strs1 = tempNode.zifu + tempNode.Flag + "#" + Test5(tempNode.left) + tempNode.left.Flag;// "+","左节点"
list.Add(strs1);
//Console.WriteLine("这里应该是根号：" + tempNode.zifu);
//Console.WriteLine("============第三种情况=================");
}
//第一个节点出队
q.Dequeue();
if (tempNode.left != null)
{
//tempNode.left.xuhao = tempNode.xuhao * 2;
//Console.WriteLine("++++++++++++++left" + tempNode.left.xuhao);
q.Enqueue(tempNode.left);
}
if (tempNode.right != null)
{
//tempNode.right.xuhao = tempNode.xuhao * 2 + 1;
//Console.WriteLine("++++++++++++++" + tempNode.right.xuhao);
q.Enqueue(tempNode.right);
}
}
return(list);
}
public middleBianLi(List <FinalNode1> nodeList1, FinalNode1 node1)
{
nodeList = nodeList1;
node = node1;
this.middlebianli(node);
}
}//第四个指标：//这个是树的结构属性
public double OperateBTLevelAndType(String queryLaTeX, String resultLaTeX)
{
AABTreeStructure acquireBtreeStructure = new AABTreeStructure(); //调用这个类，获取树结构的类
List <FinalNode1> queryLaTeXAdjacentNodeList = new List <FinalNode1>(); //存放“查询表达式”邻接节点有序对的集合
List <FinalNode1> resultLaTeXAdjacentNodeList = new List <FinalNode1>(); //存放“结果表达式”邻接节点有序对的集合
queryLaTeXAdjacentNodeList = acquireBtreeStructure.AdjacentNodeList(queryLaTeX); //已经存放“查询表达式”邻接节点有序对的集合
resultLaTeXAdjacentNodeList = acquireBtreeStructure.AdjacentNodeList(resultLaTeX); //已经存放“结果表达式”邻接节点有序对的集合
/*//第一步：我先统计一下查询表达式树的深度（先用遍历的方法，以后如果慢的话，我再用递归，我先做出来再说！！！）
* int queryLaTeXBTreeDepth = 0;
* for (int i = 0; i < queryLaTeXAdjacentNodeList.Count; i++)
* {
* if (queryLaTeXAdjacentNodeList[i].BTreeLevel > queryLaTeXBTreeDepth)
* {
* queryLaTeXBTreeDepth = queryLaTeXAdjacentNodeList[i].BTreeLevel;
* }
* }*/
//我应该算结果表达式的二叉树对应的高度吧
int resultLaTeXBTreeDepth = 0;
for (int i = 0; i < resultLaTeXAdjacentNodeList.Count; i++)
{
if (resultLaTeXAdjacentNodeList[i].BTreeLevel > resultLaTeXBTreeDepth)
{
resultLaTeXBTreeDepth = resultLaTeXAdjacentNodeList[i].BTreeLevel;
}
}
//===================先在这按照二叉树所有节点，按照树的高度进行排序==============================
FinalNode1 tempdata = new FinalNode1();
for (int i = 0; i < queryLaTeXAdjacentNodeList.Count - 1; i++)
{
for (int j = i + 1; j < queryLaTeXAdjacentNodeList.Count; j++)
{
if (queryLaTeXAdjacentNodeList[j].BTreeLevel < queryLaTeXAdjacentNodeList[i].BTreeLevel)
{
tempdata = queryLaTeXAdjacentNodeList[j];
queryLaTeXAdjacentNodeList[j] = queryLaTeXAdjacentNodeList[i];
queryLaTeXAdjacentNodeList[i] = tempdata;
}
}
}
for (int i = 0; i < resultLaTeXAdjacentNodeList.Count - 1; i++)
{
for (int j = i + 1; j < resultLaTeXAdjacentNodeList.Count; j++)
{
if (resultLaTeXAdjacentNodeList[j].BTreeLevel < resultLaTeXAdjacentNodeList[i].BTreeLevel)
{
tempdata = resultLaTeXAdjacentNodeList[j];
resultLaTeXAdjacentNodeList[j] = resultLaTeXAdjacentNodeList[i];
resultLaTeXAdjacentNodeList[i] = tempdata;
}
}
}
//===================先在这按照二叉树所有节点，按照树的高度进行排序==============================
//第二步：开始统计查询表达式对应二叉树的树的层次（用字典存储）（其实可以层次遍历二叉树的，到时候再说，先做出来）
Dictionary <int, List <FinalNode1> > queryDictionary = new Dictionary <int, List <FinalNode1> >();
for (int j = 0; j < queryLaTeXAdjacentNodeList.Count; j++)
{
//遍历查询表达式邻接节点有序对，开始对每一个节点进行判断，如果某一个节点是运算符的话，
if (isOperator(queryLaTeXAdjacentNodeList[j].zifu))
{
if (queryDictionary.Count == 0)
{
//这个是添加的第一个元素
List <FinalNode1> lists = new List <FinalNode1>();
lists.Add(queryLaTeXAdjacentNodeList[j]);
queryDictionary.Add(queryLaTeXAdjacentNodeList[j].BTreeLevel, lists);
continue;
}
//如果下一个是运算符，并且树的层次之前有出现了，那就把它再添加到对应后面
if (queryDictionary.ContainsKey(queryLaTeXAdjacentNodeList[j].BTreeLevel))
{
queryDictionary[queryLaTeXAdjacentNodeList[j].BTreeLevel].Add(queryLaTeXAdjacentNodeList[j]);
}
//如果下一个树的层次没有，那么，就添加进去
else
{
List <FinalNode1> lists = new List <FinalNode1>();
lists.Add(queryLaTeXAdjacentNodeList[j]);
queryDictionary.Add(queryLaTeXAdjacentNodeList[j].BTreeLevel, lists);
}
}
}
/*foreach (var it in queryDictionary)
* {
* Console.WriteLine("查询表达式的树的层次================"+it.Key);
* }*/
//第三步：开始统计结果表达式对应二叉树的树的层次（用字典存储）
Dictionary <int, List <FinalNode1> > resultDictionary = new Dictionary <int, List <FinalNode1> >();
for (int j = 0; j < resultLaTeXAdjacentNodeList.Count; j++)
{
//遍历查询表达式邻接节点有序对，开始对每一个节点进行判断，如果某一个节点是运算符的话，
if (isOperator(resultLaTeXAdjacentNodeList[j].zifu))
{
if (resultDictionary.Count == 0)
{
//这个是添加的第一个元素
List <FinalNode1> lists = new List <FinalNode1>();
lists.Add(resultLaTeXAdjacentNodeList[j]);
resultDictionary.Add(resultLaTeXAdjacentNodeList[j].BTreeLevel, lists);
continue;
}
//如果下一个是运算符，并且树的层次之前有出现了，那就把它再添加到对应后面
if (resultDictionary.ContainsKey(resultLaTeXAdjacentNodeList[j].BTreeLevel))
{
resultDictionary[resultLaTeXAdjacentNodeList[j].BTreeLevel].Add(resultLaTeXAdjacentNodeList[j]);
}
//如果下一个树的层次没有，那么，就添加进去
else
{
List <FinalNode1> lists = new List <FinalNode1>();
lists.Add(resultLaTeXAdjacentNodeList[j]);
resultDictionary.Add(resultLaTeXAdjacentNodeList[j].BTreeLevel, lists);
}
}
}
/*foreach (var it in resultDictionary)
* {
* Console.WriteLine("结果表达式树的高度："+it.Key);
* }*/
//======================================排序啊，排序前=======================================
////我先查看一下字典里面的层次
//foreach (var it in queryDictionary)
//{
// Console.WriteLine("查询字典是啥:"+it.Key);
//}
//foreach (var it in resultDictionary)
//{
// Console.WriteLine("结果字典是啥:"+it.Key);
//}
/*第四步:开始统计查询表达式从第一层到最后一层，
* 查询表达式每一层运算符的节点个数，在结果表达式每一层找到的运算符相同的个数
* 除以结果表达式对应该层的运算符的总个数的比值，再乘以1-层次除以结果表达式树的层次高度
*/
//设置一个存放每一层分数的集合
List <double> scoreList = new List <double>();
//下面这个是开始遍历查询表达式的每一层，假如现在是第一层，也就是第一个元素
for (int i = 0; i < queryDictionary.Count; i++)
{
//这里在每一层设置一个计算相同运算符或者相同类型运算符的个数的计数工具
int SameBTLevelCount = 0;
//注释一下，我怕那个了，此时这个i是查询表达式的高度（或者说元素序号）
//如果查询表达式的高度大于结果表达式，比如查询表达式现在
//比如查询表达式高度为5，此时i取0-4，结果表达式也应该是0-4，
//结果表达式高度为3，但是此时结果表达式高度为0-2，所以当i取3也就是
//i等于resultDictionary.count时，直接结束
if (i == resultDictionary.Count)
{
break;
}
//下面就是i不等于
//下面这个是开始遍历查询表达式每一层的节点，
//用集合存储，可能很多，以第一层为例，也就是说遍历第一层的每一个节点
//去和结果表达式里面的每一层去比较“是否相同或者是否是同类运算符”
for (int j = 0; j < queryDictionary[i + 1].Count; j++)
{
//上面这个对于查询表达式每一层的每一个节点，要去结果表达式里面
//去和结果表达式里面的每一个节点进行比较，看看是否相同
//Console.WriteLine("草拟吗傻逼："+i);
for (int k = 0; k < resultDictionary[i + 1].Count; k++)
{
//这里是相同的运算符或者相似的运算符
if (queryDictionary[i + 1][j].zifu.Equals(resultDictionary[i + 1][k].zifu))
{
SameBTLevelCount++;
}
}
}
//第一层统计完相似的运算符的个数之后，开始计算该层的分数，就以第一层为例
double BTLevelSum = Convert.ToDouble(resultDictionary[i + 1].Count); //结果表达式中第一层运算符的节点的总个数
double b = Convert.ToDouble(SameBTLevelCount) / BTLevelSum; //结果表达式中，与查询表达式相似的运算符的个数除以结果表达式的总个数
//该层相同的节点数不是唯一决定因素，还得乘以所在层次的高度这个权值，占的比重大
double c = Convert.ToDouble(i + 1); //结果表达式的层次为 i + 1
double d = Convert.ToDouble(resultLaTeXBTreeDepth); //结果表达式里面对应二叉树的总高度
//double BTLevelQuanZhong = 1 - c/d;
//树的每一层，所有层的总和
int a = 0;
for (int j = 1; j <= resultLaTeXBTreeDepth; j++)
{
a = a + j;
}
double BTLevelZongHe = Convert.ToDouble(a);//树的每一层的总和
//结果表达式树的高度不就是结果表达式那个字典里面的总个数么，还用遍历然后计算最大值啊！！！不用呢！(哎呀不对，我这个字典里面存的是树的运算符的层次，不是完整的二叉树啊)
//double BTreeHeight = Convert.ToDouble(resultDictionary.Count);
double BTreeHeight = resultLaTeXBTreeDepth;//这个才是结果表达式二叉树的最大高度，我在最上面遍历了一下所有节点，找到高度最大的那个
double BTLevelQuanZhong = (BTreeHeight - (i + 1) + 1) / BTLevelZongHe;
double BTLevelScore = b * BTLevelQuanZhong;//这个是该层的相似运算符的个数和所在层次的权重相乘的得分
scoreList.Add(BTLevelScore);
//Console.WriteLine("每层相似节点的个数:"+SameBTLevelCount);
//Console.WriteLine("每层结果表达式节点总个数:"+BTLevelSum);
//Console.WriteLine("树的高度，也就是最大层次为:"+BTreeHeight);
//Console.WriteLine("树的每一层加起来比如1+2+...总和:"+BTLevelZongHe);
//Console.WriteLine("结果表达式二叉树节点高度:"+d);
//Console.WriteLine("每层权重:"+BTLevelQuanZhong);
//Console.WriteLine("================================");
}
double finalScore = 0;
//把每一层高度的分数的和遍历打印一下，看看弄的对不对
foreach (var it in scoreList)
{
finalScore = finalScore + it;
//Console.WriteLine("看看每一层的分数算的对不对:"+it);
}
//Console.WriteLine("运算符层次和类型最终分数:"+finalScore);
return(finalScore);
}//第五个
//我把LaTeX传进来，获取它的子式
public Dictionary <int, List <FinalNode1> > childrenBTree(String LaTeX)
{
//==============类创建对象===============
Peidui peidui = new Peidui();
SpecialYunSuanShu specialYunSuanShus = new SpecialYunSuanShu();
Default defaults = new Default();
//==============类创建对象===============
//前期准备工作
Dictionary <int, string> latexKeyWordsDC = new Dictionary <int, string>(); //存储字典 必须进行初始化
Dictionary <int, string> latexKeyWordTypesDC = new Dictionary <int, string>(); //存储字典 必须进行初始化
int theLength; //关键字最大长度 必须进行初始化
//初始化字典
string path = @"C:\\Users\\dell\\Desktop\\暑假\\实验数据\\latexSybs.txt";
string sLine = "";
int i = 0;
int theMostLength = 0;
string theStrMostLength = null;
StreamReader latexSybsReader = new StreamReader(path);
while (sLine != null)
{
i += 1;
sLine = latexSybsReader.ReadLine();
if (sLine == "")
{
continue;
}
else if (sLine == null)
{
break;
}
string[] line = sLine.Split('#');
latexKeyWordsDC.Add(i, line[0]);
latexKeyWordTypesDC.Add(i, line[1]);
}
//找到最长的符号和最长的符号对应的长度
foreach (string value in latexKeyWordsDC.Values)
{
if (value.Length > theMostLength)
{
theMostLength = value.Length;
theStrMostLength = value;
}
}
//初始化长度
theLength = theMostLength;
//前期准备
//Console.WriteLine("最大长度为:"+theLength);
//找类似\frac这样的东西
for (int posInExp = 0; posInExp < LaTeX.Length; posInExp++)
{
string keyWord = null; //存储关键字
char c = LaTeX[posInExp];
if (c == '\\')
{
if (LaTeX.Length - (posInExp + 1) < theLength)
{
keyWord = c + LaTeX.Substring(posInExp + 1, LaTeX.Length - (posInExp + 1));
}
else
{
keyWord = c + LaTeX.Substring(posInExp + 1, theLength);
}
try
{
while (!latexKeyWordsDC.ContainsValue(keyWord)) //意思是假如字典里面不包含比如这个\frac，说明逆向减字没有截出来，还得再截
{
keyWord = keyWord.Substring(0, keyWord.Length - 1); //这不就开始截取了吗，哈哈哈哈哈哈哈哈！！！！！！，这是在第一次循环里面找到第一个\frac,最外层下标一步步向右推进，意思是找更多的\frac
if (keyWord == "")
{
//删除节点信息 出错报告
//deleteExpInfoAndNodeInfo(expId);
}
}
}
catch (Exception ex)
{
continue;
}
}
}
//找类似\frac这样的东西
//========================================================括号匹配开始========================================================
//==========存放插入二叉树前的序列，但目前不含============
List <FinalNode1> finalList1 = new List <FinalNode1>();
//==========存放插入二叉树前的序列============
String tempStr = null;
Stack <ZifuNode> stack1 = new Stack <ZifuNode>();
//下面我得弄一个p和q的集合，因为有可能出现好多个<p,q>这样的对,但是一开始应该先把<p=1,q=0>放入集合里面
PQPanDuan pqPanDuan = new PQPanDuan();
List <PQ> PQList = new List <PQ>();
PQ pANDq = new PQ();
pANDq.P = 1;
pANDq.Q = 0;
PQList.Add(pANDq);// 一开始应该先把 < p = 1,q = 0 > 放入集合里面
//int p = 1, q = 0;
for (int j = 0; j < LaTeX.Length; j++)
{
//从第一个字符开始
ZifuNode current = new ZifuNode();
current.zifu = LaTeX[j];
current.position = j;
switch (current.zifu)
{
case '(':
case '[':
case '{':
stack1.Push(current);
break;
case ')':
case ']':
case '}':
if (stack1.Count <= 0)
{
Console.WriteLine("栈为空");
}
else
{
ZifuNode top = new ZifuNode();
top = stack1.Peek(); //先获取栈顶元素，但是还没弹出来了啊，先获取它出来比较一下，其实这里“凡是栈里面的都是左括号”
//Console.WriteLine("草拟吗的这里top应该为15啊:" + top.position);
//Console.WriteLine("左括号位置:"+top.position + "配对右括号位置:" + current.position);
if (peidui.IsCouple(top, current)) //配对成功一对，就把栈顶那个左括号弹出，既然成功了一对，那就去掉这一对吧
{
//这里是开始截取那个特殊字符，如果截取到那个特殊字符的话，就把该字符放入集合当中
for (int m = 0; m < top.position + 1; m++) //从0到15开始截取
{
tempStr = LaTeX.Substring(m, top.position - m); //==============================================================下面这个bug到这里了
if (latexKeyWordsDC.ContainsValue(tempStr) /*&&tempStr.Equals("\\sqrt")*/) //==============
{ //==============
if (tempStr.Equals("^"))
{
if (stack1.Count > 0) //括号内的，就break
{
break;
}
else
{
//Console.WriteLine("草拟吗到底加进去了吗艹艹艹艹 艹艹艹 艹艹艹 艹艹艹" + tempStr);
FinalNode1 no = new FinalNode1(); //==============
no.yuanshiXuHao = top.position - tempStr.Length; //==============
no.pailiexuhao = current.position; //==============
no.zifu = tempStr;
//Console.WriteLine("艹艹艹艹艹艹艹艹艹艹艹艹艹"+no.zifu);
//==============
finalList1.Add(no);
break;
}
}
else if (tempStr.Equals("_"))
{
if (stack1.Count > 0)
{
break;
}
else
{
FinalNode1 no = new FinalNode1(); //==============
no.yuanshiXuHao = top.position - tempStr.Length; //==============
no.pailiexuhao = current.position; //==============
no.zifu = tempStr;
//Console.WriteLine("艹艹艹艹艹艹艹艹艹艹艹艹艹"+no.zifu);
//==============
finalList1.Add(no);
break;
}
}
else
{
//这里这不就是添加\sqrt和\frac这样的特殊的tempStr的，
FinalNode1 no = new FinalNode1(); //==============
no.yuanshiXuHao = top.position - tempStr.Length; //==============
no.pailiexuhao = current.position; //==============
no.zifu = tempStr;
//Console.WriteLine("艹艹艹艹艹艹艹艹艹艹艹艹艹"+no.zifu);
//==============
if (tempStr.Equals("\\cdot") || tempStr.Equals("\\quad") || tempStr.Equals("\\gg")) //如果类似a\\cdot{a+b}，“{”左边截取出来的是\\cdot，就不添加了，要不然就添加了两次吧，应该是
{
}
else
{
finalList1.Add(no); //==============
} //Console.WriteLine("第一次截出来特殊字符了吗？:"+tempStr); //==============
//下面加个break就对了，逻辑错误哈哈哈，如果不加break，执行到我这一行，已经截取出来，然后他妈就不停，还要到继续“下一个循环”，不断循环，不断截取，一直他妈截取完
break; //如果截出来的话，那就直接break吧，不过可能有的“数学公式”截出来可能好多，需要多判断下一个字符来确定，到时候再说
}
}
}
//Console.WriteLine("各种草拟吗了到底草拟吗了没:"+tempStr);
String specialStr = tempStr; //这里specialStr就是比如\frac或者\sqrt这样的
//Console.WriteLine("第一次出现：" + specialStr);
//Console.WriteLine("草拟吗的这里top应该为15啊:" + top.position);
//Console.WriteLine("草拟吗什么鬼:"+LaTeX);
tempStr = LaTeX.Substring(top.position + 1, current.position - top.position - 1); //这里相减再减一是两个括号里面的字符的所有长度
for (int k = 0; k < tempStr.Length; k++)
{
if (pqPanDuan.pqPanDuan(LaTeX, k, top, PQList)) //如果在这个区间内，就不执行下列代码
{
//Console.WriteLine("如果在这区间，就继续循环，不执行其它");
continue;
}
else
{
//有的东西是以“\”开始的，比如\pi，\sin，\times，所以添加的时候，要从这里（源头）开始添加，
//要不然一个一个的从开始就把字符给拆开了，后期没法弄了，所以这里开始是以一个整体的形式开始弄的
//艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹//如果遇到以“\”开始的话，但是“\”开头的有好多类型，到时候这里得一个一个添加艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹
//艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹//注意啊：不能写成“tempStr[k].Equals("\\")”，因为tempStr[k]是字符char类型的，而.Equals（）方法是字符串string类型的，两个本来不能用，所以需要强制转换一下
if (Convert.ToString(tempStr[k]).Equals("\\"))
{
k = specialYunSuanShus.specialYunSuanShu(tempStr, k, finalList1, top);
}
else
{
//Console.WriteLine("第一次:" + Convert.ToString(tempStr[k]));
FinalNode1 no = new FinalNode1();
no.zifu = Convert.ToString(tempStr[k]);
no.yuanshiXuHao = top.position + 1 + k;
no.pailiexuhao = top.position + 1 + k;
finalList1.Add(no);
}
}
}
//Console.WriteLine("草拟吗的这里top应该为15啊:" + top.position);
//因为啥了，因为遇到比如左括号，左括号前面的那个是\\sqrt或者\\frac，我就把它略过了就不执行了，但是遇到上标“^”，我就不能略过啊
//比如^{a} 和 \\frac{a}，左括号前面是\\frac就略过，左括号前面是^就不能略过
//艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹这里他妈也是个bug啊，千万得注意==============================================================
if (Convert.ToString(LaTeX[top.position - specialStr.Length]).Equals("^") || Convert.ToString(LaTeX[top.position - specialStr.Length]).Equals("_"))
{
/*p = top.position;
* q = current.position;*/
PQ ppqq = new PQ();
ppqq.P = top.position;
ppqq.Q = current.position;
PQList.Add(ppqq);
}
else //一般情况是下面
{
/*p = top.position - specialStr.Length;
* q = current.position;*/
PQ ppqqs = new PQ();
ppqqs.P = top.position - specialStr.Length;
ppqqs.Q = current.position;
PQList.Add(ppqqs);
}
//Console.WriteLine("边界p为:"+p+"\t"+"边界q为:"+q);
stack1.Pop();
} //如果配对成功
/*else
* {
* Console.WriteLine("错误");
* }*/
} //如果栈不空
break;
//如果遇到不是括号的话，因为之前的思想就是每次把括号里面的东西以对象形式放入，如果遇到不是括号了，就是普通字符，那就应该是也是上面那样吧，试一试看
//因为没有括号，所以直接就把它放入即可
default:
//艹艹艹艹艹艹艹艹艹艹艹艹艹每次上面那写草字头需要改的时候，这里也得跟着改艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹艹（明白了，因为此时遇到这个\\pi，是先跳过，后续在括号内截取会再次截取，但是如果不是括号内的呢？）
//Console.WriteLine("草拟吗加了没:" + j);
j = defaults.defaults(stack1, LaTeX, j, finalList1, current);
break;
} //switch的判断这个字符
} //遍历这个LaTeX字符串
/*if (stack1.Count <= 0)
* Console.WriteLine("ChildrenBTree.cs:栈为空啥正确了啊");*/
//========================================================括号匹配开始========================================================
//====================每次都要打印一下集合===================================================================
List <FinalNode1> finalList2 = new List <FinalNode1>();
List <FinalNode1> finalList3 = new List <FinalNode1>();
//第一个“InsertBTree”
/*foreach (var it in finalList1)
* {
* Console.WriteLine("finalList1：还得继续草泥马了啊:" + it.zifu);
*
* }*/
InsertBTree insert = new InsertBTree();
finalList2 = insert.insertBTree(finalList1, LaTeX);
//第二个“InsertBTree2”
/*foreach (var it in finalList2)
* {
* Console.WriteLine("finalList2：还得继续草泥马了啊:" + it.zifu);
* }*/
InsertBTree2 insert2 = new InsertBTree2();
finalList3 = insert2.insertBTree2(finalList2, LaTeX, latexKeyWordsDC);
//第三个“InsertBTree3”
/*foreach (var it in finalList3)
* {
* Console.WriteLine("finalList3：还得继续草泥马了啊:" + it.zifu);
* }*/
//==================================
List <FinalNode1> finalList4 = new List <FinalNode1>();
for (int a = 0; a < finalList3.Count; a++)
{
//下面这个简直多此一举，我都不知道我为啥要去掉\\sqrt
/*if (finalList3[a].zifu.Equals("\\sqrt"))
* {
* continue;
* }*/
finalList4.Add(finalList3[a]);
}
//==================================
//Console.WriteLine("这他妈是哪了啊打印finalList4");
/*foreach (var it in finalList4)
* {
* Console.WriteLine("finalList4我真草泥马:" + it.zifu+"Level："+it.Level);
*
* }*/
InsertBTree3 insert3 = new InsertBTree3();
FinalNode1 node = new FinalNode1();
BTreeLevel createBTreeLevel = new BTreeLevel();
node = insert3.insertBTree3(finalList4);//现在获取到那棵二叉树了啊，以节点形式
//createBTreeLevel.getBTreeLevel(node);//已经为每一个节点赋值它的层次了
//把中序遍历好的每一个节点（其实就是子节点啊）存入集合当中
List <FinalNode1> nodeList = new List <FinalNode1>();
middleBianLi zhongxu = new middleBianLi(nodeList, node);//其实这里这个node相当于根节点（就是该一个完整LATeX）吧，获取它的中序遍历二叉树序列
//注意啊，一开始我只是把每一个LaTeX,对应一个中序遍历邻接节点有序对存存入一个集合啊，但是，现在一个LaTex对应二叉树有好多个子树，意味着有好多个子的邻接节点有序对的集合，所以得都收集起来
//接下来对每一个子节点进行中序遍历获取它的邻接节点有序对啊
Dictionary <int, List <FinalNode1> > children = new Dictionary <int, List <FinalNode1> >();
int b = 1;
//遍历该LaTeX中所有的节点（子树）比如这里nodeList里面存的是（二叉树的每一个节点信息，比如a+b+c就有举例为a，+，b，+，c各个节点不是单一的树，而是一个个的子树，
foreach (var it in nodeList) //遍历每一个子树
{
if (it.left == null && it.right == null) //如果是叶子节点的话，舍弃
{
continue;
}
else
{
List <FinalNode1> nodeLists = new List <FinalNode1>();
createBTreeLevel.getBTreeLevel(node); //已经为每一个节点赋值它的层次了
//下面这个是每次用一个新集合nodeLists来装每一个子节点it中序遍历后的集合(也就是中序遍历后邻接节点的)
middleBianLi zhongxus = new middleBianLi(nodeLists, it); //而这里这个是对于每一个子节点进行中序遍历，获取每一个子节点的中序遍历二叉树序列集合
children.Add(b, nodeLists);
b++;
}
//Console.WriteLine("看看我猜的准不准啊艹照这么说的话第一个字符:"+nodeLists[0].zifu+"第一个字符的树的层次为:"+nodeLists[0].BTreeLevel+"\t"+"第一个字符的左边字符:"+nodeLists[0].left.zifu+"树的层次为:"+ nodeLists[0].left.BTreeLevel + "\t" + "第一个字符的右边字符:" + nodeLists[0].right.zifu + "树的层次为:" + nodeLists[0].right.BTreeLevel);
//Console.WriteLine("看看我猜的准不准啊艹照这么说的话第二个字符:" + nodeLists[1].zifu + "第二个字符的树的层次为:" + nodeLists[1].BTreeLevel + "\t" + "第二个字符的左边字符:" + nodeLists[1].left.zifu + "树的层次为:" + nodeLists[1].left.BTreeLevel + "\t" + "第二个字符的右边字符:" + nodeLists[1].right.zifu + "树的层次为:" + nodeLists[1].right.BTreeLevel);
//Console.WriteLine("看看我猜的准不准啊艹照这么说的话第三个字符:" + nodeLists[2].zifu + "第三个字符的树的层次为:" + nodeLists[2].BTreeLevel + "\t" + "第三个字符的左边字符:" + nodeLists[2].left.zifu + "树的层次为:" + nodeLists[2].left.BTreeLevel + "\t" + "第三个字符的右边字符:" + nodeLists[2].right.zifu + "树的层次为:" + nodeLists[2].right.BTreeLevel);
/* Console.WriteLine("照这么说的话索引超出范围了啊:"+nodeLists.Count);
*
* Console.WriteLine("看看我猜的准不准啊艹照这么说的话第一个字符:" + nodeLists[0].zifu );
* Console.WriteLine("看看我猜的准不准啊艹照这么说的话第二个字符:" + nodeLists[1].zifu );
* Console.WriteLine("看看我猜的准不准啊艹照这么说的话第三个字符:" + nodeLists[2].zifu );*/
}
return(children);
}
public List <String> resultJaccardList(String resultLaTeX)
{
AABTree Btree = new AABTree();
//结果表达式对应的二叉树
FinalNode1 resultBtree = new FinalNode1();
resultBtree = Btree.getBTree(resultLaTeX);
//开始获取“根、叶路径”，试一试
Dictionary <int, List <FinalNode1> > list = new Dictionary <int, List <FinalNode1> >();
Queue <FinalNode1> qNode = new Queue <FinalNode1>();
Queue <List <FinalNode1> > qStr = new Queue <List <FinalNode1> >();
/*if (queryBtree == null)
* return list;*/
qNode.Enqueue(resultBtree);
FinalNode1 temp = new FinalNode1();
temp.zifu = "#";
List <FinalNode1> tempList = new List <FinalNode1>();
tempList.Add(temp);
qStr.Enqueue(tempList);
int i = 0;
while (qNode.Count != 0)
{
FinalNode1 curNode = qNode.Dequeue();
List <FinalNode1> curStr = qStr.Dequeue();
//如果该节点就是一个根节点并且是叶子节点的话
if (curNode.left == null && curNode.right == null)
{
i++;
List <FinalNode1> templist = new List <FinalNode1>();
for (int j = 0; j < curStr.Count; j++)
{
templist.Add(curStr[j]);
}
templist.Add(curNode);
list.Add(i, templist);
}
if (curNode.left != null)
{
qNode.Enqueue(curNode.left);
List <FinalNode1> templist = new List <FinalNode1>();
for (int j = 0; j < curStr.Count; j++)
{
templist.Add(curStr[j]);
}
templist.Add(curNode);
qStr.Enqueue(templist);
}
if (curNode.right != null)
{
qNode.Enqueue(curNode.right);
List <FinalNode1> templist = new List <FinalNode1>();
for (int j = 0; j < curStr.Count; j++)
{
templist.Add(curStr[j]);
}
templist.Add(curNode);
qStr.Enqueue(templist);
}
}
//这一步可以去掉“#”号的，因为每个“#”号肯定是在首元素，所去掉每个集合的首元素就行了
foreach (var it in list)
{
it.Value.RemoveAt(0);
}
//这一步是开始把查询表达式里面的“按照jaccd系数那样的所有节点对”放在一个集合里面
//之前的操作是放到一个字典里面，字典里面是“FinalNode1”这种类型，
//因为我无法用“节点”操作形成Jaccd系数节点集合，所以再把集合中节点的字符串再次读出
List <String> finalList = new List <string>();
foreach (var it in list)
{
for (int q = 0; q < it.Value.Count; q++)
{
for (int m = q; m < it.Value.Count; m++)
{
String tempStr = "";
for (int n = q; n < m + 1; n++)
{
if (!isSpecialYunSuanShu(it.Value[n].zifu))
{
tempStr = tempStr + it.Value[n].zifu /*+ "\t"*/;
}
}
finalList.Add(tempStr);
}
}
}
//打印一下查询表达式里面所有的“Jaccd系数的字符串”
/*foreach (var it in finalList)
* {
* Console.WriteLine("看看所有Jaccd系数:" + it);
* }*/
//我得去重啊
List <String> NoRepeatfinalList = new List <String>();
//遍历有重复的节点集合，放在一个无重复的集合中
for (int j = 0; j < finalList.Count; j++)
{
//如果是第一个节点的话，直接加入，因为没有重复
if (j == 0)
{
NoRepeatfinalList.Add(finalList[j]);
continue;
}
//从第二个字符串开始，要进行判断是否重复，遍历新集合，注意必须得全部遍历一遍
//所以要设置一个重复标志，biaozhi
//因为每进来一个元素，都要判断是否有重复，所以都要重新设置一个标志
int biaozhi = 0;//表示没有重复
for (int k = 0; k < NoRepeatfinalList.Count; k++)
{
//如果新集合中的元素和原来的元素重复了
if (NoRepeatfinalList[k].Equals(finalList[j]))
{
//说明有重复了，只要有重复了，那就直接break即可
biaozhi = 1;
break;
}
}
//如果有重复的话，那就下一次循环
if (biaozhi == 1)
{
continue;
}
else
{
NoRepeatfinalList.Add(finalList[j]);
}
}
//遍历一下无重复的，试一下，结果对了
/*foreach (var it in NoRepeatfinalList)
* {
* Console.WriteLine("无重复的:" + it);
* }*/
//我还得把空字符串去掉
List <String> NoRepeatfinalLists = new List <String>();
//遍历一下无重复的，试一下，结果对了
foreach (var it in NoRepeatfinalList)
{
if (it.Equals(""))
{
}
else
{
NoRepeatfinalLists.Add(it);
}
//Console.WriteLine("无重复的:" + it);
}
//最终版本
//foreach (var it in NoRepeatfinalLists)
//{
// Console.WriteLine("无重复的啊啊:" + it);
//}
return(NoRepeatfinalLists);
}
public List <FinalNode1> FuZhi(List <FinalNode1> finalList1, String LaTeX)
{
ExpUtil exputil = new ExpUtil();
//Console.WriteLine("FuZhiFeature:传进来的LaTeX为:" + LaTeX);
if (LaTeX.Contains("\\lim") || LaTeX.Contains("\\sum"))//如果含有lim的话，这个是含有lim的得特殊处理啊
{
//Console.WriteLine("FuZhiFeature:传进来的LaTeX为:" + LaTeX);
LaTeX = LaTeX.Replace("\\join", "");
LaTeX = LaTeX.Replace("\\connect", "");
LaTeX = LaTeX.Replace("\\negative*", "-");
LaTeX = LaTeX.Replace("\\negative", "-");
LaTeX = LaTeX.Replace("\\PowerRoot", "");
LaTeX = LaTeX.Replace("\\DuiShu", "");
LaTeX = LaTeX.Replace("\\temp", "\\log_");
//Console.WriteLine("替换后的LaTeX为:" + LaTeX);
char[] limcaos = LaTeX.ToCharArray();
LaTeX = "";
for (int d = 0; d < limcaos.Length; d++)
{
if (Convert.ToString(limcaos[d]).Equals("\\") && Convert.ToString(limcaos[d + 1]).Equals("l") && Convert.ToString(limcaos[d + 2]).Equals("i") && Convert.ToString(limcaos[d + 3]).Equals("m"))
{
//下面这个下标是为了使杨颂强那个给解析出特征然后赋给我啊，而我那个里面没有任何变动
LaTeX = LaTeX + "\\lim_";
d = d + 3;
}
else if (Convert.ToString(limcaos[d]).Equals("\\") && Convert.ToString(limcaos[d + 1]).Equals("s") && Convert.ToString(limcaos[d + 2]).Equals("u") && Convert.ToString(limcaos[d + 3]).Equals("m"))
{
LaTeX = LaTeX + "\\sum_";
d = d + 3;
}
else
{
LaTeX = LaTeX + Convert.ToString(limcaos[d]);
}
}
//Console.WriteLine("FuZhiFeature:处理的差不多了LaTeX:" + LaTeX);
//============================================1、需要弄一系列特征，和杨颂强依次对应比较============================================
List <NodeInfo> temps = exputil.GetNodeList(LaTeX, 0);
if (finalList1[finalList1.Count - 1].zifu.Equals("\\join") || finalList1[finalList1.Count - 1].zifu.Equals("\\connect"))//如果最后一个元素是“\\join”或者是“\\connect”
{
List <FinalNode1> tempFinalist = new List <FinalNode1>();
for (int e = 0; e < finalList1.Count - 1; e++)
{
tempFinalist.Add(finalList1[e]);
}
finalList1 = tempFinalist;
}
/*foreach (var it in temps)
* {
* Console.WriteLine("FuZhiFeature.cs:杨颂强字符:" + it.nodeexp + "Level：" + it.level + "Flag:" + it.flag);
* }
*
* foreach (var itt in finalList1)
* {
* Console.WriteLine("FuZhiFeature.cs:我的字符:" + itt.zifu + "Level：" + itt.Level + "Flag:" + itt.Flag);
* }*/
//Console.WriteLine("需要弄一系列特征的打印结果，所以先按原始序号，因此需要按照杨颂强那个顺序依次进行比较");
int c = 0;
for (int a = 0; a < finalList1.Count; a++)//外层循环肯定是LaTeX表达式，因为它里面字符多，比如有一些上标^,下标_在杨颂强里面没有解析
{
if (temps[c].nodeexp.Equals("(") || temps[c].nodeexp.Equals(")") || temps[c].nodeexp.Equals("[") || temps[c].nodeexp.Equals("]"))
{
//Console.WriteLine("执行了没啊:");
c++;
a--;
continue;
}
else if (finalList1[a].zifu.Equals(temps[c].nodeexp))//如果LaTeX字符与杨颂强节点字符相等，把杨颂强对应特征传进我的LaTeX对应节点里面
{
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
c++;
}
else if (finalList1[a].zifu.Equals("^") || finalList1[a].zifu.Equals("_"))//如果不相等，说明肯定遇到了类似“上标”或者“下标”，到时候再添加
{
//既然遇到了“上标”或者“下标”，那就对它进行处理么
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
Console.WriteLine("现在字符：" + finalList1[a].zifu + "\t" + "杨颂强字符：" + temps[c].nodeexp);
}
//这个是下面那个含有以谁为底，以其它为对数的
else if (finalList1[a].zifu.Equals("\\temp") && temps[c].nodeexp.Equals("\\log") && temps[c + 1].flag == 4)
{
//Console.WriteLine("怎么不能执行呢？");
finalList1[a].zifu = temps[c].nodeexp;
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
c++;
}
//实际上没有下面的这个判断也行啊，也就是弄了半天，我就是把原来那个要解析的杨颂强的那个\\lim_这个极限符号给它加个下划线“_”，这样才能解析得到杨颂强的各项特征
//从而把各项特征传过来，传到我的这里啊
else if (finalList1[a].zifu.Equals("\\join") || finalList1[a].zifu.Equals("\\connect") || finalList1[a].zifu.Equals("\\PowerRoot"))
{
continue;
}
else if (a == finalList1.Count - 1 && finalList1[a].zifu.Equals("\\negative"))
{
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
c++;
}
else if (finalList1[a].zifu.Equals("\\negative") && finalList1[a + 1].zifu.Equals("*"))
{
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
finalList1[a + 1].Level = temps[c].level;
finalList1[a + 1].Flag = temps[c].flag;
finalList1[a + 1].Length = finalList1.Count;
a++;
c++;
}
else if (a < finalList1.Count - 1 && finalList1[a].zifu.Equals("\\negative") && !finalList1[a + 1].zifu.Equals("*"))
{
finalList1[a].Level = temps[c].level;
finalList1[a].Flag = temps[c].flag;
finalList1[a].Length = finalList1.Count;
c++;
}
}
//用个栈来存放\lim元素，类似于左括号，我的\join是右括号
Stack <FinalNode1> stack = new Stack <FinalNode1>();
foreach (var it in finalList1)
{
if (it.zifu.Equals("\\lim"))//相当于左括号
{
stack.Push(it);
}
else if (it.zifu.Equals("\\join"))//相当于右括号,遇到右括号的话
{
FinalNode1 tem = new FinalNode1();
tem = stack.Pop();//把栈里面的\lim给弹出来
it.Level = tem.Level;
it.Flag = tem.Flag;
}
}
/*foreach (var it in finalList1)
* {
* Console.WriteLine("FuZhiFeature.cs就差\\sum了啊:" + it.zifu + "\t" + "Level:" + it.Level + "\t" + "Flag:" + it.Flag);
* }*/
//用个栈来存放\sum元素，类似于左括号，我的“^”是右括号，先这么个简单的啊，我这里规定\sum的那个connect是与“上标的那个特征是一样的”
Stack <FinalNode1> stack1 = new Stack <FinalNode1>();
foreach (var it in finalList1)
{
if (it.zifu.Equals("\\sum"))//相当于左括号
{
//Console.WriteLine("==========尼玛执行了吗1");
stack1.Push(it);
continue;
}
else if (stack1.Count == 1 && it.zifu.Equals("^") && stack1.Peek().zifu.Equals("\\sum"))
{
//Console.WriteLine("草你妈了个比");
stack1.Push(it);
continue;
}
else if (stack1.Count == 2 && it.zifu.Equals("\\connect") && stack1.Peek().zifu.Equals("^"))//此时仅仅有\\sum和第一个“^”
{
//Console.WriteLine("====================================尼玛执行了吗3");
FinalNode1 tem = new FinalNode1();
tem = stack1.Pop();//把栈里面的"^"给弹出来
it.Level = tem.Level;
it.Flag = tem.Flag;
Console.WriteLine("第三个：字符" + it.zifu + "\t" + "空间标志位：" + it.Flag + "\t" + "第三个：字符" + tem.zifu + "\t" + "空间标志位：" + tem.Flag);
stack1.Pop();
continue;
}
}
/*foreach (var itt in finalList1)
* {
* Console.WriteLine("FuZhiFeature.cs:我的字符:" + itt.zifu + "Level：" + itt.Level + "Flag:" + itt.Flag);
* }*/
//用个栈来存放\sqrt元素，类似于左括号，我的\PowerRoot是右括号
Stack <FinalNode1> stack2 = new Stack <FinalNode1>();
for (int i = 0; i < finalList1.Count; i++)
{
if (finalList1[i].zifu.Equals("\\sqrt") && finalList1[i + 1].Flag == 7)//当前是根号，且和它相邻的下一个的字符flag为左上标，说明当前的这个根号是N次方根的那种
{
//Console.WriteLine("压入了几次啊");
stack2.Push(finalList1[i]);
}
else if (finalList1[i].zifu.Equals("\\PowerRoot"))//相当于右括号,遇到右括号的话
{
FinalNode1 tem = new FinalNode1();
tem = stack2.Pop();//把栈里面的\\PowerRoot给弹出来
finalList1[i].Level = tem.Level;
finalList1[i].Flag = tem.Flag;
}
}
//用个栈来存放\sqrt元素，类似于左括号，我的\PowerRoot是右括号
/*Stack<FinalNode1> stack2 = new Stack<FinalNode1>();
* foreach (var it in finalList1)
* {
* if (it.zifu.Equals("\\sqrt"))//相当于左括号
* {
* stack2.Push(it);
* }
* else if (it.zifu.Equals("\\join"))//相当于右括号,遇到右括号的话
* {
* FinalNode1 tem = new FinalNode1();
* tem = stack2.Pop();//把栈里面的\lim给弹出来
* it.Level = tem.Level;
* it.Flag = tem.Flag;
* }
* }*/
//foreach (var it in finalList1)
//{
// Console.WriteLine("FuZhiFeature.cs:"+it.zifu+"\t"+"Level:"+it.Level+"\t"+"Flag:"+it.Flag);
//}
}//含有特殊字符lim和sum的处理啊
//else if (LaTeX.Contains("\\negative"))
//{
// LaTeX = LaTeX.Replace("\\negative*", "-");
// LaTeX = LaTeX.Replace("\\negative", "-");
// List<NodeInfo> temps = exputil.GetNodeList(LaTeX, 0);
// foreach (var it in temps)
// {
// Console.WriteLine("FuZhiFeature.cs:杨颂强字符:" + it.nodeexp + "Level：" + it.level + "Flag:" + it.flag);
// }
// foreach (var itt in finalList1)
// {
// Console.WriteLine("FuZhiFeature.cs:我的字符:" + itt.zifu + "Level：" + itt.Level + "Flag:" + itt.Flag);
// }
// int c = 0;
// for (int a = 0; a < finalList1.Count; a++)//外层循环肯定是LaTeX表达式，因为它里面字符多，比如有一些上标^,下标_在杨颂强里面没有解析
// {
// if (finalList1[a].zifu.Equals(temps[c].nodeexp))//如果LaTeX字符与杨颂强节点字符相等，把杨颂强对应特征传进我的LaTeX对应节点里面
// {
// finalList1[a].Level = temps[c].level;
// finalList1[a].Flag = temps[c].flag;
// finalList1[a].Length = finalList1.Count;
// c++;
// }
// else if (finalList1[a].zifu.Equals("^") || finalList1[a].zifu.Equals("_"))//如果不相等，说明肯定遇到了类似“上标”或者“下标”，到时候再添加
// {
// //既然遇到了“上标”或者“下标”，那就对它进行处理么
// finalList1[a].Level = temps[c].level;
// finalList1[a].Flag = temps[c].flag;
// finalList1[a].Length = finalList1.Count;
// }
// //下面这种情况是数学表达式：“-\\frac{a}{b}”，对应的
// /*
// 我： \negative * \frac a b
// 杨： - \frac a b
// */
// else if (a == finalList1.Count - 1 && finalList1[a].zifu.Equals("\\negative"))
// {
// finalList1[a].Level = temps[c].level;
// finalList1[a].Flag = temps[c].flag;
// finalList1[a].Length = finalList1.Count;
// c++;
// }
// else if (finalList1[a].zifu.Equals("\\negative") && finalList1[a + 1].zifu.Equals("*"))
// {
// finalList1[a].Level = temps[c].level;
// finalList1[a].Flag = temps[c].flag;
// finalList1[a].Length = finalList1.Count;
// finalList1[a + 1].Level = temps[c].level;
// finalList1[a + 1].Flag = temps[c].flag;
// finalList1[a + 1].Length = finalList1.Count;
// a++;
// c++;
// }
// else if (a<finalList1.Count-1 && finalList1[a].zifu.Equals("\\negative") && !finalList1[a + 1].zifu.Equals("*"))
// {
// finalList1[a].Level = temps[c].level;
// finalList1[a].Flag = temps[c].flag;
// finalList1[a].Length = finalList1.Count;
// c++;
// }
// }
//}
else
{
LaTeX = LaTeX.Replace("\\negative*", "-");
LaTeX = LaTeX.Replace("\\negative", "-");
LaTeX = LaTeX.Replace("\\PowerRoot", "");
LaTeX = LaTeX.Replace("\\DuiShu", "");
LaTeX = LaTeX.Replace("\\temp", "\\log_");
//Console.WriteLine("FuZhiFeature.cs:卧槽===========:" + LaTeX);
//======================================下面这个是最一般字符的处理，不用管了，之前已经验证了========================================================
//============================================1、需要弄一系列特征，和杨颂强依次对应比较============================================
List <NodeInfo> temp = exputil.GetNodeList(LaTeX, 0);
//Console.WriteLine("草拟吗："+LaTeX);
/*foreach (var it in temp)
* {
* Console.WriteLine("FuZhiFeature.cs:杨颂强字符:" + it.nodeexp + "Level：" + it.level + "Flag:" + it.flag);
* }
*
* foreach (var itt in finalList1)
* {
* Console.WriteLine("FuZhiFeature.cs:我的字符:" + itt.zifu + "Level：" + itt.Level + "Flag:" + itt.Flag);
* }*/
//Console.WriteLine("需要弄一系列特征的打印结果，所以先按原始序号，因此需要按照杨颂强那个顺序依次进行比较");
int b = 0;
for (int a = 0; a < finalList1.Count; a++)//外层循环肯定是LaTeX表达式，因为它里面字符多，比如有一些上标^,下标_在杨颂强里面没有解析
{
if (temp[b].nodeexp.Equals("(") || temp[b].nodeexp.Equals(")") || temp[b].nodeexp.Equals("[") || temp[b].nodeexp.Equals("]"))
{
//Console.WriteLine("执行了没啊:");
b++;
a--;
continue;
}
else if (finalList1[a].zifu.Equals(temp[b].nodeexp))//如果LaTeX字符与杨颂强节点字符相等，把杨颂强对应特征传进我的LaTeX对应节点里面
{
finalList1[a].Level = temp[b].level;
finalList1[a].Flag = temp[b].flag;
finalList1[a].Length = finalList1.Count;
b++;
/////////////////////////////////////////////Console.WriteLine("第一个b"+b);
}
//=======================================！！！！！！！！！！！！！！！！！！！！下面这个是改上下标啊=================================================
else if (finalList1[a].zifu.Equals("^") || finalList1[a].zifu.Equals("_"))//如果不相等，说明肯定遇到了类似“上标”或者“下标”，到时候再添加
{
//既然遇到了“上标”或者“下标”，那就对它进行处理么
/////////////////////////////////Console.WriteLine("================b"+b);
//Console.WriteLine("原始字符："+finalList1[a].zifu);
// Console.WriteLine("杨颂强字符：" + temp[b].nodeexp);
finalList1[a].Level = temp[b - 1].level;
finalList1[a].Flag = temp[b - 1].flag;
finalList1[a].Length = finalList1.Count;
//////////////////////////////////Console.WriteLine("FuZhiFeature.cs第二个：原始字符"+ finalList1[a].zifu + "\t" + "空间标志为：" + finalList1[a].Flag + "第二个：杨颂强字符" + temp[b].nodeexp + "\t" + "空间标志为：" + temp[b].flag);
}
//=======================================！！！！！！！！！！！！！！！！！下面这个是改上下标啊=================================================
else if (a == finalList1.Count - 1 && finalList1[a].zifu.Equals("\\negative"))
{
finalList1[a].Level = temp[b].level;
finalList1[a].Flag = temp[b].flag;
finalList1[a].Length = finalList1.Count;
b++;
}
else if (finalList1[a].zifu.Equals("\\negative") && finalList1[a + 1].zifu.Equals("*"))
{
finalList1[a].Level = temp[b].level;
finalList1[a].Flag = temp[b].flag;
finalList1[a].Length = finalList1.Count;
finalList1[a + 1].Level = temp[b].level;
finalList1[a + 1].Flag = temp[b].flag;
finalList1[a + 1].Length = finalList1.Count;
a++;
b++;
}
else if (a < finalList1.Count - 1 && finalList1[a].zifu.Equals("\\negative") && !finalList1[a + 1].zifu.Equals("*"))
{
finalList1[a].Level = temp[b].level;
finalList1[a].Flag = temp[b].flag;
finalList1[a].Length = finalList1.Count;
b++;
}
else if (finalList1[a].zifu.Equals("\\temp") && temp[b].nodeexp.Equals("\\log") && temp[b + 1].flag == 4)
{
//Console.WriteLine("怎么不能执行呢？");
finalList1[a].zifu = temp[b].nodeexp;
finalList1[a].Level = temp[b].level;
finalList1[a].Flag = temp[b].flag;
finalList1[a].Length = finalList1.Count;
b++;
}
else if (finalList1[a].zifu.Equals("\\PowerRoot") || finalList1[a].zifu.Equals("\\DuiShu"))
{
continue;
}
}
//用个栈来存放\sqrt元素，类似于左括号，我的\PowerRoot是右括号
Stack <FinalNode1> stack2 = new Stack <FinalNode1>();
for (int i = 0; i < finalList1.Count; i++)
{
if (finalList1[i].zifu.Equals("\\sqrt") && finalList1[i + 1].Flag == 7)//当前是根号，且和它相邻的下一个的字符flag为左上标，说明当前的这个根号是N次方根的那种
{
stack2.Push(finalList1[i]);
}
else if (finalList1[i].zifu.Equals("\\PowerRoot"))//相当于右括号,遇到右括号的话
{
FinalNode1 tem = new FinalNode1();
tem = stack2.Pop();//把栈里面的\lim给弹出来
finalList1[i].Level = tem.Level;
finalList1[i].Flag = tem.Flag;
}
}
}//一般字符
return(finalList1);
}
//重新写结构
public void WriteStructure()
{
StreamReader sr = new StreamReader("C:\\Users\\dell\\Desktop\\暑假\\实验数据\\1.txt", Encoding.Default);
StreamWriter sw = new StreamWriter("C:\\Users\\dell\\Desktop\\暑假\\实验数据\\2.txt");
String read = sr.ReadLine();
while (read != null)
{
//开始层次遍历
Dictionary <int, List <String> > dic = new Dictionary <int, List <string> >();
BinaryTreeNode bnode = new BinaryTreeNode();
FinalNode1 root = new FinalNode1();
FinalNode1 tempNode = new FinalNode1();
root = bnode.getNode(read);
root.xuhao = 1;
tempNode = root;//临时指向根结点
Queue <FinalNode1> q = new Queue <FinalNode1>();
q.Enqueue(root);
while (q.Count != 0)
{
//指向队列第一个字符
tempNode = q.First();
if (dic.Count == 0)
{
List <String> list = new List <string>();
list.Add(tempNode.zifu + "1" + "1");
dic.Add(tempNode.BTreeLevel, list);
}
else
{
if (dic.ContainsKey(tempNode.BTreeLevel))
{
if (isOperator(tempNode.zifu))
{
dic[tempNode.BTreeLevel].Add(tempNode.zifu + tempNode.BTreeLevel + tempNode.xuhao);
}
else
{
dic[tempNode.BTreeLevel].Add("$" + tempNode.BTreeLevel + tempNode.xuhao);
}
}
else
{
if (isOperator(tempNode.zifu))
{
List <String> list = new List <string>();
list.Add(tempNode.zifu + tempNode.BTreeLevel + tempNode.xuhao);
dic.Add(tempNode.BTreeLevel, list);
}
else
{
List <String> list = new List <string>();
list.Add("$" + tempNode.BTreeLevel + tempNode.xuhao);
dic.Add(tempNode.BTreeLevel, list);
}
}
}
//第一个节点出队
q.Dequeue();
if (tempNode.left != null)
{
tempNode.left.xuhao = tempNode.xuhao * 2;
//Console.WriteLine("++++++++++++++left" + tempNode.left.xuhao);
q.Enqueue(tempNode.left);
}
if (tempNode.right != null)
{
tempNode.right.xuhao = tempNode.xuhao * 2 + 1;
//Console.WriteLine("++++++++++++++" + tempNode.right.xuhao);
q.Enqueue(tempNode.right);
}
}
//开始写了
String str = null;
foreach (var it in dic)
{
String text = "";
foreach (var itt in it.Value)
{
text = text + itt;
}
str = str + text + "#";
}
str = str + read;
Console.WriteLine("结果为：" + str);
sw.WriteLine(str);
read = sr.ReadLine();
}//读取内容
sw.Flush();
}
