中缀表达式java构造递归_通过不断迭代，编写<通过中缀表达式，构造表达式树>的代码...

1 import java.util.*;2

3 public classdemo {4 public static voidmain(String args[]){5

6 /*tree.Express2BTree("((3*4)/(1+2))*((1+1)/(1-2))");7 System.out.println(tree);*/

8 BTtree tree=newBTtree();9 tree.splitCh=' ';10 Scanner scan;11 int flag=10;12 while(flag>0){13 flag--;14 scan=new Scanner(System.in);//generate input flu

15 System.out.print("请输入中缀表达式: ");//input reminder

16 String str=new String(scan.nextLine());//assignment

17 tree.Express2BTree(str);18 System.out.println("前缀表达式: ");//input reminder

19 tree.PreOrderTraversal();20 System.out.println("后缀表达式: ");//input reminder

21 tree.PostOrderTraversal();22 }23 scan=newScanner(System.in);24 scan.close();25

26 }27 }28

29 class BTtree{//二叉树类

30 class BTNode{//节点类

31 String data=new String("0");32 BTNode lChild=null;33 BTNode rChild=null;34 boolean LTag=false;//=0 : 指向左孩子。 =1 : 指向前驱

35 boolean RTag=false;//=0 : 指向右孩子。 =1 : 指向后继

36 int height=1; //用于AVL树

37 BTNode(){}38 BTNode(String data){this.data=data;}39 BTNode(int num){this.data=Integer.toString(num);};40 }41 voidExpress2BTree(String str){42 root=Express2BTreeProc(str);43 }44 privateBTNode Express2BTreeProc(String str){45 inti;46 //首尾括号剥夺

47 if(str.length()>1 && str.charAt(0)=='(' && str.charAt(str.length()-1)==')'){48 String tmp=str.substring(1, str.length()-1);49 //是否存在括号内字符？

50 boolean haveInnerChar=false;51 int inBracket=0;52 for(i=0;i

57 haveInnerChar=true;58 }59 }60 if(!haveInnerChar) str=tmp;61 }62 BTNode parent=newBTNode();63

64 boolean isSet[]={false,false}; //【0】:left，【1】:right65 //boolean havaAddOrSub = ( str.indexOf("+")<0 || str.indexOf("-")<0 ) ? false : true;

66

67 boolean only_Have_Priority=false;68 int inBracket=0; //判断当前字符是否在括号中

69

70 /*if(( str.indexOf("+")<0 && str.indexOf("-")<0 )71 &&72 ( str.indexOf("*")>=0 || str.indexOf("/")>=0 ))73 only_Have_Priority=true;*/

74 boolean havaMulti=false;75 boolean havaAdd=false;76 for(i=0;i

81 if(ch=='*' || ch == '/') havaMulti=true;82 else if(ch=='-' || ch == '+') havaAdd=true;83 }84 }85 if((!havaAdd) && (havaMulti)) only_Have_Priority=true;86 //能够找到 * / 、不能找到 + -

87

88 inBracket=0;89

90 String tmp=new String(); //临时字符串

91

92 for(i=0;i

94 if(ch=='('){95 tmp+=ch;//括号内的括号

96 inBracket++;97 }98 else if(ch==')'){99 inBracket--;100 tmp+=ch;101 }102 else if( (ch>=48 && ch<=57)103 || isSet[0]104 || ((!only_Have_Priority)&&(ch=='*' || ch=='/')) //不存在(只有1*2)，也就是1*2+3

105 || inBracket>0){106 tmp+=ch;107 }108 else if(ch=='+' || ch=='-' || ch=='*' || ch=='/'){109 parent.data=String.valueOf(ch);110 if(! isSet[0]){ //左子树未构造

111 isSet[0]=true;112 parent.lChild=Express2BTreeProc(tmp);113 tmp=new String(""); //归零初始化

114 }115 }116 }117

118 if(isSet[0] && (! isSet[1])){//右子树未构造

119 isSet[1]=true;120 parent.rChild=Express2BTreeProc(tmp);121 tmp=new String(""); //归零初始化

122 }123 if(! isSet[0]) parent.data=tmp;//如果函数处理的全是数字(叶子节点)，那么就返回叶子节点

124 returnparent;125 }126

