Java二叉排序树

最新推荐文章于 2023-06-26 18:34:42 发布
置顶 最新推荐文章于 2023-06-26 18:34:42 发布
阅读量6.3k 收藏 17
点赞数 4
分类专栏： Java学习笔记 文章标签： java 二叉排序树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Evankaka/article/details/48088241
版权

一、二叉排序树定义

1.二叉排序树的定义

　　二叉排序树(Binary Sort Tree)又称二叉查找(搜索)树(Binary Search Tree)。其定义为：二叉排序树或者是空树，或者是满足如下性质的二叉树：
①若它的左子树非空，则左子树上所有结点的值均小于根结点的值；
②若它的右子树非空，则右子树上所有结点的值均大于根结点的值；
③左、右子树本身又各是一棵二叉排序树。

上述性质简称二叉排序树性质(BST性质)，故二叉排序树实际上是满足BST性质的二叉树。



2.二叉排序树的性质
按中序遍历二叉排序树，所得到的中序遍历序列是一个递增有序序列。

3.二叉排序树的插入
在二叉排序树中插入新结点，要保证插入后的二叉树仍符合二叉排序树的定义。 　　
插入过程：
若二叉排序树为空，则待插入结点*S作为根结点插入到空树中； 　　
当非空时，将待插结点关键字S->key和树根关键字t->key进行比较，若s->key = t->key,则无须插入，若s->key< t->key,则插入到根的左子树中，若s->key> t->key,则插入到根的右子树中。而子树中的插入过程和在树中的插入过程相同，如此进行下去，直到把结点*s作为一个新的树叶插入到二叉排序树中，或者直到发现树已有相同关键字的结点为止。

4.二叉排序树的查找
假定二叉排序树的根结点指针为 root ，给定的关键字值为 K ，则查找算法可描述为：
　　① 置初值： q ＝ root ；
　　② 如果 K ＝ q －＞ key ，则查找成功，算法结束；
　　③ 否则，如果 K ＜ q －＞ key ，而且 q 的左子树非空，则将 q 的左子树根送 q ，转步骤②；否则，查找失败，结束算法；
　　④ 否则，如果 K ＞ q －＞ key ，而且 q 的右子树非空，则将 q 的右子树根送 q ，转步骤②；否则，查找失败，算法结束。

5.二叉排序树的删除
假设被删结点是*p，其双亲是*f，不失一般性，设*p是*f的左孩子，下面分三种情况讨论： 　　
⑴ 若结点*p是叶子结点，则只需修改其双亲结点*f的指针即可。 　　
⑵ 若结点*p只有左子树PL或者只有右子树PR，则只要使PL或PR 成为其双亲结点的左子树即可。 　　
⑶ 若结点*p的左、右子树均非空，先找到*p的中序前趋(或后继)结点*s（注意*s是*p的左子树中的最右下的结点，它的右链域为空），然后有两种做法：① 令*p的左子树直接链到*p的双亲结点*f的左链上,而*p的右子树链到*p的中序前趋结点*s的右链上。② 以*p的中序前趋结点*s代替*p（即把*s的数据复制到*p中），将*s的左子树链到*s的双亲结点*q的左（或右）链上。

6、二叉树的遍历

二叉树的遍历有三种方式，如下：
（1）前序遍历（DLR），首先访问根结点，然后遍历左子树，最后遍历右子树。简记根-左-右。
（2）中序遍历（LDR），首先遍历左子树，然后访问根结点，最后遍历右子树。简记左-根-右。
（3）后序遍历（LRD），首先遍历左子树，然后遍历右子树，最后访问根结点。简记左-右-根。


二、代码编写

1、树节点类的定义

package com.lin;
/**
 * 功能概要：
 * 
 * @author linbingwen
 * @since  2015年8月29日 
 */
public class TreeNode {
	
	public Integer data;
	
	/*该节点的父节点*/
	public TreeNode parent;
	
	/*该节点的左子节点*/
	public TreeNode left;
	
