Java实现链式存储的二叉查找树(递归方法),Java实现链式存储的二叉树

二叉查找树的定义:

  二叉查找树或者是一颗空树,或者是一颗具有以下特性的非空二叉树:

    1. 若左子树非空,则左子树上所有节点关键字值均小于根节点的关键字;

    2. 若右子树非空,则右子树上所有节点关键字值均大于根节点的关键字;

    3. 左、右子树本身也分别是一颗二叉查找树。

二叉查找树的实现,功能有:

  1. 用一个数组去构建二叉查找树

  2. 二叉查找树的中序遍历和层次遍历

  3. 插入节点

  4. 查找节点

      5. 查找二叉树中的最大值和最小值

  6.  得到节点的直接父节点

  7. 得到节点的直接前驱和直接后继节点

  8. 删除节点

树节点TreeNode的定义见:Java实现链式存储的二叉树

  1 import java.lang.Integer;
  2 import java.util.LinkedList;
  3 import java.util.Queue;
  4 import java.util.Scanner;
  5 
  6 /*
  7  * 二叉排序树(二叉查找树)的实现
  8  */
  9 public class BinarySearchTree {
 10     private TreeNode<Integer> root;  //根节点
 11     
 12     public BinarySearchTree(){
 13         root = null;
 14     }
 15     
 16     //用一个数组去构建二叉查找树
 17     public TreeNode<Integer> buildBST(Integer[] array){
 18         if(array.length == 0){
 19             return null;
 20         }else{
 21             root = null;  //初始化树为空树
 22             for(int i=0; i<array.length; i++){ //依次将每个元素插入
 23                 root = insertNode(root,array[i]);
 24             }
 25             return root;
 26         }        
 27     }
 28     
 29     //在二叉查找树中插入一个数据域为data的结点,新插入的结点一定是某个叶子节点
 30     public TreeNode<Integer> insertNode(TreeNode<Integer> node, Integer data){
 31         if(node == null){   //原树为空,新插入的记录为根节点
 32             node = new TreeNode<Integer>(data,null,null);        
 33         }else{
 34             if(node.getData() == data){   //树中存在相同关键字的结点,什么也不做
 35                 
 36             }else{
 37                 if(node.getData() > data){  //根节点>插入数据,插入到左子树中
 38                     node.setLchild(insertNode(node.getLchild(),data));
 39                 }else{ //根节点<插入数据,插入到右子树中
 40                     node.setRchild(insertNode(node.getRchild(),data)); 
 41                 }
 42             }        
 43         }
 44         return node;
 45     }
 46     
 47     //二叉查找树的中序遍历,可以得到一个递增的有序数列
 48     public void inOrder(TreeNode<Integer> node){
 49         if(node != null){
 50             inOrder(node.getLchild());
 51             System.out.print(node.getData()+" ");
 52             inOrder(node.getRchild());
 53         }
 54     }
 55     //二叉查找树的层次遍历
 56     public void levelOrder(TreeNode<Integer> root){
 57         Queue<TreeNode<Integer>> nodeQueue = new LinkedList<TreeNode<Integer>>();
 58         TreeNode<Integer> node = null;
 59         nodeQueue.add(root);  //将根节点入队    
 60         while(!nodeQueue.isEmpty()){  //队列不空循环
 61             node = nodeQueue.peek();
 62             System.out.print(node.getData()+" ");
 63             nodeQueue.poll();     //队头元素出队
 64             if(node.getLchild() != null){     //左子树不空,则左子树入队列
 65                 nodeQueue.add(node.getLchild());
 66             }
 67             if(node.getRchild() != null){     //右子树不空,则右子树入队列
 68                 nodeQueue.add(node.getRchild());
 69             }
 70         }
 71     }
 72     
 73     //查找数据域为data的结点,若不存在,返回null
 74     public TreeNode<Integer> searchNode(TreeNode<Integer> node, Integer data){
 75         while(node != null && node.getData() != data){
 76             if(node.getData() > data){
 77                 node = node.getLchild();  //根节点>数据,向左走
 78             }else{
 79                 node = node.getRchild();  //根节点<数据,向右走
 80             }
 81         }
 82         return node;
 83     }
 84     
 85     //查找最大值:不断地寻找右子节点
 86     public TreeNode<Integer> getMaxData(TreeNode<Integer> node){
 87         if(node.getRchild() == null){
 88             return node;
 89         }else{
 90             return getMaxData(node.getRchild());
 91         }
 92     }
 93     
 94     //查找最小值:不断地寻找左子节点
 95     public TreeNode<Integer> getMinData(TreeNode<Integer> node){
 96         if(node.getLchild() == null){
 97             return node;
 98         }else{
 99             return getMinData(node.getLchild());
100         }
101     }
102     
103     //得到数据域为data的结点的直接父节点parentNode
104     public TreeNode<Integer> getParentNode(TreeNode<Integer> root, Integer data){
105         TreeNode<Integer> parentNode = root;
106         if(parentNode.getData() == data){   //根节点的父节点返回为null
107             return null;
108         }
109         while(parentNode != null){
110             //查找当前节点的父节点的左右子节点,若是相等,则返回该父节点
111             if((parentNode.getLchild() != null && parentNode.getLchild().getData() == data) || 
112                     (parentNode.getRchild() != null && parentNode.getRchild().getData() == data)){
113                 return parentNode;
114             }else{
115                 if(parentNode.getData() > data){ //向左查找父节点
116                     parentNode = parentNode.getLchild();
117                 }else{
118                     parentNode = parentNode.getRchild();  //向右查找父节点
119                 }
120             }            
121         }
122         return null;
123     }
124     
125     /**
126      * 得到结点node的直接前趋
127      * a.该节点左子树不为空:其前驱节点为其左子树的最大元素
128      * b.该节点左子树为空: 其前驱节点为其祖先节点(递归),且该祖先节点的右孩子也为其祖先节点
129      *   (就是一直往其parent找,出现左拐后的那个祖先节点) 
130      */
131     public TreeNode<Integer> getPrecessor(TreeNode<Integer> root,TreeNode<Integer> node){
132         if(node == null){
133             return null;
134         }
135         //a.该节点左子树不为空:其前驱节点为其左子树的最大元素
136         if(node.getLchild() != null){
137             return getMaxData(node.getLchild());
138         }else{  //b.该节点左子树为空: 其前驱节点为其祖先节点(递归)        
139             TreeNode<Integer> parentNode = getParentNode(root, node.getData());
140             while(parentNode != null && node == parentNode.getLchild()){
141                 node = parentNode;
142                 parentNode = getParentNode(root, parentNode.getData());
143             }
144             return parentNode;
145         }
146     }
147     
148     /**
149      * 得到结点node的直接后继(后继节点就是比要删除的节点的关键值要大的节点集合中的最小值)
150      * a.该节点右子树不为空,其后继节点为其右子树的最小元素
151      * b.该节点右子树为空,则其后继节点为其祖先节点(递归),且此祖先节点的左孩子也是该节点的祖先节点,
152      *   就是说一直往上找其祖先节点,直到出现右拐后的那个祖先节点: 
153      */
154     public TreeNode<Integer> getSuccessor(TreeNode<Integer> root,TreeNode<Integer> node){
155         if(node == null){
156             return null;
157         }
158         //a.该节点右子树不为空,其后继节点为其右子树的最小元素
159         if(node.getRchild() != null){
160             return getMinData(node.getRchild());
161         }else{  //b.该节点右子树为空,则其后继节点为其最高祖先节点(递归)        
162             TreeNode<Integer> parentNode = getParentNode(root, node.getData());
163             while(parentNode != null && node == parentNode.getRchild()){
164                 node = parentNode;
165                 parentNode = getParentNode(root, parentNode.getData());
166             }
167             return parentNode;
168         }
169     }
170     
171     /**
172      * 删除数据域为data的结点
173      * 按三种情况处理:
174      * a.如果被删除结点z是叶子节点,则直接删除,不会破坏二叉查找树的性质
175      * b.如果节点z只有一颗左子树或右子树,则让z的子树成为z父节点的子树,代替z的位置
176      * c.若结点z有左、右两颗子树,则令z的直接后继(或直接前驱)替代z,
177      *   然后从二叉查找树中删去这个直接后继(或直接前驱),这样就转换为第一或第二种情况
178      * @param node 二叉查找树的根节点
179      * @param data 需要删除的结点的数据域
180      * @return
181      */
182     public boolean deleteNode(TreeNode<Integer> node, Integer data){
183         if(node == null){ //树为空
184             throw new RuntimeException("树为空!");
185         }
186         TreeNode<Integer> delNode= searchNode(node, data);  //搜索需要删除的结点
187         TreeNode<Integer> parent = null;
188         if(delNode == null){  //如果树中不存在要删除的关键字
189             throw new RuntimeException("树中不存在要删除的关键字!");
190         }else{
191             parent = getParentNode(node,data);  //得到删除节点的直接父节点
192             //a.如果被删除结点z是叶子节点,则直接删除,不会破坏二叉查找树的性质         
193             if(delNode.getLchild()==null && delNode.getRchild()==null){    
194                 if(delNode==parent.getLchild()){  //被删除节点为其父节点的左孩子
195                     parent.setLchild(null);
196                 }else{    //被删除节点为其父节点的右孩子
197                     parent.setRchild(null);
198                 }
199                 return true;
200             }
201             //b1.如果节点z只有一颗左子树,则让z的子树成为z父节点的子树,代替z的位置
202             if(delNode.getLchild()!=null && delNode.getRchild()==null){
203                 if(delNode==parent.getLchild()){ //被删除节点为其父节点的左孩子
204                     parent.setLchild(delNode.getLchild());                    
205                 }else{ //被删除节点为其父节点的右孩子
206                     parent.setRchild(delNode.getLchild());
207                 }
208                 delNode.setLchild(null); //设置被删除结点的左孩子为null
209                 return true;
210             }
211             //b2.如果节点z只有一颗右子树,则让z的子树成为z父节点的子树,代替z的位置
212             if(delNode.getLchild()==null && delNode.getRchild()!=null){
213                 if(delNode==parent.getLchild()){ //被删除节点为其父节点的左孩子
214                     parent.setLchild(delNode.getRchild());
215                 }else{  //被删除节点为其父节点的右孩子
216                     parent.setRchild(delNode.getRchild());
217                 }
218                 delNode.setRchild(null); //设置被删除结点的右孩子为null
219                 return true;
220             }
221             //c.若结点z有左、右两颗子树,则删除该结点的后继结点,并用该后继结点取代该结点
222             if(delNode.getLchild()!=null && delNode.getRchild()!=null){
223                 TreeNode<Integer> successorNode = getSuccessor(node,delNode); //得到被删除结点的后继节点
224                 deleteNode(node,successorNode.getData()); //删除该结点的后继结点
225                 delNode.setData(successorNode.getData()); //用该后继结点取代该结点
226                 return true;
227             }
228         }
229         return false;
230     }
231     
232     
233     public static void main(String args[]){
234         Scanner input = new Scanner(System.in);
235         Integer[] array = {8,3,10,1,6,14,4,7,13};
236         BinarySearchTree bst = new BinarySearchTree();
237         TreeNode<Integer> root = bst.buildBST(array);
238         System.out.print("层次遍历:");  
239         bst.levelOrder(root);
240         System.out.print("\n"+"中序遍历:");  
241         bst.inOrder(root);  
242          System.out.println();
243          System.out.print("得到最大值:");  
244          System.out.println(bst.getMaxData(root).getData());  
245          System.out.print("得到最小值:");  
246          System.out.println(bst.getMinData(root).getData()); 
247          System.out.print("向二叉查找树中插入一个节点,请输入需插入节点的数据域:");
248          int data = input.nextInt();
249          System.out.print("插入节点"+ data +"后,中序遍历的结果:");
250          root = bst.insertNode(root, data); 
251          bst.inOrder(root);  
252          System.out.println("\n"+"在二叉查找树中查找元素,"+"请输入需要查找的结点值:");
253          data = input.nextInt();
254          if(bst.searchNode(root, data) == null){
255              System.out.println("false");
256          }else{
257              System.out.println("true");
258          }
259          System.out.println("查找节点的直接父节点,"+"请输入需要查找的结点值:");
260          data = input.nextInt();
261          System.out.print("节点"+ data +"的父节点是:");
262          if(bst.getParentNode(root, data) == null){
263              System.out.println("null");
264          }else{
265              System.out.println(bst.getParentNode(root, data).getData());
266          }
267          System.out.println("删除结点,"+"请输入需要删除的结点值:");
268          data = input.nextInt();
269          if(bst.deleteNode(root, data)){
270             System.out.print("删除结点后的层次遍历:");  
271              bst.levelOrder(root);
272              System.out.print("\n"+"删除结点后的中序遍历:");  
273              bst.inOrder(root); 
274          }      
275     }    
276 }

