二叉排序树的Java实现

最新推荐文章于 2022-12-31 15:37:11 发布
最新推荐文章于 2022-12-31 15:37:11 发布
阅读量310 收藏
点赞数
分类专栏： Java学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ncut_nwpu/article/details/79993770
版权 
class Node{
	public int data;
	public Node left;
	public Node right;
	public Node(int data){
		this.data = data;
		this.left = null;
		this.right = null;
	}
}
public class BinaryTree {
	
	private Node root;
	public BinaryTree(){//构造函数
		this.root = null;
	}
	//将data插入到排序二叉树中
	public void InsertNode(int data){
		Node newNode = new Node(data);
		if(this.root == null){
			this.root = newNode;
		}else{
			Node current = this.root;
			Node parent = current;
			while(current != null){
				parent = current;
				if(data < current.data){
					current = current.left;
				}else{
					current = current.right;
				}
			}
			if(data < parent.data){
				parent.left = newNode;
			}else{
				parent.right = newNode;
			}
		}
	}
	//构造一颗BST
	public void CreateBST(int[] nums,int n){
		for(int i = 0;i<n;i++){
			InsertNode(nums[i]);
		}
	}
	//查找指定BST的最小关键字
	public Node SearchMin(Node root){
		if(root == null) {
			return null;}
		if(root.left==null){
			return root;
		}else {
			return SearchMin(root.left);
		}		
	} 
	//查找最大关键字
	public Node SearchMax(Node root){
		if(root == null) {
			return null;
		}
		if(root.right==null){
			return root;
		}else {
			return SearchMax(root.right);
		}		
	} 
	//查找值为key的关键字，非递归方法
	public Node SearchBST(Node root,int key){
		while(root != null){
			if(key==root.data){
				return root;
			}else if(key < root.data){
				root = root.left;
			}else{
				root = root.right;
			}
		}
		return null;				
	}
	//查找当前结点的父结点,key为当前结点的值，root为二叉树根结点
	public Node getParent(Node root,int key){
		while(root != null){
			if((root.left != null && key==root.left.data) || (root.right != null && key==root.right.data)){
				return root;
			}else if(key < root.data){
				root = root.left;
			}else{
				root = root.right;		
			}
		}
		return null;				
	} 
	//BST删除值为data的结点
	public void DeleteBST(Node root,int data){
		if(root != null){
			if(root.data == data){//找到该结点
				DelNode(root);
			}else if(root.data > data){
				DeleteBST(root.left,data);
			}else
				DeleteBST(root.right,data);
		}
	}
	/**
	 * 二叉排序树待删除结点p分为三种情况：
	 * 1.p是叶子结点——直接删除
	 * 2.p只有左子树或只有右子树——删除p后，将p的左子树或右子树整个移动到删除结点的位置
	 * 3.p既有左子树也有右子树，找到p中序遍历的直接前驱s（左子树中的最大值），替换p结点，然后再删除结点s
	 */
	public void DelNode(Node p){//要删除的结点为p
		Node temp,s;
		if(p.left==null && p.right==null){//删除元素为叶子结点
			temp = getParent(root,p.data);//temp为结点p的双亲结点
	        if(temp.left == p){
	        	temp.left = null;//如果p为temp的左孩子，则删除p即将temp的左孩子置为null
	        }else{
	        	temp.right = null;
	        }
		}else if(p.left != null && p.right==null){//删除元素有左孩子
			temp = getParent(root,p.data);//temp为结点p的双亲结点
			if(temp.left == p){
	        	temp.left = p.left;
	        }else{
	        	temp.right = p.left;
	        }
		}else if(p.left == null && p.right!=null){//删除元素有右孩子
			temp = getParent(root,p.data);//temp为结点p的双亲结点
			if(temp.left == p){
	        	temp.left = p.right;
	        }else{
	        	temp.right = p.right;
	        }
		}else{//删除元素左右孩子都不为空 ，找到左孩子中最大的,即p的直接前驱s，用s来替换p，然后删除s
	        s = SearchMax(p.left);//p的左子树中最大元素结点s没有右孩子
	        temp = getParent(root,s.data);//找到s的双亲
	        if(temp == p){//p的左子树没有右子树，即s==p.left
	        	p = s;
	        }else{//p的左子树有右结点，s为最右的结点，即s若有子树则只有左子树
	        	p.data = s.data; 
	        	temp.right = s.left;
	        }
	        s = null;   
		}
	}
			