127 protected BTNode root=newBTNode();128 BTtree(){129 }130 BTtree(intlayer){131 //用队列的方式构造n层树

132 List queue=new ArrayList();133 int front=0;134 int rear=0;//队尾插入

135 queue.add(root);//初始化入队

136 rear++;137 int i , k=0, j;138 for(j=0;j

142 BTNode parent=queue.get(front++);143 BTNode lChild=newBTNode();144 lChild.data=Integer.toString(++k);145 BTNode rChild=newBTNode();146 rChild.data=Integer.toString(++k);147 parent.lChild=lChild;148 parent.rChild=rChild;149 queue.add(lChild);150 rear++;151 queue.add(rChild);152 rear++;153 }154 }155 }156 BTtree(String express){//通过中缀表达式进行构造157 //1.对表达式进行括号补全。

158

159

160 }161 public String toString(){//重写打印函数

162 String padding=new String(" ");163 List queue=new ArrayList();164 List PrintList=new ArrayList();165 int front=0;166 int rear=0;//队尾插入

167 queue.add(root);//初始化入队

168 rear++;169 int i , k=0, j;170

171 String emptySignal=new String("");//空信号

172

173 String str[]=new String[1];174 str[0]=root.data;175 PrintList.add(str);//打印数据结构初始化

176 int layer=1;//下一层字符串的数目是2^1=2。

177 int pos=0;178

179 boolean flag=true;180 ok:181 while(flag){182 pos=0;//pos初始化

183 String tmp[]=new String[(int)Math.pow((int)2, (int)(layer++))];//length=2^layer

184 flag=false; //循环标志初始化

185 int nowRear=rear;186 int nowFront=front;187 for(i=front;i

191 if(parent.data.equals(emptySignal)){//如果是空的，派生出两个空孩子

192 for(int t=0;t<2;t++){193 tmp[pos++]=padding;194 BTNode empty=newBTNode();195 empty.data=emptySignal;196 queue.add(empty);rear++;197 }198 }else{199 if(parent.lChild!=null){200 flag=true; //只要这一层存在孩子，就可以继续循环下去。

201 queue.add(parent.lChild);202 tmp[pos++]=parent.lChild.data;203 rear++;204 }else{205 tmp[pos++]=padding;206 BTNode empty=newBTNode();207 empty.data=emptySignal;208 queue.add(empty);209 rear++;210 }211 if(parent.rChild!=null){212 flag=true;213 queue.add(parent.rChild);214 tmp[pos++]=parent.rChild.data;215 rear++;216 }else{217 tmp[pos++]=padding;218 BTNode empty=newBTNode();219 empty.data=emptySignal;220 queue.add(empty);221 rear++;222 }223 }224 } //end of for

225 PrintList.add(tmp);226 } //end of while

227 /*

228 for(i=0;i

232 //后处理

233 String[] PrintListLine=new String[PrintList.size()-1];234 for(i=PrintListLine.length-1;i>=0;i--){//循环构造235 //首先进行构造

236 String tmp=newString();237 for(j=0;j=0;i--){//居中操作

244 int spaceNum=(PrintListLine[i+1].length()-PrintListLine[i].length())/2;245 String space=newString();246 for(int t=0;t

251 outStr+=PrintListLine[i]+"\n";252 }253 returnoutStr;254 }255 voidPreOrderTraversal(){256 PreOrder(root);257 System.out.println();258 }259 char splitCh=',';260 private voidPreOrder(BTNode obj){261 if(obj!=null){262 System.out.print(obj.data+splitCh);263 PreOrder(obj.lChild);264 PreOrder(obj.rChild);265 }266 }267 voidInOrderTraversal(){268 InOrder(root);269 System.out.println();270 }271 private voidInOrder(BTNode obj){272 if(obj!=null){273 InOrder(obj.lChild);274 System.out.print(obj.data+splitCh);275 InOrder(obj.rChild);276 }277 }278 voidPostOrderTraversal(){279 PostOrder(root);280 System.out.println();281 }282 private voidPostOrder(BTNode obj){283 if(obj!=null){284

285 InOrder(obj.lChild);286 InOrder(obj.rChild);287 System.out.print(obj.data+splitCh);288 }289 }290 }291

292

293

294 //线索二叉树

295 class BThrTree extendsBTtree{296 BThrTree(BTtree obj){//由父类构造而来297 //首先拷贝根节点

298 BTNode tmp=newBTNode();299 tmp.data=obj.root.data;300 copy(root,obj.root);301 }302 voidcopy(BTNode node1,BTNode node2){303 if(node2.lChild!=null){//左树递归

304 BTNode l=newBTNode();305 l.data=node2.lChild.data;//拷贝左树

306 node1.lChild=l;//左树赋值

307 copy(node1.lChild,node2.lChild);308 }309 if(node2.rChild!=null){//右树递归

310 BTNode r=newBTNode();311 r.data=node2.rChild.data;//拷贝右树

312 node1.rChild=r;//右树赋值

313 copy(node1.rChild,node2.rChild);314 }315 }316 public void InThreadingFabric(){//中序线索化构造

317 BTNode now=root;318 InThreading(now);319 pre.RTag=true;//【最后一个后继为null】

320 pre.rChild=null;321 }322 private BTNode pre=null;//前驱指针

323 private void InThreading(BTNode node){//中序线索化递归

324 if(node!=null){//保证节点非空

325 InThreading(node.lChild);//左子树线索化

326 if(node.lChild==null){//如果左子树不存在

327 node.LTag=true;//线索化

328 node.lChild=pre;//前驱 【第一个前驱为null】

329 }330 if(pre!=null && pre.rChild==null){//后继

331 pre.RTag=true;332 pre.rChild=node;333 }334 pre=node;//保持pre指向node的前驱。

335 InThreading(node.rChild);//左子树线索化

336 }337 }338 void InOrderTraversal_Thr(){//线索化遍历

339 BTNode now=root;340 //遍历前驱

341 while(now.lChild!=null){//要么有左子树。

342 now=now.lChild;343 }344 while(now!=null){//要么有左子树。

345 System.out.print(now.data+",");346 if(now.RTag){now=now.rChild;}//如果是后继，就继续后继。

347 else{348 now=now.rChild;//如果不是，则令右子树的最左节点为后继

349 while(!now.LTag) now=now.lChild;350 }351 }352 System.out.println();353 }354 }355

356

357 class SearchBST extends BTtree{//二叉查找树

358 SearchBST(int[] nums){//由二维数组构造

359 root.data=String.valueOf(nums[0]);//构造根节点

360 for(int i=1;i

361 BTNode node=newBTNode();362 node.data=String.valueOf(nums[i]);//构造叶子节点

363 BTNode parent=root;364 int nodeV=nums[i];365 while(parent!=null){366 int parentV=Integer.valueOf(parent.data).intValue();//当前根节点的值

367 if(nodeV

368 if(parent.lChild==null){//当前根节点的左叶子非空

369 parent.lChild=node;//挂入节点

370 break; //如果这里没有加【break】，就会死循环。待解决☆☆☆

371 }372 parent=parent.lChild;//如果这里空了，跳出循环

373 }else{374 if(parent.rChild==null){375 parent.rChild=node;//挂入节点

376 break; //☆☆☆

377 }378 parent=parent.rChild;//如果这里空了，跳出循环

379 }380 }381 }382 }383 SearchBST(){}384 }385

386 class AVLTree extends BTtree{ //平衡二叉树

387 AVLTree(int[] nums){//由二维数组构造

388 root.data=String.valueOf(nums[0]);389 for(int i=1;i

392 /*

393 * 根节点的左孩子 为新的根节点。394 * 老根节点成为新根节点的右孩子395 * 根节点的左孩子 的右子树作为 老根节点的左子树396 */

397 BTNode pre=node;398 node=node.lChild;//根节点的左孩子 为新的根节点。399 //从此之后node就是【根节点的左孩子】

400 pre.lChild=node.rChild;//根节点的左孩子(node) 的右子树作为 老根节点(pre)的左子树

401 node.rChild=pre;402 //pre: 老根节点

403 pre.height=Math.max(getHeight(pre.lChild), getHeight(pre.rChild))+1;//递归增加树的高度

404 node.height=Math.max(getHeight(node.lChild), getHeight(node.rChild))+1;//递归增加树的高度

405 return node;//返回根节点

406 }407