程序运行结果:

《Java实现链式存储的二叉查找树(递归方法),Java实现链式存储的二叉树》

层次遍历:8 3 10 1 6 14 4 7 13 
中序遍历:1 3 4 6 7 8 10 13 14 
得到最大值:14
得到最小值:1
向二叉查找树中插入一个节点,请输入需插入节点的数据域:15
插入节点15后,中序遍历的结果:1 3 4 6 7 8 10 13 14 15 
在二叉查找树中查找元素,请输入需要查找的结点值:
4
true
查找节点的直接父节点,请输入需要查找的结点值:
10
节点10的父节点是:8
删除结点,请输入需要删除的结点值:
4
删除结点后的层次遍历:8 3 10 1 6 14 7 13 15 
删除结点后的中序遍历:1 3 6 7 8 10 13 14 15 

某些方法的非递归实现:

1. 插入节点insertNode():

 1   //在二叉查找树中插入一个数据域为data的结点,新插入的结点一定是某个叶子节点
 2     public TreeNode<Integer> insertNode(TreeNode<Integer> node, Integer data){
 3         TreeNode<Integer> newNode = new TreeNode<Integer>(data,null,null);
 4         TreeNode<Integer> tmpNode = node;  //遍历节点
 5         TreeNode<Integer> pnode = null;   //记录当前节点的父节点    
 6         
 7         if(node == null){   //原树为空,新插入的记录为根节点
 8             node = newNode;    
 9             return node;
10         }
11         while(tmpNode != null){
12             pnode = tmpNode;
13             if(tmpNode.getData() == data){ //树中存在相同关键字的结点,什么也不做
14                 return node;
15             }else{
16                 if(tmpNode.getData() > data){ //根节点>插入数据,插入到左子树中
17                     tmpNode = tmpNode.getLchild();
18                 }else{ //根节点<插入数据,插入到右子树中
19                     tmpNode = tmpNode.getRchild();
20                 }
21             }
22         }
23         if(pnode.getData() > data){
24             pnode.setLchild(newNode);
25         }else{
26             pnode.setRchild(newNode);
27         }    
28         return node;
29     }