	//二叉树的遍历
	public void PreOrderTraverse(Node root){//先序遍历
		if(root != null){
			System.out.println(root.data);
			PreOrderTraverse(root.left);
			PreOrderTraverse(root.right);
		}
	}
	public void MidOrderTraverse(Node root){//中序遍历
		if(root != null){			
			MidOrderTraverse(root.left);
			System.out.println(root.data+" "+root);
			MidOrderTraverse(root.right);
		}
	}
	public void PostOrderTraverse(Node root){//后序遍历
		if(root != null){			
			PostOrderTraverse(root.left);			
			PostOrderTraverse(root.right);
			System.out.println(root.data);
		}
	}

	public static void main(String[] args) {
		int[] nums= {17,12,19,10,15,18,20,8,11,13,16,14};
		BinaryTree newBST = new BinaryTree();
		
		newBST.CreateBST(nums,nums.length);	
		System.out.println("创建后中序遍历：");
		newBST.MidOrderTraverse(newBST.root);	
				
		newBST.InsertNode(9);
		System.out.println("插入9后中序遍历：");
		newBST.MidOrderTraverse(newBST.root);	
		
		Node Max = newBST.SearchMax(newBST.root);
		System.out.println("二叉树中的max: "+Max.data);
		Node Min = newBST.SearchMin(newBST.root);
		System.out.println("二叉树中的min: "+Min.data);
		
		Node Key = newBST.SearchBST(newBST.root,11);
		System.out.println("查找Key值="+Key.data + "， 则其地址="+Key);
		
		newBST.DeleteBST(newBST.root, 17);
		System.out.println("删除17后中序遍历：");
		newBST.MidOrderTraverse(newBST.root);
		
		System.out.println("*--------------------------------------*");
		
		int[] nums1= {2,4,6,7,98,0,2,6,9,1};
        BinaryTree newBST1 = new BinaryTree();
		
		newBST1.CreateBST(nums1,nums1.length);	
		System.out.println("创建后中序遍历：");
		newBST1.MidOrderTraverse(newBST1.root);	
				
		newBST1.InsertNode(11);
		System.out.println("插入11后中序遍历：");
		newBST1.MidOrderTraverse(newBST1.root);	
		
		Node Max1 = newBST1.SearchMax(newBST1.root);
		System.out.println("二叉树中的max: "+Max1.data);
		Node Min1 = newBST1.SearchMin(newBST1.root);
		System.out.println("二叉树中的min: "+Min1.data);
		
		Node Key1 = newBST1.SearchBST(newBST1.root,11);
		System.out.println("查找Key值="+Key1.data + "， 则其地址="+Key1);
		
		newBST1.DeleteBST(newBST1.root, 6);//重复的两个6，只能删掉后一个6
		System.out.println("删除6后中序遍历：");
		newBST1.MidOrderTraverse(newBST1.root);
	}
}

上述代码执行结果：

