二叉查找树的各种操作

二叉查找树的很多相关操作 包括递归和非递归，看代码。

view plain

1. package com.meran.tree;  
2.   
3. public class TNode {  
4.     int key;  
5.     TNode left;  
6.     TNode right;  
7.     TNode parent;  
8.     public TNode(int key,TNode left,TNode right,TNode parent){  
9.         this.key=key;  
10.         this.left=left;  
11.         this.right=right;  
12.         this.parent=parent;  
13.     }  
14.     public TNode(int key,TNode parent){  
15.         this.key=key;  
16.         this.left=null;  
17.         this.right=null;  
18.         this.parent=parent;  
19.     }  
20.   
21. }  

 

view plain

1. package com.meran.tree;  
2.   
3. import java.util.LinkedList;  
4.   
5. public class BinarySearchTree {  
6.       
7.     TNode root ;  
8.       
9.     //非递归方法插入节点  
10.     public void iterativeInsertNode(int  i){  
11.         TNode p =root,prev=null;  
12.         while(p!=null){  
13.             prev=p;  
14.             if(i<p.key)  
15.               
16.                 p=p.left;  
17.                   
18.             else  
19.                 p=p.right;                        
20.         }  
21.         if(root==null)  
22.             root=new TNode(i,null);  
23.         else  
24.             if(prev.key<i){  
25.                 TNode temp=new TNode(i,prev);  
26.                 prev.right=temp;  
27.                 temp.parent=prev;  
28.             }  
29.             else{  
30.                 TNode temp=new TNode(i,prev);  
31.                 prev.left=temp;  
32.                 temp.parent=prev;  
33.             }  
34.   
35.           
36.     };  
37.     //递归方式插入  
38.     public  void  insertNode(int i){  
39.         TNode prev=getPosition(i,root,root);  
40.         if(prev==null)  
41.             root=new TNode(i,null);  
42.         else if(i<prev.key)  
43.             prev.left=new TNode(i,prev);  
44.         else  
45.             prev.right=new TNode(i,prev);  
46.               
47.           
48.     }  
49.     private TNode getPosition(int i,TNode p,TNode prev){  
50.                
51.         if(p!=null){  
52.             prev=p;  
53.             if(i<p.key)  
54.              return getPosition(i,p.left,prev);  
55.             else  
56.              return getPosition(i,p.right,prev);  
57.         }  
58.         return prev;  
59.     }  
60.     public  void  preorder(TNode p){  
61.         if(p!=null){  
62.          visit(p);  
63.          preorder(p.left);  
64.          preorder(p.right);  
65.         }  
66.           
67.     }  
68.     public  void inorder(TNode p){  
69.         if(p!=null){  
70.             inorder(p.left);  
71.             visit(p);  
72.             inorder(p.right);  
73.         }  
74.           
75.     }  
76.       
77.     public void postorder(TNode p){  
78.         if(p!=null){  
79.             postorder(p.left);  
80.             postorder(p.right);  
81.             visit(p);             
82.         }  
83.     }  
84.     private void visit(TNode p){  
85.         System.out.println(p.key);  
86.     }  
87.     //非递归查找  
88.     public TNode iterativeSearch(int i){  
89.         TNode p=root;  
90.         while(p!=null){  
91.             if(p.key==i)  
92.                 return p;  
93.             else if(i<p.key)  
94.                 p=p.left;  
95.             else  
96.                 p=p.right;            
97.         }  
98.         return null;  
99.               
100.     }  
101.     //递归查找  
102.     public TNode search(TNode p,int i){  
103.             if(p!=null){  
104.                 if(p.key==i)  
105.                     return p;  
106.                 else if(i<p.key)  
107.                     search(p.left,i);  
108.                 else  
109.                     search(p.right,i);  
110.             }  
111.             return null;  
112.     }  
113.     //非递归前序遍历  
114.     public void iterativePreorder(){  
115.         TNode p=root;  
116.         LinkedList<TNode> list=new LinkedList<TNode>();  
117.           
118.         if(p!=null){  
119.             list.addFirst(p);             
120.             while(!list.isEmpty()){  
121.                 p=list.poll();  
122.   
123.                 visit(p);  
124.                 if(p.right!=null)  
125.                     list.addFirst(p.right);  
126.                if(p.left!=null)  
127.                     list.addFirst(p.left);  
128.             }  
129.         }  
130.           
131.     }  
132.     //非递归后序遍历    
133.     public void iterativePostorder(){  
134.           
135.         TNode p=root;  
136.         TNode q=p;  
137.         LinkedList<TNode> list=new LinkedList<TNode>();  
138.         while(p!=null){  
139.             for(;p.left!=null;p=p.left)  
140.                 list.addFirst(p);  
141.             //无右子或者右子已打印  
142.             while(p!=null&&(p.right==null||p.right==q)){  
143.                 visit(p);  
144.                 q=p;  
145.                 if(list.isEmpty())  
146.                     return;  
147.               
148.                 p=list.poll();  
149.             }  
150.             //处理右子  
151.             list.addFirst(p);  
152.             p=p.right;  
153.         }  
154.           
155.     }  
156.     // 广度优先遍历  
157.     public void breadthFirst(){  
158.         TNode p=root;  
159.         LinkedList<TNode> list=new LinkedList<TNode>();  
160.         if(p!=null){  
161.               
162.             list.addLast(p);  
163.             while(!list.isEmpty()){  
164.               
165.                 p=list.poll();  
166.                 visit(p);  
167.                 if(p.left!=null)  
168.                     list.addLast(p.left);  
169.                 if(p.right!=null)  
170.                     list.addLast(p.right);  
171.                   
172.             }  
173.               
174.         }  
175.     }  
176.     //返回最小值非递归  
177.     public TNode iterativeminMum(){  
178.         TNode p=root;  
179.         while(p.left!=null){  
180.             p=p.left;  
181.         }  
182.         return p;  
183.     }  
184.     //返回最大值非递归  
185.     public TNode iterativemimMum(){  
186.         TNode p=root;  
187.         while(p.right!=null)  
188.         p=p.right;  
189.           
190.         return p;  
191.                   
192.     }  
193.     //返回最大值递归  
194.       
195.     public TNode maxMum(TNode p){  
196.         if(p.right!=null)  
197.             return minMum(p.right);  
198.           
199.         return p;  
200.           
201.     }  
202.       
203.     //返回最小值递归  
204.       
205.     public TNode minMum(TNode p){  
206.         if(p.left!=null)  
207.             return minMum(p.left);  
208.           
209.         return p;  
210.           
211.     }  
212.       
213.     //返回节点的后继  
214.       
215.     public TNode successor(TNode p){  
216.         if(p.right!=null)  
217.             return minMum(p.right);  
218.   
219.        TNode y=p.parent;  
220.        while(y!=null&&y==y.parent.right)  
221.        {  
222.            p=y;  
223.            y=y.parent;  
224.        }  
225.        return   y;        
226.           
227.     }  
228.     //返回节点的前驱  
229.    public TNode predecessor(TNode p){  
230.        if(p.left!=null)  
231.            return maxMum(p.left);  
232.        TNode y=p.parent;  
233.        while(y!=null&&y==y.parent.left){  
234.            p=y;  
235.            y=y.parent;  
236.        }  
237.        return y;  
238.    }      
239.      
240.      
241.    public void delete(TNode p){  
242.        TNode y=new TNode(0,null);  
243.        TNode x=new TNode(0,null);  
244.      if(p.left==null||p.right==null)  
245.          y=p;  
246.      else  
247.          y=successor(p);  //选择需要被删除的元素  
248.      if(y.left!=null)  
249.          x=y.left;  
250.      else  
251.          x=y.right;  
252.      if(x!=null)  
253.          x.parent=y.parent; //删除y  
254.      if(y.parent==null)  
255.          root=y;//如果y是根  
256.      else if(y==y.parent.left)  
257.          y.parent.left=x;  
258.      else  
259.          y.parent.right=x;  
260.        
261.      if(y!=p)  
262.          p.key=y.key;  
263.         
264.           
265.       }  
266.      
267.   
268.    public static void main(String [] args){  
269.          
270.          
271.        BinarySearchTree tree=new BinarySearchTree();  
272.            
273.          TNode node3=new TNode(4,null,null,null);  
274.          TNode node1=new TNode(3,null,node3,null);  
275.          TNode node2=new TNode(6,null,null,null);  
276.          TNode node7=new TNode(9,null,null,null);  
277.          TNode node6=new TNode(8,null,node7,null);  
278.          TNode node5=new TNode(10,node6,null,null);  
279.          TNode node4=new TNode(7,node2,node5,null);  
280.          TNode root=new TNode(5,node1,node4,null);  
281.   
282.          
283.          node1.parent=root;  
284.          node2.parent=node4;  
285.          node4.parent=root;  
286.          node5.parent=node4;  
287.          node3.parent=node1;  
288.          node6.parent=node5;  
289.          node7.parent=node6;  
290.            
291.          tree.root=root;  
292.      //  tree.inorder(tree.root);  
293.      //   System.out.println( tree.successor(root).key);  
294.     //    System.out.print( tree.predecessor(root).key);  
295.           
296.         tree.delete(root);  
297.         tree.iterativePostorder();  
298.           
299.         //tree.delete(node5);  
300.     //    tree.iterativePreorder();  
301.         
302.        
303.        //tree.preorder(tree.root);  
304.      //  tree.postorder(tree.root);  
305.    }  
306.       
307.                             
308.   
309. }