	/*该节点的右子节点*/
	public TreeNode right;
	
	public TreeNode(Integer data) {
		this.data = data;
		
	}

	@Override
	public String toString() {
		return "TreeNode [data=" + data + "]";
	}
		
}

2、二叉排序树的定义 

package com.lin;

/**
 * 功能概要：排序/平衡二叉树
 * 
 * @author linbingwen
 * @since  2015年8月29日 
 */
public class SearchTree {
	
     public TreeNode root;
     
     public long size;
		
	/**
	 * 往树中加节点
	 * @author linbingwen
	 * @since  2015年8月29日 
	 * @param data
	 * @return Boolean 插入成功返回true
	 */
	public Boolean addTreeNode(Integer data) {

		if (null == root) {
			root = new TreeNode(data);
			System.out.println("数据成功插入到平衡二叉树中");
			return true;
		}

		TreeNode treeNode = new TreeNode(data);// 即将被插入的数据
		TreeNode currentNode = root;
		TreeNode parentNode;

		while (true) {
			parentNode = currentNode;// 保存父节点
			// 插入的数据比父节点小
			if (currentNode.data > data) {
				currentNode = currentNode.left;
				// 当前父节点的左子节点为空
				if (null == currentNode) {
					parentNode.left = treeNode;
					treeNode.parent = parentNode;
					System.out.println("数据成功插入到二叉查找树中");
					size++;
					return true;
				}
				// 插入的数据比父节点大
			} else if (currentNode.data < data) {
				currentNode = currentNode.right;
				// 当前父节点的右子节点为空
				if (null == currentNode) {
					parentNode.right = treeNode;
					treeNode.parent = parentNode;
					System.out.println("数据成功插入到二叉查找树中");
					size++;
					return true;
				}
			} else {
				System.out.println("输入数据与节点的数据相同");
				return false;
			}
		}		
	}
	
	/**
	 * 查找数据
	 * @author linbingwen
	 * @since  2015年8月29日 
	 * @param data
	 * @return TreeNode
	 */
	public TreeNode findTreeNode(Integer data){
		if(null == root){
			return null;
		}
		TreeNode current = root;
		while(current != null){
			if(current.data > data){
				current = current.left;
			}else if(current.data < data){
				current = current.right;
			}else {
				return current;
			}
			
		}
		return null;
	}
	
}

这里暂时只放了一个增加和查找的方法

3、前、中、后遍历

package com.lin;

import java.util.Stack;

/**
 * 功能概要：
 * 
 * @author linbingwen
 * @since  2015年8月29日 
 */
public class TreeOrder {
	
    /**
     * 递归实现前序遍历
     * @author linbingwen
     * @since  2015年8月29日 
     * @param treeNode
     */
	public static void preOrderMethodOne(TreeNode treeNode) {
		if (null != treeNode) {
			System.out.print(treeNode.data + "  ");
			if (null != treeNode.left) {
				preOrderMethodOne(treeNode.left);
			}
			if (null != treeNode.right) {
				preOrderMethodOne(treeNode.right);

			}
		}
	}

	/**
	 * 循环实现前序遍历
	 * @author linbingwen
	 * @since  2015年8月29日 
	 * @param treeNode
	 */
	public static void preOrderMethodTwo(TreeNode treeNode) {
		if (null != treeNode) {
			Stack<TreeNode> stack = new Stack<TreeNode>();
			stack.push(treeNode);
			while (!stack.isEmpty()) {
				TreeNode tempNode = stack.pop();
				System.out.print(tempNode.data + "  ");
				// 右子节点不为null,先把右子节点放进去
				if (null != tempNode.right) {
					stack.push(tempNode.right);
				}
				// 放完右子节点放左子节点，下次先取
				if (null != tempNode.left) {
					stack.push(tempNode.left);
				}
			}
		}
	}
	