创建后中序遍历：
8 bst.Node@15db9742
10 bst.Node@6d06d69c
11 bst.Node@7852e922
12 bst.Node@4e25154f
13 bst.Node@70dea4e
14 bst.Node@5c647e05
15 bst.Node@33909752
16 bst.Node@55f96302
17 bst.Node@3d4eac69
18 bst.Node@42a57993
19 bst.Node@75b84c92
20 bst.Node@6bc7c054
插入9后中序遍历：
8 bst.Node@15db9742
9 bst.Node@232204a1
10 bst.Node@6d06d69c
11 bst.Node@7852e922
12 bst.Node@4e25154f
13 bst.Node@70dea4e
14 bst.Node@5c647e05
15 bst.Node@33909752
16 bst.Node@55f96302
17 bst.Node@3d4eac69
18 bst.Node@42a57993
19 bst.Node@75b84c92
20 bst.Node@6bc7c054
二叉树中的max: 20
二叉树中的min: 8
查找Key值=11， 则其地址=bst.Node@7852e922
删除17后中序遍历：
8 bst.Node@15db9742
9 bst.Node@232204a1
10 bst.Node@6d06d69c
11 bst.Node@7852e922
12 bst.Node@4e25154f
13 bst.Node@70dea4e
14 bst.Node@5c647e05
15 bst.Node@33909752
16 bst.Node@3d4eac69
18 bst.Node@42a57993
19 bst.Node@75b84c92
20 bst.Node@6bc7c054
*--------------------------------------*
创建后中序遍历：
0 bst.Node@4aa298b7
1 bst.Node@7d4991ad
2 bst.Node@28d93b30
2 bst.Node@1b6d3586
4 bst.Node@4554617c
6 bst.Node@74a14482
6 bst.Node@1540e19d
7 bst.Node@677327b6
9 bst.Node@14ae5a5
98 bst.Node@7f31245a
插入11后中序遍历：
0 bst.Node@4aa298b7
1 bst.Node@7d4991ad
2 bst.Node@28d93b30
2 bst.Node@1b6d3586
4 bst.Node@4554617c
6 bst.Node@74a14482
6 bst.Node@1540e19d
7 bst.Node@677327b6
9 bst.Node@14ae5a5
11 bst.Node@6d6f6e28
98 bst.Node@7f31245a
二叉树中的max: 98
二叉树中的min: 0
查找Key值=11， 则其地址=bst.Node@6d6f6e28
删除6后中序遍历：
0 bst.Node@4aa298b7
1 bst.Node@7d4991ad
2 bst.Node@28d93b30
2 bst.Node@1b6d3586
4 bst.Node@4554617c
6 bst.Node@1540e19d
7 bst.Node@677327b6
9 bst.Node@14ae5a5
11 bst.Node@6d6f6e28
98 bst.Node@7f31245a



                

        

        

    




    

      

        

            

              
                
                  深海里的杂货铺
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                      0
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    0
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      

            

                专栏目录
          










                



	

		

			

				
					
二叉排序树（Java实现）

				
			

			

				

					qq_37837621的博客
				

				

					04-30
					
					2170
					
				

			

		

		

			
				
文章收藏的好句子：坚持和放纵是永远对立的矛盾，好习惯的坚持就像春天随手丢下的种子，经历漫长的仲夏，终将会迎来收获的金秋。而坏习惯的养成真的只能让人生的脚步停止在寒风凛冽的冬天，让你永远看不见下一个春天。目录1、数列的查询和添加问题2、二叉排序树  2、1二叉排序树的介绍  2、2二叉排序树的创建和遍历  2、3二叉排序树的删除1、数列的查询和添加...

			
		

	



                

              
                



	

		

			

				
					
二叉排序树的JAVA实现

				
			

			

				

					coding and writing and 承接需求
				

				

					05-19
					
					638
					
				

			

		

		

			
				
二叉排序树

			
		

	



                


  
              

                


	

		

			

				
					
Java开发 - 树（二叉树，二叉排序树，红黑树）

				
			

			

				

					CodingFire的博客
				

				

					12-30
					
					1892
					
				

			

		

		

			
				
其本质上是数据结构，是用来存储数据的，所以我们一般用泛型，让外部告知具体类型，而不能把类型写死。}而为了让传入的类型支持比较，必须要对泛型继承Comparable，这也是一个难点，很多人在这里容易写错。//根节点//定义内部类表示节点//节点中保存的元素对象//左子树指向的节点//右子树指向的节点//定义有参构造方法,用于创建节点}}}这时，一棵树的基本元素就定义好了，接下来就是我们所熟悉的增删改查方法，但写起来，可能并没那么简单。

			
		

	





	

		

			

				
					
(数据结构)二叉排序树(java)

				
			

			

				

					imbzz的博客
				

				

					12-31
					
					155
					
				

			

		

		

			
				
二叉排序树的java封装实现

			
		

	



		

			
		



	

		

			

				
					
Java数据结构——排序二叉树

				
			

			

				

					m0_62969222的博客
				

				

					05-25
					
					805
					
				

			

		

		

			
				
