二叉查找树（Java实现）

最新推荐文章于 2024-04-17 10:42:18 发布
最新推荐文章于 2024-04-17 10:42:18 发布
阅读量407 收藏 1
点赞数
分类专栏： 算法 文章标签： 二叉树 算法 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Salmon1122/article/details/109605788
版权

先来API：
在这里插入图片描述

public class BST<Key extends Comparable<Key>, Value> {
	private Node root;

	private class Node {
		private Key key;
		private Value val;
		private Node left, right;
		private int N;

		public Node(Key key, Value val, int N) {
			this.key = key;
			this.val = val;
			this.N = N;
		}
	}

	public int size() {
		return size(root);
	}

	private int size(Node x) {
		if (x == null) {
			return 0;
		} else {
			return x.N;
		}
	}

	public Value get(Key key) {
		return get(root, key);
	}

	private Value get(Node x, Key key) {
		if (x == null) {
			return null;
		}
		int cmp = key.compareTo(x.key);
		if (cmp < 0) {
			return get(x.left, key);
		} else if (cmp > 0) {
			return get(x.right, key);
		} else {
			return x.val;
		}
	}

	public void put(Key key, Value val) {
		root = put(root, key, val);
	}

	private Node put(Node x, Key key, Value val) {
	//此方法实现了二叉树的重要性质
		if (x == null) {
			return new Node(key, val, 1);
		}
		int cmp = key.compareTo(x.key);
		if (cmp < 0) {
			x.left = put(x.left, key, val);
		} else if (cmp > 0) {
			x.right = put(x.right, key, val);
		} else {
			x.val = val;
		}
		x.N = size(x.left) + size(x.right) + 1;
		return x;
	}

	public Key max() {
		return max(root).key;
	}

	private Node max(Node x) {
		if (x.right == null) {
			return x;
		}
		return max(x.right);
	}

	public Key min() {
		return min(root).key;
	}

	private Node min(Node x) {
		if (x.left == null) {
			return x;
		}
		return min(x.left);
	}

	public Key floor(Key key) {
		Node x = floor(root, key);
		if (x == null) {
			return null;
		}
		return x.key;
	}

	private Node floor(Node x, Key key) {
		if (x == null) {
			return null;
		}
		int cmp = key.compareTo(x.key);
		if (cmp == 0) {
			return x;
		}
		if (cmp < 0) {
			return floor(x.left, key);
		}
		Node t = floor(x.right, key);
		if (t != null) {
			return t;
		} else {
			return x;
		}
	}

	public Key ceiling(Key key) {
		Node x = ceiling(root, key);
		if (x == null) {
			return null;
		}
		return x.key;
	}

	private Node ceiling(Node x, Key key) {
		if (x == null) {
			return null;
		}
		int cmp = key.compareTo(x.key);
		if (cmp == 0) {
			return x;
		}
		if (cmp > 0) {
			return floor(x.right, key);
		}
		Node t = floor(x.left, key);
		if (t != null) {
			return t;
		} else {
			return x;
		}
	}

	public Key select(int k) {
		return select(root, k).key;
	}

	private Node select(Node x, int k) {
		if (x == null) {
			return null;
		}
		int t = size(x.left);
		if (t > k) {
			return select(x.left, k);
		} else if (t < k) {
			return select(x.right, k - t - 1);
		} else {
			return x;
		}
	}

	public int rank(Key key) {
		return rank(key, root);
	}

	private int rank(Key key, Node x) {
		if (x == null) {
			return 0;
		}
		int cmp = key.compareTo(x.key);
		if (cmp < 0) {
			return rank(key, x.left);
		} else if (cmp > 0) {
			return 1 + size(x.left) + rank(key, x.right);
		} else {
			return size(x.left);
		}
	}

	public void deleteMin() {
		root = deleteMin(root);
	}

	private Node deleteMin(Node x) {
		if (x.left == null) {
			return x.right;
		}
		x.left = deleteMin(x.left);
		x.N = size(x.left) + size(x.right) + 1;
		return x;
	}

	public void deleteMax() {
		root = deleteMax(root);
	}

	private Node deleteMax(Node x) {
		if (x.right == null) {
			return x.left;
		}
		x.right = deleteMax(x.right);
		x.N = size(x.left) + size(x.right) + 1;
		return x;
	}

	public void delete(Key key) {
		root = delete(root, key);
	}