	/**
	 * 递归实现中序遍历
	 * @author linbingwen
	 * @since  2015年8月29日 
	 * @param treeNode
	 */
	public static void medOrderMethodOne(TreeNode treeNode){
		if (null != treeNode) {			
			if (null != treeNode.left) {
				medOrderMethodOne(treeNode.left);
			}
			System.out.print(treeNode.data + "  ");
			if (null != treeNode.right) {
				medOrderMethodOne(treeNode.right);
			}
		}
		
	}
	
	/**
	 * 循环实现中序遍历
	 * @author linbingwen
	 * @since  2015年8月29日 
	 * @param treeNode
	 */
	public static void medOrderMethodTwo(TreeNode treeNode){	
		Stack<TreeNode> stack = new Stack<TreeNode>();  
        TreeNode current = treeNode;  
        while (current != null || !stack.isEmpty()) {  
            while(current != null) {  
                stack.push(current);  
                current = current.left;  
            }  
            if (!stack.isEmpty()) {  
                current = stack.pop();  
                System.out.print(current.data+"  ");  
                current = current.right;  
            }  
        }  		
	}
	
    /**
     * 递归实现后序遍历
     * @author linbingwen
     * @since  2015年8月29日 
     * @param treeNode
     */
	public static void postOrderMethodOne(TreeNode treeNode){		
		if (null != treeNode) {		
			if (null != treeNode.left) {
				postOrderMethodOne(treeNode.left);
			}
			if (null != treeNode.right) {
				postOrderMethodOne(treeNode.right);
			}
			System.out.print(treeNode.data + "  ");
		}
		
	}
	
	/**
	 * 循环实现后序遍历
	 * @author linbingwen
	 * @since  2015年8月29日 
	 * @param treeNode
	 */
	public static void postOrderMethodTwo(TreeNode treeNode){
		if (null != treeNode) {
			Stack<TreeNode> stack = new Stack<TreeNode>();
			TreeNode current = treeNode;
			TreeNode rightNode = null;
			while(current != null || !stack.isEmpty()) {  
	            while(current != null) {  
	                stack.push(current);  
	                current = current.left;  
	            }  
	            current = stack.pop();  
	            while (current != null && (current.right == null ||current.right == rightNode)) {  
	                System.out.print(current.data + "  ");  
	                rightNode = current;  
	                if (stack.isEmpty()){  
	                    System.out.println();  
	                    return;  
	                }  
	                current = stack.pop();  
	            }  
	            stack.push(current);  
	            current = current.right;  
	        }  
			
			
			
		}
	}
	
}
4、使用方法 

package com.lin;

/**
 * 功能概要：
 * 
 * @author linbingwen
 * @since  2015年8月29日 
 */
public class SearchTreeTest {

	/**
	 * @author linbingwen
	 * @since  2015年8月29日 
	 * @param args    
	 */
	public static void main(String[] args) {
		SearchTree tree = new SearchTree();
		tree.addTreeNode(50);
		tree.addTreeNode(80);
		tree.addTreeNode(20);
		tree.addTreeNode(60);	
		tree.addTreeNode(10);
		tree.addTreeNode(30);
		tree.addTreeNode(70);
		tree.addTreeNode(90);	
		tree.addTreeNode(100);
		tree.addTreeNode(40);
		System.out.println("=============================="+"采用递归的前序遍历开始"+"==============================");
		TreeOrder.preOrderMethodOne(tree.root);
		System.out.println();
		System.out.println("=============================="+"采用循环的前序遍历开始"+"==============================");
		TreeOrder.preOrderMethodTwo(tree.root);
		System.out.println();
		System.out.println("=============================="+"采用递归的后序遍历开始"+"==============================");
		TreeOrder.postOrderMethodOne(tree.root);
		System.out.println();
		System.out.println("=============================="+"采用循环的后序遍历开始"+"==============================");
		TreeOrder.postOrderMethodTwo(tree.root);
		System.out.println();
		System.out.println("=============================="+"采用递归的中序遍历开始"+"==============================");
		TreeOrder.medOrderMethodOne(tree.root);
		System.out.println();
		System.out.println("=============================="+"采用循环的中序遍历开始"+"==============================");
		TreeOrder.medOrderMethodTwo(tree.root);

	}

}