排序二叉树概念

二叉排序树（Binary Sort Tree），又称二叉查找树（Binary Search Tree），亦称二叉搜索树。是数据结构中的一类。
对于二叉排序树的任何一个非叶子节点， 要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。
对二叉排序树进行中序遍历，结果就是按从小到大排序的。

排序二叉树类的定义
public class binarySortTree {
    class Node{
        int value;
        Node left;
  

			
		

	





	

		

			

				
					
Java实现二叉排序树

				
			

			

				

					09-02
				

			

		

		

			
				
说明: 可实现:构造树,插入,查找,删除. 通过模式的选择,可以插入值相等的点.但是不建议使用.

			
		

	





	

		

			

				
					
详解Java二叉排序树

				
			

			

				

					09-02
				

			

		

		

			
				
主要介绍了Java二叉排序树，包括二叉排序树的定义、二叉排序树的性质、二叉排序树的插入和查找等，感兴趣的小伙伴们可以参考一下

			
		

	





	

		

			

				
					
数据结构 二叉排序树 java图形界面实现

				
			

			

				

					02-20
				

			

		

		

			
				
数据结构 二叉排序树 二叉搜索树 java swing图形界面实现

			
		

	





	

		

			

				
					
Java基于二叉查找树实现排序功能示例

				
			

			

				

					08-29
				

			

		

		

			
				
主要介绍了Java基于二叉查找树实现排序功能,结合实例形式分析了Java二叉查找树的定义、遍历及排序等相关操作技巧,需要的朋友可以参考下

			
		

	





	

		

			

				
					
java二叉查找树的实现代码

				
			

			

				

					08-29
				

			

		

		

			
				
主要为大家详细介绍了java二叉查找树的实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下

			
		

	





	

		

			

				
					
JAVA实现二叉排序树（创建、中序遍历、插入节点和删除节点操作）

				
			

			

				

					梅森上校的博客  业精于勤荒于嬉，形成于思毁于随。
				

				

					03-31
					
					7817
					
				

			

		

		

			
				
JAVA实现二叉排序树

二叉排序树的定义

二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 
（1）若左子树不空，则左子树上所有结点的值均小于或等于它的根结点的值； 
（2）若右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值； 
（3）左、右子树也分别为二叉排序树；

从上述定义可以看出，二叉排序树的定义本身就是依赖于递归思想的。

二叉排序树举例



二叉排序树的JAVA...

			
		

	





	

		

			

				
					
二叉排序(查找)树（Java实现）

				
			

			

				

					qq_49306008的博客
				

				

					12-02
					
					930
					
				

			

		

		

			
				
二叉排序树：BST（Binary Sort（Search）Tree），又称为二叉查找树。其定义为：二叉排序树或者是一棵空树，或者是具有如下性质的二叉树。
① 若它的左子树非空，则左子树上所有节点的值均小于根节点的值，
② 若它的右子树非空，则右子树上的所有节点的值均大于（或大于等于）根节点的值。
③ 它的左右子树也分别为二叉排序树。
简单来说，对于二叉排序树的任何一个非叶子节点，要求左子节点的值比当前节点的值小，右子节点的值比当前节点的值大。若有相同的值，可将该节点放在左子节点或右子节点。
二叉排序树的创建

			
		

	





	

		

			

				
					
【树结构】二叉搜索树

				
			

			

				

					惜暮
				

				

					01-07
					