	private Node delete(Node x, Key key) {
		if (x == null) {
			return null;
		}
		int cmp = key.compareTo(x.key);
		if (cmp < 0) {
			x.left = delete(x.left, key);
		} else if (cmp > 0) {
			x.right = delete(x.right, key);
		} else {
			if (x.right == null) {
				return x.left;
			}
			if (x.left == null) {
				return x.right;
			}
			Node t = x;
			x = min(t.right);
			x.right = deleteMin(t.right);
			x.left = t.left;
		}
		x.N = size(x.left) + size(x.right) + 1;
		return x;
	}

	public Iterable<Key> keys() {
		return keys(min(), max());
	}

	public Iterable<Key> keys(Key lo, Key hi) {
		Queue<Key> queue = new Queue<Key>();
		keys(root, queue, lo, hi);
		return queue;
	}

	private void keys(Node x, Queue<Key> queue, Key lo, Key hi) {
		if (x == null) {
			return;
		}
		int cmplo = lo.compareTo(x.key);
		int cmphi = hi.compareTo(x.key);
		if (cmplo < 0) {
			keys(x.left, queue, lo, hi);
		}
		if (cmplo <= 0 && cmphi >= 0) {
			queue.enqueue(x.key);
		}
		if (cmphi > 0) {
			keys(x.right, queue, lo, hi);
		}
	}

	// Exercise 3.2.6
	public int height() {
		return height(root);
	}

	private int height(Node x) {
		if (x == null) {
			return -1;
		}
		return 1 + Math.max(height(x.left), height(x.right));
	}

	// Exercise 3.2.32
	private boolean isBST() {
		return isBST(root, null, null);
	}

	private boolean isBST(Node x, Key min, Key max) {
		if (x == null) {
			return true;
		}
		if (min != null && x.key.compareTo(min) <= 0) {
			return false;
		}
		if (max != null && x.key.compareTo(max) >= 0) {
			return false;
		}
		return isBST(x.left, min, x.key) && isBST(x.right, x.key, max);
	}

	/**
	 * Exercise 3.2.33
	 * 
	 * @return
	 */
	public boolean isRankConsistent() {
		for (int i = 0; i < size(); i++) {
			if (i != rank(select(i))) {
				return false;
			}
		}
		for (Key key : keys()) {
			if (!key.equals(select(rank(key)))) {
				return false;
			}
		}
		return true;
	}
}

对于二叉树的性质：对于根节点来说，左子树的所有结点都比它本身小，右子树的所有结点都比它本身大

查找过程图：

在这里插入图片描述

插入过程图

在这里插入图片描述

floor方法图示

在这里插入图片描述

select方法图示( 即找出排名为某的键)

在这里插入图片描述

删除图示

在这里插入图片描述
在这里插入图片描述

思想分析：

查找

  • A、如果二叉查找树为空，查找失败（search miss），返回null；

  • B、如果根节点的键等于要查找的键，返回根节点的值（search hit）。

  • C、继续在相应的子树中查找。如果要查找的键小于根节点的键，在左子树中查找；如果要查找的键大于根节点的键，在右子树中查找。

  • D、重复ABC步骤，直至search miss或者search hit。

插入实现

  • A、如果二叉查找树是空的，生成一个新节点，并返回该节点

  • B、如果根节点键和要插入的键相等，更新根节点的值。

  • C、如果要插入的键小于根节点的键，在左子树插入，并将根节点的左链接指向插入后的左子树。

  • D、如果要插入的键小于根节点的键，在右子树插入，并将根节点的右链接指向插入后的右子树。

  • E、更新根节点的size，并返回根节点，作为插入新节点后的二叉树根节点。

  • F、重复ABCD，直至插入或者更新成功。

min实现和max实现

  • A、如果根节点的左链接是null，返回根结点。

  • B、否则继续在左子树中查找。

  • C、重复AB，直至找到一个根节点的左链接是null，返回当前结点。

floor和ceiling实现

思路：
如果给定的键key小于二叉查找树根节点的键，那么小于等于key的最大键floor（key）一定在根节点的左子树中；
如果给定的键key大于二叉查找树根节点的键，那么只有当根结点右子树中存在小于等于key的结点时，小于等于key的最大键才会出现在右子树中，否则根结点就是floor（key）

  • A、如果根节点是null，则直接返回null。

  • B、如果根节点键值大于key，则继续floor(key)在左子树中，所以继续在左子树中查找。

  • C、如果根节点键值刚好等于key，则根节点的键值即为floor(key)，直接返回该键。

  • D、如果根节点键值小于key，那么根节点的key有可能就是floor(key)，只要右子树中不存在节点的key小于等于输入的key。

  • E、重复ABCD