408 BTNode RRRotate(BTNode node){//左子树.高度-右子树.高度==-2 【向左旋转】

409 /*

410 * 根节点的左孩子 为新的根节点。411 * 老根节点成为新根节点的右孩子412 * 根节点的左孩子 的右子树作为 老根节点的左子树413 */

414 BTNode pre=node;415 node=node.rChild;//根节点的右孩子 为新的根节点。416 //从此之后node就是【根节点的左孩子】

417 pre.rChild=node.lChild;//根节点的左孩子(node) 的右子树作为 老根节点(pre)的左子树

418 node.lChild=pre;419 //pre: 老根节点

420 pre.height=Math.max(getHeight(pre.lChild), getHeight(pre.rChild))+1;//递归增加树的高度

421 node.height=Math.max(getHeight(node.lChild), getHeight(node.rChild))+1;//递归增加树的高度

422 returnnode;423 }424

425 BTNode LRRotate(BTNode node){//左子树.高度-右子树.高度==2 【向右旋转】

426 node.lChild=RRRotate(node.lChild);427 node=LLRotate(node);428 returnnode;429 }430

431 BTNode RLRotate(BTNode node){//左子树.高度-右子树.高度==2 【向右旋转】

432 node.rChild=LLRotate(node.rChild);433 node=RRRotate(node);434 returnnode;435 }436 //当前节点 父节点