					8718
					
				

			

		

		

			
				
最近在看JDK源码时，发现JDK的J.U.C包下面的很多类都用到了二叉排序树和红黑树，就想着这一块还是考研的时候看了的，顺便就在理论基础上复习加用Java做个实现。
二叉排序树先来说说这个二叉排序树的定义和性质：
  定义：二叉排序树或者是一棵空树，或者是具有下列性质的二叉树： 
  （1）若左子树不空，则左子树上所有结点的键值均小于或等于它的根结点的键值； 
  （2）若右子树不空，则右子树上所有

			
		

	





	

		

			

				
					
数据结构之二叉排序树及其基本操作(java实现）

				
			

			

				

					江南V的博客
				

				

					07-04
					
					5050
					
				

			

		

		

			
				
一、简介      最近在整理以前写的数据结构的代码资料，顺便做数据结构复习用，故我在这里只做代码展示之用，不做过多的数据结构理论上的讲解。如果读者对代码有异议或者有错误的地方欢迎大家批评指正。感谢大家的阅读。二、代码实现        二叉排序树在二叉树的基础上多了一个有序的功能，故基本实现于二叉树相似，具体代码如下：        Node.java        package Binary...

			
		

	





	

		

			

				
					
二叉排序树的理解和实现(Java)

				
			

			

				

					如是说的博客
				

				

					03-12
					
					9032
					
				

			

		

		

			
				
二叉排序树的定义和性质
二叉排序树又称二叉排序树。它或者是一个空树，或者是一个具有下列性质的二叉树：

若它的左子树不空，则左子树上所有节点的值均小于它的根结构的值
若它的右子树不空，则右子树上所有结点的值均大于它的根节点的值
它的左、右子树也分别是二叉排序树

如下图是一个二叉排序树：

下面的代码(Java实现)基本全部基于递归实现(非递归操作复杂且效率高)，简单的实现了BST的这些操作：初始...

			
		

	





	

		

			

				
					
二叉排序树（Binary Sort Tree）查找、插入、删除  Java实现

				
			

			

				

					CmdSmith的博客
				

				

					03-30
					
					2947
					
				

			

		

		

			
				
顺序存储的插入和删除可以通过在表末端插入和删除元素同最后一个元素互换来保持高效率，但是无序造成查找的效率很低。
如果查找的数据表是有序线性表，并且是顺序存储的，查找可以折半、插值、斐波那契等查找算法来实现，但是因为有序在插入和删除操作上，就需要耗费大量时间。
二叉排序树可以使得插入和删除的效率不错，又可以比较高效率地实现查找。


二叉排序树（Binary Sort Tree），又称为二

			
		

	





	

		

			

				
					
java实现二叉排序树

				
			

			

				

					sunpy
				

				

					05-28
					
					996
					
				

			

		

		

			
				
1.什么是二叉排序树
二叉排序树是二叉树的基础上多出来一些性质而已。
性质：
若它的左子树不空，则左子树上的所有关键字的值都小于根关键字的值。
若它的右子树不空，则右子树上的所有关键字的值都大于根关键字的值。
左右子树又各是一棵二叉排序树。
基于二叉排序树的性质我们可以得到的一点是，如果我们输出二叉排序树的中序遍历序列，则这个序列的值是依次递增的顺序。
如果对二叉树不清楚，那么可以看

			
		

	





	

		

			

				
					
二叉查找树--查找、删除、插入（Java实现）

				
			

			

				

					weixin_33883178的博客
				

				

					05-06
					
					544
					
				

			

		

		

			
				
下篇：平衡二叉树   http://blog.csdn.net/kiritor/article/details/8892648        二叉查找树     二叉查找树（Binary Search Tree），或者是一颗空树，或者是具有下列性质的二叉树：  ...

			
		

	





	

		

			

				
					
二叉排序树查找代码java实现

					
最新发布

				
			

			

				

					10-11
				

			

		

		

			
				
二叉排序树查找代码Java实现：

```
public class BinarySearchTree {
    private TreeNode root;

    public BinarySearchTree() {
        root = null;
    }

    public void insert(int value) {
        root = insert(root, value);
    }

    private TreeNode insert(TreeNode node, int value) {
        if (node == null) {
            node = new TreeNode(value);
            return node;
        }

        if (value < node.val) {
            node.left = insert(node.left, value);
        } else if (value > node.val) {
            node.right = insert(node.right, value);
        }

        return node;
    }

    public TreeNode search(int value) {
        return search(root, value);
    }

    private TreeNode search(TreeNode node, int value) {
        if (node == null || node.val == value) {
            return node;
        }

        if (value < node.val) {
            return search(node.left, value);
        } else {
            return search(node.right, value);
        }
    }

    private class TreeNode {
        int val;
        TreeNode left;
        TreeNode right;

        TreeNode(int x) {
            val = x;
            left = null;
            right = null;
        }
    }
}
```



			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值