select实现
size是专门为select和rank等函数准备的。

  • A、如果根节点为null，直接返回null。

  • B、如果左子树的节点个数为t，select(k)，如果t=k，那么直接返回根节点的值。

  • C、如果t>k，根节点的排序太大，需要在左子树中继续select(k)。

  • D、如果t<k，根节点的排序太小，需要在右子树中继续select(k-t-1)。

  • E、重复ABCD

rank实现

  • A、如果根节点为null，返回0。

  • B、如果根节点的键刚好等于key，返回左子树的节点个数（刚好只有左子树的所有键小于key）。

  • C、如果根节点的键大于key，则在左子树中rank(key)（只有左子树才有小于key的键）。

  • D、如果根节点的键小于key，则除了左子树所有键都小于key外，右子树也可能有小于key的键，则返回左子树的节点个数+rank(key)在右子树的值+1。

  • E、重复ABCD。

删除最小值和最大值
  • 一直往左走，直到到达左链接为null的节点x（最小值），然后将指向该节点x的链接替换为x.right。
删除节点

如果要删除的节点x只有子节点或者没有子节点，那么可以效仿删除最小值和最大值的做法。

如果有两个子节点呢？应该在右子树中找继承者来替换x，然后再返回x。

  • A、用t保存即将删除的节点x。

  • B、将x指向右子树的最小键节点，也就是继承者。

  • C、x.right = deleteMin(t.right)。

  • D、x.left = t.left。

参考了以下博客：

https://www.cnblogs.com/songdechiu/p/6821168.html