输出结果：



同样，进行查找过程如下：

		TreeNode node = tree.findTreeNode(100);
		System.out.println(node);


结果是正确的

Evankaka
关注
  • 4
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
详解Java二叉排序树
09-02
主要介绍了Java二叉排序树，包括二叉排序树的定义、二叉排序树的性质、二叉排序树的插入和查找等，感兴趣的小伙伴们可以参考一下
数据结构—二叉树的4种遍历方式详解以及Java代码的完整演示
终生学习践行者
04-24 5641
本文介绍了4种二叉树的遍历方法，分别是前序、中序、后续、层序遍历，并且每种方法均提供了详尽的Java语言的代码演示，在最后还介绍了遍历结果推导的方法。
二叉树前，中，后序遍历的实现
qq_40823802的博客
08-22 707
思路分析： 前序遍历：先输出父节点，再遍历左子树和右子树。 中序遍历：先遍历左子树，再输出父节点，再遍历右子树。 后序遍历：先遍历左子树，再遍历右子树，最后输出父节点。 小结：看输出父节点的顺序，就确定是前序，中序还是后序。 //先创建HeroNode节点 class HeroNode { private int no; private String name; pri...
Java数据结构——二叉树的遍历
chenchenchencl的博客
10-03 9091
一文速学二叉树的遍历
Java实现二叉树的遍历
朝花夕拾
04-07 4520
6.8 遍历二叉树 假设，我手头有20张100元的和2000张1元的奖券，同时洒向了空中，大家比赛看谁最终捡的最多。如果是你，你会怎么做? 相信所有同学都会说， 一定先捡100元的。道理非常简单，因为捡一张100元等于1元的捡100张，效率好得不是一点点。所以可以得到这样的结论，同样是捡奖券，在有限时间内，要达到最高效率，次序非常重要。对于二叉树的遍历来讲，次序同样显得很重要。 二叉
代码随想录 - 二叉树的各种遍历方法（Java）
weixin_45685902的博客
03-28 1030
那么再看看中序遍历，中序遍历是左中右，先访问的是二叉树顶部的节点，然后一层一层向下访问，直到到达树左面的最底部，再开始处理节点（也就是在把节点的数值放进result数组中），这就造成了。分析一下为什么刚刚写的前序遍历的代码，不能和中序遍历通用呢，因为前序遍历的顺序是中左右，先访问的元素是中间节点，要处理的元素也是中间节点，所以刚刚才能写出相对简洁的代码，而广度优先遍历的实现一般使用队列来实现，这也是队列先进先出的特点所决定的，因为需要先进先出的结构，才能一层一层的来遍历二叉树。我们以中序遍历为例，在。
Java实现二叉排序树
09-02
说明: 可实现:构造树,插入,查找,删除. 通过模式的选择,可以插入值相等的点.但是不建议使用.
java 二叉排序树构建遍历
08-20
排序二叉树的基础代码，包含递归非递归二叉树构建、递归非递归遍历，获取最小最大值。
Java基于二叉查找树实现排序功能示例
08-29
主要介绍了Java基于二叉查找树实现排序功能,结合实例形式分析了Java二叉查找树的定义、遍历及排序等相关操作技巧,需要的朋友可以参考下
java二叉查找树的实现代码
08-29
主要为大家详细介绍了java二叉查找树的实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
二叉排序树（Java实现）
qq_37837621的博客
04-30 2144
文章收藏的好句子：坚持和放纵是永远对立的矛盾，好习惯的坚持就像春天随手丢下的种子，经历漫长的仲夏，终将会迎来收获的金秋。而坏习惯的养成真的只能让人生的脚步停止在寒风凛冽的冬天，让你永远看不见下一个春天。目录1、数列的查询和添加问题2、二叉排序树 2、1二叉排序树的介绍 2、2二叉排序树的创建和遍历 2、3二叉排序树的删除1、数列的查询和添加...
用Java实现二叉树的遍历
m0_61630116的博客
05-20 6696
树是一种非线性结构的数据结构，有一个点没有前驱，被称为根节点，它可以有多种变化，普通二叉树，N叉树，二叉搜索树（BST），红黑树（RBTree），B树等等，上述所说的树中，普通二叉树就算是比较简单的数据结构。 二叉树的存储： 二叉树的存储方式分为：顺序存储和类似于链表的链式存储。 二叉树的链式存储是通过一个一个的节点引用起来的，常见的表示方式有二叉和三叉表示方式。 我们使用孩子表示法来给大家解释一下 class TreeNode { public char val;//数据 pu
二叉排序树（Java版）
WYSCODER的博客
08-09 1336
二叉排序树
二叉排序树详解（Java实现）
qq_40749830的博客
05-01 1477
文章目录一、二叉排序树定义二、二叉树的表现形式（Java)三、创建二叉树四、遍历二叉排序树1、前序遍历2、中序遍历3、后序遍历左、右、根五、查找某个结点六、删除结点七、总结二叉排序树 一、二叉排序树定义 特点：一颗空树，或者具有以下性质的二叉树 如果左子树不为空，则左子树上所有结点的值均小于根结点的值 如果右子树不为空，则右子树上所有结点的值均大于根结点的值 它的左、右子树也分别为二叉排序树。 ...
二叉树遍历方法——前、中、后序遍历（java）
热门推荐
loss_rose777的博客
06-26 4万+
前序遍历是一种访问二叉树的每一个结点的方法，它的遍历顺序是根节点，左子树，右子树。
java二叉树的六种遍历方式
xklx_z的博客
09-06 545
java二叉树的遍历的六种实现，前中后序的递归循环
JAVA实现------二叉树的遍历，三种常见的遍历方式
IKonwNothing的博客
06-27 1355
三种常见的二叉树遍历方式
二叉搜索树（二叉排序树）—Java
m0_74365243的博客
02-11 224
BinarySearchTree-二叉搜索树（二叉排序树）
整理：Java二叉树遍历（递归、迭代、Morris）原创图解+代码
qq_64257622的博客
06-08 796
刷题的时候看到一些二叉树遍历的解法，整理在这里作为笔记，也分享给大家。语言是 Java 的，我会采取代码+图解+说明形式来尽可能讲明白每种遍历方式。
java二叉排序树代码示例
最新发布
11-04
下面是一个Java二叉排序树的代码示例： ```java public class BinarySortTree { private Node root; // 节点类 private class Node { int value; Node left; Node right; public Node(int value) { this.value = value; this.left = null; this.right = null; } } // 添加节点 public void addNode(Node node) { if (root == null) { root = node; } else { Node current = root; while (true) { if (node.value < current.value) { if (current.left == null) { current.left = node; break; } else { current = current.left; } } else { if (current.right == null) { current.right = node; break; } else { current = current.right; } } } } } // 中序遍历 public void middleSort() { middleSort(root); } private void middleSort(Node node) { if (node != null) { middleSort(node.left); System.out.print(node.value + " "); middleSort(node.right); } } // 查找节点 public Node search(int value) { Node current = root; while (current != null && current.value != value) { if (value < current.value) { current = current.left; } else { current = current.right; } } return current; } // 删除节点 public void delete(int value) { root = delete(root, value); } private Node delete(Node node, int value) { if (node == null) { return null; } if (value < node.value) { node.left = delete(node.left, value); } else if (value > node.value) { node.right = delete(node.right, value); } else { if (node.left == null) { return node.right; } else if (node.right == null) { return node.left; } Node minNode = findMin(node.right); node.value = minNode.value; node.right = delete(node.right, minNode.value); } return node; } private Node findMin(Node node) { while (node.left != null) { node = node.left; } return node; } } ```

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

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值