2. 二叉查找树的中序遍历:

 1   //二叉查找树的中序遍历LNR,可以得到一个递增的有序数列
 2     public void inOrder(TreeNode<Integer> node){
 3         Stack<TreeNode<Integer>> nodeStack = new Stack<TreeNode<Integer>>();
 4         TreeNode<Integer> tempNode = node;  //遍历指针
 5         while(tempNode != null || !nodeStack.isEmpty()){
 6             if(tempNode != null){
 7                 nodeStack.push(tempNode);
 8                 tempNode = tempNode.getLchild();
 9             }else{
10                 tempNode = nodeStack.pop();
11                 System.out.print(tempNode.getData() + " ");
12                 tempNode = tempNode.getRchild();
13             }
14         }
15     }

3. 得到二叉查找树的最大值和最小值:

 1     //查找最大值:不断地寻找右子节点
 2     public TreeNode<Integer> getMaxData(TreeNode<Integer> node){
 3         TreeNode<Integer> tempNode = node;
 4         while(tempNode.getRchild()!=null){
 5             tempNode = tempNode.getRchild();
 6         }
 7         return tempNode;
 8     }
 9     
10     //查找最小值:不断地寻找左子节点
11     public TreeNode<Integer> getMinData(TreeNode<Integer> node){
12         TreeNode<Integer> tempNode = node;
13         while(tempNode.getLchild() != null){
14             tempNode = tempNode.getLchild();
15         }
16         return tempNode;
17     }

 

    原文作者:CherishFu
    原文地址: https://www.cnblogs.com/CherishFX/p/4625382.html
    本文转自网络文章,转载此文章仅为分享知识,如有侵权,请联系博主进行删除。
点赞

发表评论

电子邮件地址不会被公开。 必填项已用*标注