码迷,mamicode.com
首页 > 其他好文 > 详细

通过不断迭代,编写<通过中缀表达式,构造表达式树>的代码

时间:2017-10-07 17:39:28      阅读:200      评论:0      收藏:0      [点我收藏+]

标签:www.   ima   ted   sub   bst   混淆   表达式树   数组   其他   

 

今天要练习的算法是通过中缀表达式生成表达式树。中缀、前缀、后缀表达式的概念就不赘述了,学习链接:中缀、前缀、后缀表达式

参考代码学习链接:表达式树—中缀表达式转换成后缀表达式(一)

 

 


 

  • 【迭代 ①】:识别单个运算符,进行分割,通过递归的思想构建表达式树。

举例:输入“1+2”,输出技术分享

Java code of phase[1]:

 1     void Express2BTree(String str){
 2         root=Express2BTreeProc(str);
 3     }
 4     private BTNode Express2BTreeProc(String str){
 5         BTNode parent=new BTNode();
 6         boolean isSet[]={false,false};    //【0】:left,【1】:right
 7         String tmp=new String();        //临时字符串
 8         for(int i=0;i<str.length();i++){
 9             char ch=str.charAt(i);
10             if(ch>=48 && ch<=57){            //是数字
11                 tmp+=ch;
12             }
13             else if(ch==‘+‘ || ch==‘-‘ || ch==‘*‘ || ch==‘/‘){
14                 parent.data=String.valueOf(ch);
15                 if(! isSet[0]){            //左子树未构造
16                     isSet[0]=true;
17                     parent.lChild=Express2BTreeProc(tmp);
18                     tmp=new String("");    //归零初始化
19                 }
20             }
21         }
22         if(isSet[0] && (! isSet[1])){//右子树未构造
23             isSet[1]=true;
24             parent.rChild=Express2BTreeProc(tmp);
25             tmp=new String("");    //归零初始化
26         }
27         if(! isSet[0]) parent.data=tmp;//如果函数处理的全是数字(叶子节点),那么就返回叶子节点
28         return parent;
29     }

逻辑盲区:

1、启动构造右子树的 if  语句不能嵌套在上方的 if 中,否则不能触发。

2、数字0~9的ascii码是[ 48 , 57 ],故应写<=、>=。


 

  • 【迭代 ②】:判断多个表达式。

举例:输入“1+2+3”,输出:

技术分享

代码改进:在临时字符串递加段,加入【或】判断条件 isSet[0] ,如果左子树已构造,继续扫描、递加。

技术分享

 


 

  • 【迭代 ③】:识别优先级。*、/ 的优先级比+、- 的要高。

(在这里我修改了toString打印树函数,填充符由*变为space,避免混淆)

如果代码按原先的方式跑,结果是:

 技术分享

但是根据运算符优先级,应该是:

技术分享

修改两处代码:

1.递归函数中引入 only_Have_Priority 变量:

1         boolean only_Have_Priority=false;
2         if(( str.indexOf("+")<0 && str.indexOf("-")<0 )  
3                             &&
4         ( str.indexOf("*")>=0 || str.indexOf("/")>=0 ))
5             only_Have_Priority=true;
6         //能够找到 * / 、不能找到 + -

2.触发对表达式进行分割的判断语句中引入一个【与】判断条件:

((!only_Have_Priority)&&(ch==‘*‘ || ch==‘/‘))

完整代码:

Java code of phase[3]:

 1     void Express2BTree(String str){
 2         root=Express2BTreeProc(str);
 3     }
 4     private BTNode Express2BTreeProc(String str){
 5         BTNode parent=new BTNode();
 6         int i;
 7         boolean isSet[]={false,false};    //【0】:left,【1】:right
 8     //    boolean havaAddOrSub = ( str.indexOf("+")<0 || str.indexOf("-")<0 ) ? false : true;
 9         
10         boolean only_Have_Priority=false;
11         if(( str.indexOf("+")<0 && str.indexOf("-")<0 )  
12                             &&
13         ( str.indexOf("*")>=0 || str.indexOf("/")>=0 ))
14             only_Have_Priority=true;
15         //能够找到 * / 、不能找到 + -
16         
17         String tmp=new String();        //临时字符串
18         
19         for(i=0;i<str.length();i++){
20             char ch=str.charAt(i);    //是数字、或者左树已构造  || (havaAddOrSub && (ch==‘‘ || ch==‘-‘) )   
21             if( (ch>=48 && ch<=57 ) || isSet[0] || ((!only_Have_Priority)&&(ch==‘*‘ || ch==‘/‘))   ){
22                 tmp+=ch;
23             }
24             else if(ch==‘+‘ || ch==‘-‘ || ch==‘*‘ || ch==‘/‘){
25                 parent.data=String.valueOf(ch);
26                 if(! isSet[0]){            //左子树未构造
27                     isSet[0]=true;
28                     parent.lChild=Express2BTreeProc(tmp);
29                     tmp=new String("");    //归零初始化
30                 }
31             }
32         }

逻辑盲点:

技术分享

对 only_Have_Priority 进行赋值时,应该是【与】而不是或。想错了。

测试:

输入:1*2+3*4

输出:

技术分享

输入:1*2+3*4+5*6

输出:

技术分享


 

  • 【迭代 ④】:小括号的优先级应最高

 

 运行中出现bug。经查是原来的 only_Have_Priority  判断语句的不足。修改之。

加入了堆栈思想的括号判断语句。

Java code of phase[4]:

 1     void Express2BTree(String str){
 2         root=Express2BTreeProc(str);
 3     }
 4     private BTNode Express2BTreeProc(String str){
 5         BTNode parent=new BTNode();
 6         int i;
 7         boolean isSet[]={false,false};    //【0】:left,【1】:right
 8     //    boolean havaAddOrSub = ( str.indexOf("+")<0 || str.indexOf("-")<0 ) ? false : true;
 9         
10         boolean only_Have_Priority=false;
11         int inBracket=0;        //判断当前字符是否在括号中    
12                 
13         boolean havaMulti=false;
14         boolean havaAdd=false;
15         for(i=0;i<str.length();i++){
16             char ch=str.charAt(i);
17             if(ch==‘(‘) inBracket++;
18             else if(ch==‘)‘) inBracket--;
19             else if(inBracket==0){            //在括号内
20                 if(ch==‘*‘ || ch == ‘/‘) havaMulti=true;
21                 else if(ch==‘-‘ || ch == ‘+‘) havaAdd=true;
22             }
23         }
24         if((!havaAdd) && (havaMulti)) only_Have_Priority=true;
25         //能够找到 * / 、不能找到 + -
26         
27         inBracket=0;
28         
29         String tmp=new String();        //临时字符串
30         
31         for(i=0;i<str.length();i++){
32             char ch=str.charAt(i);    //是数字、或者左树已构造  
33             if(ch==‘(‘){
34                 if(inBracket>0) tmp+=ch;//括号内的括号
35                 inBracket++;
36             }
37             else if(ch==‘)‘){
38                 inBracket--;
39                 if(inBracket>0) tmp+=ch;
40             }
41             else if( (ch>=48 && ch<=57 ) 
42                     || isSet[0] 
43                     || ((!only_Have_Priority)&&(ch==‘*‘ || ch==‘/‘)) //不存在(只有1*2),也就是1*2+3
44                     || inBracket>0  ){
45                 tmp+=ch;
46             }
47             else if(ch==‘+‘ || ch==‘-‘ || ch==‘*‘ || ch==‘/‘){
48                 parent.data=String.valueOf(ch);
49                 if(! isSet[0]){            //左子树未构造
50                     isSet[0]=true;
51                     parent.lChild=Express2BTreeProc(tmp);
52                     tmp=new String("");    //归零初始化
53                 }
54             }
55         }
56         
57         if(isSet[0] && (! isSet[1])){//右子树未构造
58             isSet[1]=true;
59             parent.rChild=Express2BTreeProc(tmp);
60             tmp=new String("");    //归零初始化
61         }
62         if(! isSet[0]) parent.data=tmp;//如果函数处理的全是数字(叶子节点),那么就返回叶子节点
63         return parent;
64     }

测试输入:((3*4)/(1+2))*((1+1)/(1-2))

测试输出:

技术分享

测试输入:(1+2)*3

测试输出:

技术分享


 

【在一次测试中发现异常】:

输入:(1+2)*3-2

输出:

技术分享

然后改了一个小时bug。我的函数写的还是有问题,反正现在无论怎么输入,只要是一个正常的表达式,都没什么问题了。

修改BUG后代码:

技术分享
 1     void Express2BTree(String str){
 2         root=Express2BTreeProc(str);
 3     }
 4     private BTNode Express2BTreeProc(String str){
 5         int i;
 6         //首尾括号剥夺
 7         if(str.length()>1 && str.charAt(0)==‘(‘ && str.charAt(str.length()-1)==‘)‘){
 8             String tmp=str.substring(1, str.length()-1);
 9             //是否存在括号内字符?
10             boolean haveInnerChar=false;
11             int inBracket=0;    
12             for(i=0;i<str.length();i++){
13                 char ch=str.charAt(i);
14                 if(ch==‘(‘) inBracket++;
15                 else if(ch==‘)‘) inBracket--;
16                 else if(inBracket==0){            //在括号内
17                     haveInnerChar=true;
18                 }
19             }
20             if(!haveInnerChar) str=tmp;
21         }
22         BTNode parent=new BTNode();
23 
24         boolean isSet[]={false,false};    //【0】:left,【1】:right
25     //    boolean havaAddOrSub = ( str.indexOf("+")<0 || str.indexOf("-")<0 ) ? false : true;
26         
27         boolean only_Have_Priority=false;
28         int inBracket=0;        //判断当前字符是否在括号中    
29         
30 /*        if(( str.indexOf("+")<0 && str.indexOf("-")<0 )  
31                             &&
32         ( str.indexOf("*")>=0 || str.indexOf("/")>=0 ))
33             only_Have_Priority=true;*/
34         boolean havaMulti=false;
35         boolean havaAdd=false;
36         for(i=0;i<str.length();i++){
37             char ch=str.charAt(i);
38             if(ch==‘(‘) inBracket++;
39             else if(ch==‘)‘) inBracket--;
40             else if(inBracket==0){            //在括号内
41                 if(ch==‘*‘ || ch == ‘/‘) havaMulti=true;
42                 else if(ch==‘-‘ || ch == ‘+‘) havaAdd=true;
43             }
44         }
45         if((!havaAdd) && (havaMulti)) only_Have_Priority=true;
46         //能够找到 * / 、不能找到 + -
47         
48         inBracket=0;
49         
50         String tmp=new String();        //临时字符串
51         
52         for(i=0;i<str.length();i++){
53             char ch=str.charAt(i);    //是数字、或者左树已构造  
54             if(ch==‘(‘){
55                 tmp+=ch;//括号内的括号
56                 inBracket++;
57             }
58             else if(ch==‘)‘){
59                 inBracket--;
60                 tmp+=ch;
61             }
62             else if( (ch>=48 && ch<=57 ) 
63                     || isSet[0] 
64                     || ((!only_Have_Priority)&&(ch==‘*‘ || ch==‘/‘)) //不存在(只有1*2),也就是1*2+3
65                     || inBracket>0  ){
66                 tmp+=ch;
67             }
68             else if(ch==‘+‘ || ch==‘-‘ || ch==‘*‘ || ch==‘/‘){
69                 parent.data=String.valueOf(ch);
70                 if(! isSet[0]){            //左子树未构造
71                     isSet[0]=true;
72                     parent.lChild=Express2BTreeProc(tmp);
73                     tmp=new String("");    //归零初始化
74                 }
75             }
76         }
77         
78         if(isSet[0] && (! isSet[1])){//右子树未构造
79             isSet[1]=true;
80             parent.rChild=Express2BTreeProc(tmp);
81             tmp=new String("");    //归零初始化
82         }
83         if(! isSet[0]) parent.data=tmp;//如果函数处理的全是数字(叶子节点),那么就返回叶子节点
84         return parent;
85     }
View Code

完整代码:

技术分享
  1 import java.util.*;
  2 
  3 public class demo {
  4     public static void main(String args[]){
  5 
  6 /*        tree.Express2BTree("((3*4)/(1+2))*((1+1)/(1-2))");
  7         System.out.println(tree);*/
  8         BTtree tree=new BTtree();
  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=new Scanner(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     void Express2BTree(String str){
 42         root=Express2BTreeProc(str);
 43     }
 44     private BTNode Express2BTreeProc(String str){
 45         int i;
 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<str.length();i++){
 53                 char ch=str.charAt(i);
 54                 if(ch==‘(‘) inBracket++;
 55                 else if(ch==‘)‘) inBracket--;
 56                 else if(inBracket==0){            //在括号内
 57                     haveInnerChar=true;
 58                 }
 59             }
 60             if(!haveInnerChar) str=tmp;
 61         }
 62         BTNode parent=new BTNode();
 63 
 64         boolean isSet[]={false,false};    //【0】:left,【1】:right
 65     //    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<str.length();i++){
 77             char ch=str.charAt(i);
 78             if(ch==‘(‘) inBracket++;
 79             else if(ch==‘)‘) inBracket--;
 80             else if(inBracket==0){            //在括号内
 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<str.length();i++){
 93             char ch=str.charAt(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         return parent;
125     }
126     
127     protected BTNode root=new BTNode();
128     BTtree(){
129     }
130     BTtree(int layer){
131         //用队列的方式构造n层树
132         List<BTNode> queue=new ArrayList<BTNode>();
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<layer;j++){
139             int nowRear=rear;
140             for(i=front;i<nowRear;i++){
141                 //出队,生两个孩子
142                 BTNode parent=queue.get(front++);
143                 BTNode lChild=new BTNode();
144                 lChild.data=Integer.toString(++k);
145                 BTNode rChild=new BTNode();
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<BTNode> queue=new ArrayList<BTNode>();
164         List<String[]> PrintList=new ArrayList<String[]>();
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<nowRear;i++){
188                 String nowStr=new String();
189                 BTNode parent=queue.get(front++);
190                 if(parent==null) break ok;    //跳出两重循环
191                 if(parent.data.equals(emptySignal)){//如果是空的,派生出两个空孩子
192                     for(int t=0;t<2;t++){
193                         tmp[pos++]=padding;
194                         BTNode empty=new BTNode();
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=new BTNode();
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=new BTNode();
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<PrintList.size();i++){
229             for(j=0;j<PrintList.get(i).length;j++) System.out.print(PrintList.get(i)[j]+" ");
230             System.out.println();
231         }*/
232         //后处理
233         String[] PrintListLine=new String[PrintList.size()-1];
234         for(i=PrintListLine.length-1;i>=0;i--){//循环构造
235             //首先进行构造
236             String tmp=new String();
237             for(j=0;j<PrintList.get(i).length;j++){
238                 tmp+=PrintList.get(i)[j];
239                 if(j!=PrintList.get(i).length-1) tmp+=" ";
240             }
241             PrintListLine[i]=tmp;
242         }
243         for(i=PrintListLine.length-2;i>=0;i--){//居中操作
244             int spaceNum=(PrintListLine[i+1].length()-PrintListLine[i].length())/2;
245             String space=new String();
246             for(int t=0;t<spaceNum;t++) space+=" ";
247             PrintListLine[i]=space+PrintListLine[i]+space;
248         }    
249         String outStr=new String();
250         for(i=0;i<PrintListLine.length;i++){//最后构造一个字符串
251             outStr+=PrintListLine[i]+"\n";
252         }
253         return outStr;
254     }
255     void PreOrderTraversal(){
256         PreOrder(root);
257         System.out.println();
258     }
259     char splitCh=‘,‘;
260     private void PreOrder(BTNode obj){
261         if(obj!=null){
262             System.out.print(obj.data+splitCh);
263             PreOrder(obj.lChild);
264             PreOrder(obj.rChild);
265         }
266     }
267     void InOrderTraversal(){
268         InOrder(root);
269         System.out.println();
270     }
271     private void InOrder(BTNode obj){    
272         if(obj!=null){
273             InOrder(obj.lChild);
274             System.out.print(obj.data+splitCh);
275             InOrder(obj.rChild);
276         }
277     }
278     void PostOrderTraversal(){
279         PostOrder(root);
280         System.out.println();
281     }
282     private void PostOrder(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 extends BTtree{
296     BThrTree(BTtree obj){//由父类构造而来
297         //首先拷贝根节点
298         BTNode tmp=new BTNode();
299         tmp.data=obj.root.data;
300         copy(root,obj.root);
301     }
302     void copy(BTNode node1,BTNode node2){
303         if(node2.lChild!=null){//左树递归
304             BTNode l=new BTNode();
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=new BTNode();
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<nums.length;i++){//对其他元素进行构造
361             BTNode node=new BTNode();
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<parentV){//左叶子
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<nums.length;i++) AVLinsert(root,null,true,String.valueOf(nums[i]));
390     }
391     BTNode LLRotate(BTNode node){//左子树.高度-右子树.高度==2 【向右旋转】
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         return node;
423     }
424     
425     BTNode LRRotate(BTNode node){//左子树.高度-右子树.高度==2 【向右旋转】
426         node.lChild=RRRotate(node.lChild);
427         node=LLRotate(node);
428         return node;
429     }
430     
431     BTNode RLRotate(BTNode node){//左子树.高度-右子树.高度==2 【向右旋转】
432         node.rChild=LLRotate(node.rChild);
433         node=RRRotate(node);
434         return node;
435     }
436     //                  当前节点           父节点               
437     void AVLinsert(BTNode node,BTNode parent,boolean isLeft,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=new BTNode();
443             newNode.data=data;
444             if(isLeft) parent.lChild=newNode;
445             else        parent.rChild=newNode;
446         }
447         
448         else if(dataV<nodeV){//向左插入
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     int getHeight(BTNode node){
515         if(node!=null){
516             return node.height;
517         }else{
518             return 0;
519         }
520     }
521     void test(){
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 }
View Code

 

程序运行结果:

技术分享

 

通过不断迭代,编写<通过中缀表达式,构造表达式树>的代码

标签:www.   ima   ted   sub   bst   混淆   表达式树   数组   其他   

原文地址:http://www.cnblogs.com/TQCAI/p/7635089.html

(0)
(0)
   
举报
评论 一句话评论(0
登录后才能评论!
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码!