salmon1802
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
java二叉查找树的实现代码
08-29
主要为大家详细介绍了java二叉查找树的实现代码，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
Java基于二叉查找树实现排序功能示例
08-29
主要介绍了Java基于二叉查找树实现排序功能,结合实例形式分析了Java二叉查找树的定义、遍历及排序等相关操作技巧,需要的朋友可以参考下
【Java】Java泛型类继承Comparable接口
qgnczmnmn的博客
06-04 4025
遇到一个泛型类中的新应用，记录一下，如果泛型类中的泛型需要进行比较可以通过让泛型继承Comparable接口的方式来实现，如下： public class SortedSymbolList<Key extends Comparable<Key>, Value> { // .................. // Key类型继承了Comparable接口以后就可以在代码中，Key类型的参数就可以进行比较的操作了 } 或者 public class SortedList<T
【大数据存储】Java实现B+树(增、删、单值查询和范围查询)
m0_53700832的博客
05-20 661
BPlusNode.java package BplusTree; import java.util.*; @SuppressWarnings("all") public class BPlusNode<K extends Comparable<K>, V> { // 是否为叶子节点 protected boolean isLeaf; //是否是根节点 protected boolean isRoot; // 父节点 pr
Java实现二叉搜索树
最新发布
枫飘长安的博客
04-17 570
Java实现二叉搜索树
高级数据结构（Ⅱ）优先队列（Priority Queue）
像写诗一样优雅地写代码~
01-18 6642
高级数据结构（Ⅱ）优先队列（Priority Queue） 许多应用程序都需要处理有序的元素，但不一定要求它们全部有序，或是不一定要一次就将它们排序。很多情况下我们会收集一些元素，处理当前键值最大的元素，然后再收集更多的元素，再处理当前键值最大的元素，如此这般。例如，你可能有一台能够同时运行多个应用程序的电脑（或者手机）。这是通过为每个应用程序事件分配一个优先级，并总是处理下一个优先级最高的事件来实现的。例如，绝大多数手机分配给来电的优先级都会被游戏程序的高。 在这种情况下，一个合适的数据结构应该支持两种操
Python 每日一记241@Java有序符号表实现及key extends Comparable的理解
教练我想学编程
04-17 587
一、思路 上一篇文章，在添加元素时暴力的将其添加到head的后面，如果要根据key的顺序有序的添加怎么办？ 我们在添加的时候循环判断key的大小即可，就是和循环到的节点的key比较，但是要比较的话，就得提供比较规则，这个时候就可以使用Comparable，让key extends Comparable，这样key就可以使用compareTo方法了。 二、Java代码实现 直接看put方法即可，其他...
Java—数据结构之二叉搜索树
m0_68840064的博客
11-18 1010
在Java数据结构之二叉搜索树的学习中，我通过总结以及查阅资料，对以下问题有了更深一层的理解。什么是二叉搜索树，二叉搜索树有什么样的性质以及特点？二叉搜索树该如何进行查找，插入及删除？二叉搜索树的时间复杂度该如何计算？如果你在Java数据结构之二叉搜索树的学习中，也想对这些问题有一个更深的了解，请阅读这篇文章，或许会对你有所启发。二叉搜索树又叫二叉排序树，它或是一颗空树，或是具有以下性质的二叉树若它的左子树不为空，则左子树上的所有结点都小于根结点上的值。
二叉查找树java
09-02
java实现二叉查找树的插入、删除、遍历、查询
二叉查找树的具体实现-java
10-29
二叉搜索树的效率： 树的大部分操作需要从上至下一层层的查找树的节点，对于一棵满树，大约有一半的节点处于最底层（最底层节点数 = 其它层节点数的和 + 1），故节点操作大约有一半需要找到最底层节点，大约有四分...
Java实现二叉排序树
09-02
说明: 可实现:构造树,插入,查找,删除. 通过模式的选择,可以插入值相等的点.但是不建议使用.
数据结构：二叉查找树
梁辰兴的博客
09-17 716
二叉查找树（Binary Search Tree，简称BST）是一种特殊的二叉树，其中每个节点都有一个可比较的键和一个关联的值，且对于每个节点，其左子树的所有键都小于节点的键，而右子树的所有键都大于节点的键。简介二叉查找树是一种自我平衡的二叉树，它的中序遍历会得到一个升序的序列。二叉查找树的每个节点都包含一个键和一个值，其中键用于保持树的排序，而值则可以是任何类型的数据。二叉查找树的主要操作包括插入、查找和删除。图示50/ \30 70/ \ / \
Java二叉搜索树
m0_64318128的博客
11-05 1314
二叉搜索树的概念、性质，二叉搜索树的实现
数据结构之搜索二叉树
qq_56999918的博客
11-24 1024
目录 搜索二叉树基本介绍： 二叉搜索树的插入： 二叉搜索树的查找： 二叉搜索树的删除： 普通二叉树的删除： 搜索二叉树基本介绍： 1.二叉搜索树的概念： 二叉搜索树又称二叉查找树，亦称为二叉排序树。设x为二叉查找树中的一个节点，x节点包含关键字key，节点x的key值记为key[x]。如果y是x的左子树中的一个节点，则key[y] <= key[x]；如果y是x的右子树的一个节点，则key[y] >= key[x]。 2.二叉搜索树的性质： （1）若左子树不...
【Java 数据结构与算法】-二叉搜索树
m0_63979882的博客
03-25 728
二叉搜索树的概念，二叉搜索树的查找、新增，保姆级别分析二叉搜索树的删除问题。
二叉查找树(Java)
qq_45910820的博客
04-27 627
很多情况下，我们可能需要像遍历数组数组一样，遍历树，从而拿出树中存储的每一个元素，由于树状结构和线性结构不一样，它没有办法从头开始依次向后遍历，所以存在如何遍历，也就是按照什么样的。在某些情况下，我们需要查找出树中存储所有元素的键的最大值，比如比如我们的树中存储的是学生的成绩和学生的姓名，那么需要查找出最高的分数是多少？根据对图的观察，我们发现二叉树其实就是由一个一个的结点及其之间的关系组成的，按照面向对象的思想，我们设计一个结点类来描述结点这个事物。找到当前结点的左子树，如果不为空，递归遍历左子树。
Java实现第k选择（线性时间选择）
weixin_57093836的博客
05-13 766
package test2; import java.util.Random; import java.util.Scanner; public class xianxing{ public void geta(int a[]) { Random rd=new Random(); for(int i=0;i<10;i++) { a[i]=rd.nextInt(100)+1; } } public void printa0(int a[]) { System.out.print(“生
二叉树——查找指定节点
Blackoutdragon的博客
01-19 6492
二叉树——查找指定节点 前序查找 思路分析 先判断当前节点是否为要查找的节点，相等就返回当前节点，作为递归中值的条件 如果不相等，判断左子节点是否为空，不为空，递归前序查找 如果左递归前序查找，找到该节点，那就返回该节点 没找到，那就判定右子节点是否为空，不为空就进行右子节点的递归前序查找 代码实现 我的代码： public HeroNode preOrderSearch(int no){...
二叉查找树java实现
06-02
好的，下面是一份基本的二叉查找树的 Java 实现代码： ``` public class BinarySearchTree { private Node root; private class Node { private int key; private Node left; private Node right; public ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值