437 void AVLinsert(BTNode node,BTNode parent,booleanisLeft,String data){438 int dataV=Integer.valueOf(data).intValue();439 int nodeV=0;440 if(node!=null) nodeV=Integer.valueOf(node.data).intValue();441 if(node==null){442 BTNode newNode=newBTNode();443 newNode.data=data;444 if(isLeft) parent.lChild=newNode;445 else parent.rChild=newNode;446 }447

448 else if(dataV

449 AVLinsert(node.lChild,node,true,data);450 node.height=Math.max(getHeight(node.lChild), getHeight(node.rChild))+1;//递归增加树的高度

451

452 System.out.println("sub="+(getHeight(node.lChild)-getHeight(node.rChild)));453 System.out.println("node="+node.data);454

455 if(getHeight(node.lChild)-getHeight(node.rChild)==2){456 System.out.println("L变形前\n"+this);457 if(getHeight(node.lChild.lChild)>getHeight(node.lChild.rChild)){458 System.out.println("LL");459 boolean flag=false;460 if(root.data.equals(node.data)) flag=true;461 if(!flag){462 if(isLeft) parent.lChild=LLRotate(node);463 else parent.rChild=LLRotate(node);464 }else node=LLRotate(node);465 if(flag) root=node;466 }else{467 System.out.println("LR");468 boolean flag=false;469 if(root.data.equals(node.data)) flag=true;470 if(!flag){471 if(isLeft) parent.lChild=LRRotate(node);472 else parent.rChild=LRRotate(node);473 }else node=LRRotate(node);474 if(flag) root=node;475 }476 System.out.println("变形后\n"+this);477 }478 System.out.println(this);479

480 }else{481 AVLinsert(node.rChild,node,false,data);482 node.height=Math.max(getHeight(node.lChild), getHeight(node.rChild))+1;//递归增加树的高度

483

484 System.out.println("sub="+(getHeight(node.lChild)-getHeight(node.rChild)));485 System.out.println("node="+node.data);486

487 if(getHeight(node.lChild)-getHeight(node.rChild)==-2){488 System.out.println("R变形前\n"+this);489 if(getHeight(node.rChild.lChild)>getHeight(node.rChild.rChild)){490 System.out.println("RL");491 boolean flag=false;492 if(root.data.equals(node.data)) flag=true;493 if(!flag){494 if(isLeft) parent.lChild=RLRotate(node);495 else parent.rChild=RLRotate(node);496 }else node=RLRotate(node);497 if(flag) root=node;498 }else{499 System.out.println("RR");500 boolean flag=false;501 if(root.data.equals(node.data)) flag=true;502 if(!flag){503 if(isLeft) parent.lChild=RRRotate(node);504 else parent.rChild=RRRotate(node);505 }else node=RRRotate(node);506 if(flag) root=node;507 }508 System.out.println("变形后\n"+this);509 }510 System.out.println(this);511 }512 }513

514 intgetHeight(BTNode node){515 if(node!=null){516 returnnode.height;517 }else{518 return 0;519 }520 }521 voidtest(){522 root=new BTNode(0);523 BTNode node[]=new BTNode[3];524 for(int i=0;i<3;i++) node[i]=new BTNode(i+1);525 root.lChild=node[0];526 root.lChild.rChild=node[1];527 root.lChild.lChild=node[2];528 System.out.println(this);529 root=LRRotate(root);530 System.out.println(this);531 System.out.println(root.height);532 System.out.println(root.lChild.height);533 System.out.println(root.rChild.height);534 }535 AVLTree(){}536 }