二叉搜索树的基础操作

如果对于二叉搜索树不是太清楚，为什么要使用二叉搜索树？作者推荐：二叉搜索树的初步认识_加瓦不加班的博客-CSDN博客

定义节点 static class BSTNode { int key; // 若希望任意类型作为 key, 则后续可以将其设计为 Comparable 接口 Object value; BSTNode left; BSTNode right; public BSTNode(int key) { this.key = key; this.value = key; } public BSTNode(int key, Object value) { this.key = key; this.value = value; } public BSTNode(int key, Object value, BSTNode left, BSTNode right) { this.key = key; this.value = value; this.left = left; this.right = right; } } 查询

参照图：

递归实现 //解题思路：从根节点出发 比根节点大的向右找 比根节点小的向左找 如果相等则返回 public Object get(int key) { return doGet(root, key); } //查询方法：递归实现 private Object doGet(BSTNode node, int key) { if (node == null) { return null; // 没找到 } if (key < node.key) { return doGet(node.left, key); // 向左找 } else if (node.key < key) { return doGet(node.right, key); // 向右找 } else { return node.value; // 找到了 } } 非递归实现 public Object get(int key) { BSTNode node = root; while (node != null) { if (key < node.key) { node = node.left; } else if (node.key < key) { node = node.right; } else { return node.value; } } return null; } Comparable

随便给个泛型T就能参与大小比较吗？不能,所以我们要对T进行限制，让它能够参与大小比较，那么就需要实现一个接口： Comparable 接口

如果希望让除 int 外更多的类型能够作为 key，一种方式是 key 必须实现 Comparable 接口。

代码实现：

//<T extends Comparable<T>>:将来我的泛型T就有个上限了，必须是Comparable的子类型，那么T就再也不是任意类型 public class BSTTree2<T extends Comparable<T>> { static class BSTNode<T> { T key; // 若希望任意类型作为 key, 则后续可以将其设计为 Comparable 接口 Object value; BSTNode<T> left; BSTNode<T> right; public BSTNode(T key) { this.key = key; this.value = key; } public BSTNode(T key, Object value) { this.key = key; this.value = value; } public BSTNode(T key, Object value, BSTNode<T> left, BSTNode<T> right) { this.key = key; this.value = value; this.left = left; this.right = right; } } //定义根节点 BSTNode<T> root; public Object get(T key) { return doGet(root, key); } //注意：key pareTo(p.key)的方法比较 //-1： key p.key //0： key =p.key //1： key p.key //递归的实现 private Object doGet(BSTNode<T> node, T key) { if (node == null) { return null; } int result = node.key pareTo(key); if (result > 0) { return doGet(node.left, key); } else if (result < 0) { return doGet(node.right, key); } else { return node.value; } } //非递归的实现 //注意：key pareTo(p.key)的方法比较 //-1： key p.key //0： key =p.key //1： key p.key //非递归的实现 public Object get(T key){ BSTNode<T> p=root; while (p!=null){ int result = key pareTo(p.key); if(result<0){ p=p.left; }else if(result>0){ p=p.right; }else { return p.value; } } return null; } }

还有一种做法不要求 key 实现 Comparable 接口，而是在构造 Tree 时把比较规则作为 Comparator 传入，将来比较 key 大小时都调用此 Comparator 进行比较，这种做法可以参考 Java 中的 java.util.TreeMap

当然我们也可以实现像Map一样的格式，给value也加个泛型，然后我们将key的泛型修改一下名字，就更像Map<K,V>:

public class BSTTree2<K extends Comparable<K>, V> { static class BSTNode<K, V> { K key; V value; BSTNode<K, V> left; BSTNode<K, V> right; public BSTNode(K key) { this.key = key; } public BSTNode(K key, V value) { this.key = key; this.value = value; } public BSTNode(K key, V value, BSTNode<K, V> left, BSTNode<K, V> right) { this.key = key; this.value = value; this.left = left; this.right = right; } } BSTNode<K, V> root; public V get(K key) { BSTNode<K, V> p = root; while (p != null) { /* -1 key < p.key 0 key == p.key 1 key > p.key */ int result = key pareTo(p.key); if (result < 0) { p = p.left; } else if (result > 0) { p = p.right; } else { return p.value; } } return null; } }

但是后面，我们为了更加使得我们小白能够更好理解代码，我们还是以int key,object value来实现后续的代码。

查询最小值

参照图：

递归实现

思路：从根节点开始，一直往左走，一直走到最后的节点没有左孩子就停止

//思路：从根节点开始，一直往左走，一直走到最后的节点没有左孩子就停止 public Object min() { return doMin(root); } public Object doMin(BSTNode node) { if (node == null) {//当给的节点为Null 我们就不需要去找 return null; } // 左边已走到头 if (node.left == null) { //最小的节点 return node.value; } return doMin(node.left); } 非递归实现 public Object min() { if (root == null) { return null; } BSTNode p = root; // 左边未走到头 while (p.left != null) { p = p.left; } return p.value; } 查询最大值

参考：其实现方法与《最小》的操作基本上是一样的

递归实现 public Object max() { return doMax(root); } public Object doMax(BSTNode node) { if (node == null) { return null; } // 右边已走到头 if (node.left == null) { return node.value; } return doMin(node.right); } 非递归实现 public Object max() { if (root == null) { return null; } BSTNode p = root; // 右边未走到头 while (p.right != null) { p = p.right; } return p.value; } 新增操作

参考图：

解题思路：

//1.key在该二叉树中有 那就更新key所对应的value值 //2.key在该二叉树中没有 那就新增key与所对应的value值

新增前：

新增后：

图示解析：以上述图为例，新增前，从根节点开始找，找到8时，9大于8，那么就要要继续向右找，但是此时前进不了了，因为8已经是叶子节点，走到头还没有找到9，那么就新增9连通值一起创建出来，做为8的右孩子新增进去。

递归实现 public void put(int key, Object value) { root = doPut(root, key, value); } private BSTNode doPut(BSTNode node, int key, Object value) { if (node == null) { return new BSTNode(key, value); } if (key < node.key) { node.left = doPut(node.left, key, value); } else if (node.key < key) { node.right = doPut(node.right, key, value); } else { node.value = value; } return node; }

若找到 key，走 else 更新找到节点的值

若没找到 key，走第一个 if，创建并返回新节点

返回的新节点，作为上次递归时 node 的左孩子或右孩子

缺点是，会有很多不必要的赋值操作

非递归实现 public void put(int key, Object value) { BSTNode node = root; BSTNode parent = null; while (node != null) { parent = node;// 4 7 8 if (key < node.key) { node = node.left; } else if (node.key < key) { node = node.right;//4->7 7->8 8->null } else { // 1. key 存在则更新 node.value = value; return; } } // 2. key 不存在则新增 if (parent == null) { //当我二叉树是null，那么parent初始就是Null 那么新增的key就是根节点 root = new BSTNode(key, value); } else if (key < parent.key) { parent.left = new BSTNode(key, value); } else { parent.right = new BSTNode(key, value); } } 查询节点的前驱后继

什么叫屈曲与后继？

答：

一个节点的前驱（前任）节点是指比它小的节点中，最大的那个

一个节点的后继（后任）节点是指比它大的节点中，最小的那个

1 2 3 4 5 6 7 8

例如上图中

1 没有前驱，后继是 2

2 前驱是 1，后继是 3

3 前驱是 2，后继是 4

...

查询节点前驱

简单的办法是中序遍历，即可获得排序结果，此时很容易找到前驱后继

二叉树的中序遍历就是升序的结果

要效率更高，需要研究一下规律，找前驱分成 2 种情况：

节点有左子树，此时前驱节点就是左子树中的最大值， 图中属于这种情况的有

2 的前驱是1

4 的前驱是 3

6 的前驱是 5

7 的前驱是 6

个人理解：比如:(4的前驱节点有 1 2 3，其中最大值就是3)

节点没有左子树，若离它最近的祖先自从左而来，此祖先即为前驱，如

3 的祖先 2 自左而来，前驱 2

5 的祖先 4 自左而来，前驱 4

8 的祖先 7 自左而来，前驱 7

1 没有这样的祖先，前驱 null

个人理解：比如:(5的祖先节点有 6 7 4，其中以5为参考点，右边6和7都是比5大的，左边4是比5小的，从左而来的祖先4即为前驱)

比如:(3的祖先节点有 2 4，其中以3为参考点，右边4是比3大的，左边2是比3小的，从左而来的祖先2即为前驱)

// 情况2 - 有祖先自左而来 //对于情况2，我们如何知道哪些节点是要找节点的祖先，又是如何知道这些祖先节点哪些是自从左而来的呢？ //以5节点为例，那我要找到5这个节点的过程中，它必然已经经历过一些节点了，从根节点4开始找，5比4大就向右找，7比5大就向左找，6比5大就像左找，找到了

//在从根节点开始4 7 6是不是都是5的祖先？是的  其实循环的每步都是在经历他这些祖先节点，好，现在知道怎么去获取祖先节点。

//那我们怎么去进一步判断 它这个祖先是左边来还是从右边来呢？ //答：你看4到7是不是向右走，那么以5为参考点，那么4是不是在左边？那么7到6、6到5都是向左走，但是以5为参考点，那么7到6、6到5都是向右走 //所以只要我们看到这种向右走的代码if (p.key < key) {p = p.right;}那就表示祖先是自左而来 //而且我们每次循环更新都是最新也就是最近的自左而来的祖先节点

在predecessor方法之前，我们对于Max方法进行简单的修改，因为我们上面写的Max方法仅仅只是针对于root根节点来查询最大：

//非递归实现 针对于root的max方法 public Object max() { return max(root); // if (root == null) { // return null; // } // BSTNode p = root; // // 右边未走到头 // while (p.right != null) { // p = p.right; // } // return p.value; } //通用的Max方法 private Object max(BSTNode node){ if (node == null) { return null; } BSTNode p = node; // 右边未走到头 while (p.right != null) { p = p.right; } return p.value; }

然后我们就开始书写查询节点的前驱代码：

public Object predecessor(int key) { BSTNode ancestorFromLeft = null; BSTNode p = root; //查找用户给的Key在二叉树中是否有 while (p != null) { if (key < p.key) { p = p.left; } else if (p.key < key) { ancestorFromLeft = p; p = p.right; } else { break; } } //key没找到，说明也就没有前任节点 if (p == null) { return null; } // 情况1 - 有左孩子 if (p.left != null) { return max(p.left); } // 情况2 - 有祖先自左而来 //对于情况2，我们如何知道哪些节点是要找节点的祖先，又是如何知道这些祖先节点哪些是自从左而来的呢？ //以5节点为例，那我要找到5这个节点的过程中，它必然已经经历过一些节点了，从根节点4开始找，5比4大就向右找，7比5大就向左找，6比5大就像左找，找到了 //在从根节点开始4 7 6是不是都是5的祖先？是的 其实循环的每步都是在经历他这些祖先节点，好，现在知道怎么去获取祖先节点。 //那我们怎么去进一步判断 它这个祖先是左边来还是从右边来呢？ //答：你看4到7是不是向右走，那么以5为参考点，那么4是不是在左边？那么7到6、6到5都是向左走，但是以5为参考点，那么7到6、6到5都是向右走 //所以只要我们看到这种向右走的代码if (p.key < key) {p = p.right;}那就表示祖先是自左而来 //而且我们每次循环更新都是最新也就是最近的自左而来的祖先节点 return ancestorFromLeft != null ? ancestorFromLeft.value : null; }

查询节点后继

找后继也分成 2 种情况 与找前任的代码相类似

节点有右子树，此时后继节点即为右子树的最小值，如

2 的后继 3

3 的后继 4

5 的后继 6

7 的后继 8

节点没有右子树，若离它最近的祖先自从右而来，此祖先即为后继，如

1 的祖先 2 自右而来，后继 2

4 的祖先 5 自右而来，后继 5

6 的祖先 7 自右而来，后继 7

8 没有这样的祖先，后继 null

在successor方法之前，我们对于Min方法进行简单的修改，因为我们上面写的Min方法仅仅只是针对于root根节点来查询最小：

//非递归实现 public Object min() { return min(root); // if (root == null) { // return null; // } // BSTNode p = root; // // 左边未走到头 // while (p.left != null) { // p = p.left; // } // return p.value; } private Object min(BSTNode node){ if (node == null) { return null; } BSTNode p = node; // 左边未走到头 while (p.left != null) { p = p.left; } return p.value; }

然后我们就开始书写查询节点的后继代码：

public Object successor(int key) { BSTNode ancestorFromRight = null; BSTNode p = root; while (p != null) { if (key < p.key) { ancestorFromRight = p; p = p.left; } else if (p.key < key) { p = p.right; } else { break; } } if (p == null) { return null; } // 情况1 - 有右孩子 if (p.right != null) { return min(p.right); } // 情况2 - 有祖先自右而来 return ancestorFromRight != null ? ancestorFromRight.value : null; } 删除操作

要删除某节点（称为 D），必须先找到被删除节点的父节点，这里称为 Parent

1.删除节点没有左孩子，将右孩子托孤给 Parent

2.删除节点没有右孩子，将左孩子托孤给 Parent

3.删除节点左右孩子都没有，已经被涵盖在情况1、情况2当中，把null托孤给Parent

4.删除节点左右孩子都有，可以将它的后继节点（称为S)托孤给Parent,设S的父亲为SP,又分两种情况:

               1.SP 就是被删除节点，此时 D 与 S 紧邻，只需将 S 托孤给 Parent

               2.SP 不是被删除节点，此时 D 与 S 不相邻，此时需要将 S 的后代托孤给 SP，再将 S 托孤给 Parent

非递归实现 /** * <h3>根据关键字删除</h3> * * @param key 关键字 * @return 被删除关键字对应值 */ public Object delete(int key) { BSTNode p = root; BSTNode parent = null;//记录待删除节点的父亲 while (p != null) { if (key < p.key) { parent = p; p = p.left; } else if (p.key < key) { parent = p; p = p.right; } else { break; } } if (p == null) { return null; } // 删除操作 if (p.left == null) { shift(parent, p, p.right); // 情况1 } else if (p.right == null) { shift(parent, p, p.left); // 情况2 } else { // 情况4：被删除节点是左、右都有子节点，所以找后继节点：节点有右子树，此时后继节点即为右于树的最小值 // 4.1 被删除节点找后继 BSTNode s = p.right;//后继节点 BSTNode sParent = p; // 后继父亲 while (s.left != null) { //当循环结束，后继节点即为s sParent = s; s = s.left; } // 4.2 删除和后继不相邻, 处理后继的后事 if (sParent != p) { shift(sParent, s, s.right); // 不可能有左孩子：因为节点有右子树，此时后继节点即为右于树的最小值 s.right = p.right;//顶上去的后继节点的右孩子==被删除节点的右孩子 } // 4.3 后继取代被删除节点 shift(parent, p, s); s.left = p.left;//shift方法只改变了父类节点的左右孩子的指向，而没有改变你后继节点的做左右孩子的指向 } return p.value; } /** * 托孤方法 * * @param parent 被删除节点的父亲 * @param deleted 被删除节点 * @param child 被顶上去的节点 */ // 只考虑让 n1父亲的左或右孩子指向 n2, n1自己的左或右孩子并未在方法内改变 private void shift(BSTNode parent, BSTNode deleted, BSTNode child) { //情况讨论：当被删除节点就是根节点，而根节点是没有父亲的 if (parent == null) { root = child;//你们被删除节点的子节点就成根节点 } else if (deleted == parent.left) { parent.left = child; } else { parent.right = child; } } 递归实现 /** * <h3>根据关键字删除</h3> * * @param key 关键字 * @return 被删除关键字对应值 是删除单个节点，当该节点被删除，则它的子节点将会与该节点的父类节点进行连接 */ public Object remove(int key) { ArrayList<Object> result = new ArrayList<>(); // 保存被删除节点的值 root = doRemove(root, key, result); return result.isEmpty() ? null : result.get(0); } /* 4 / \ 2 6 / \ 1 7 node 起点 返回值 删剩下的孩子(找到) 或 null(没找到) */ //递归实现删除操作 BSTNode node:我要删除时，从哪个节点开始删除 node是起点 private BSTNode doRemove(BSTNode node, int key, ArrayList<Object> result) { //1.没有找到的情况： if (node == null) { return null; } //2.找到的情况： if (key < node.key) {//向左查找 node.left = doRemove(node.left, key, result); return node; } if (node.key < key) {//向右查找 node.right = doRemove(node.right, key, result); return node; } result.add(node.value); if (node.left == null) { // 情况1 - 只有右孩子 return node.right; } if (node.right == null) { // 情况2 - 只有左孩子 return node.left; } //s：后继节点 BSTNode s = node.right; // 情况3 - 有两个孩子 while (s.left != null) { s = s.left; } //while循环结束以后，找到了后继节点 s.right = doRemove(node.right, s.key, new ArrayList<>()); s.left = node.left; return s; }

对于第四种情况进行代码解析：

当D与S紧邻：

当D与S不是紧邻：

对于remove方法的解析：

说明

ArrayList<Object> result 用来保存被删除节点的值

第二、第三个 if 对应没找到的情况，继续递归查找和删除，注意后续的 doDelete 返回值代表删剩下的，因此需要更新

最后一个 return 对应删除节点只有一个孩子的情况，返回那个不为空的孩子，待删节点自己因没有返回而被删除

第四个 if 对应删除节点有两个孩子的情况，此时需要找到后继节点，并在待删除节点的右子树中删掉后继节点，最后用后继节点替代掉待删除节点返回，别忘了改变后继节点的左右指针

范围查询

下面三种题型的核心解题思路：

我们利用中序遍历的特性：遍历出来的都是升序的结果来进行范围查询

找小的 /* 4 / \ 2 6 / \ / \ 1 3 5 7 */ //找 > key 的所有 value //解题思路：我们利用中序遍历的特性：遍历出来的都是升序的结果 public List<Object> less(int key) { //当我们输入的是6 //result：将符合条件的加入到result中 ArrayList<Object> result = new ArrayList<>(); //中序遍历过程： BSTNode p = root; LinkedList<BSTNode> stack = new LinkedList<>(); while (p != null || !stack.isEmpty()) { if (p != null) { stack.push(p); p = p.left; } else { BSTNode pop = stack.pop(); if (pop.key < key) { result.add(pop.value); } else { //当我们遇到比key大的分支时，该分支的子分支就没必要多此一举的进行判断，直接跳出 //比如：当key=6，那么我们6右节点就不需要多此一举的去判断，而是直接跳出 break; } p = pop.right; } } return result; } 找大的

方法与《找小的》操作类似

第一种方法：

/* 4 / \ 2 6 / \ / \ 1 3 5 7 */ //解题思路：我们利用中序遍历的特性：遍历出来的都是升序的结果 public List<Object> greater(int key) { ArrayList<Object> result = new ArrayList<>(); BSTNode p = root; LinkedList<BSTNode> stack = new LinkedList<>(); while (p != null || !stack.isEmpty()) { if (p != null) { stack.push(p); p = p.left; } else { BSTNode pop = stack.pop(); if (pop.key > key) {//在这里，我们遍历>key的就不需要break,让它执行到子节点为Null result.add(pop.value); } p = pop.right; } } return result; }

但这样效率不高，可以用 RNL 遍历

什么是RNL 遍历？

答：

注：

前三中就是我们之前所讲的前、中、后序遍历 N：值 L：左 R：右

Pre-order, NLR

In-order, LNR

Post-order, LRN

以下三种遍历与上三种遍历的区别：上三种是先左后右，下三种是先右后左

Reverse pre-order（反向前序遍历）, NRL

Reverse in-order（中向前序遍历）, RNL

Reverse post-order（反向后序遍历）, RLN

第二种方法：

public List<Object> greater(int key) { ArrayList<Object> result = new ArrayList<>(); BSTNode p = root; //RNL 遍历:得到的是降序的结果 LinkedList<BSTNode> stack = new LinkedList<>(); while (p != null || !stack.isEmpty()) { if (p != null) { stack.push(p); p = p.right; } else { BSTNode pop = stack.pop(); if (pop.key > key) { result.add(pop.value); } else { break; } p = pop.left; } } return result; } 找之间

方法与《找小的》操作类似

public List<Object> between(int key1, int key2) { ArrayList<Object> result = new ArrayList<>(); BSTNode p = root; LinkedList<BSTNode> stack = new LinkedList<>(); while (p != null || !stack.isEmpty()) { if (p != null) { stack.push(p); p = p.left; } else { BSTNode pop = stack.pop(); if (pop.key >= key1 && pop.key <= key2) { result.add(pop.value); } else if (pop.key > key2) { break; } p = pop.right; } } return result; }

小结

优点：

如果每个节点的左子树和右子树的大小差距不超过一，可以保证搜索操作的时间复杂度是 O(log n)，效率高。

插入、删除结点等操作也比较容易实现，效率也比较高。

对于有序数据的查询和处理，二叉查找树非常适用，可以使用中序遍历得到有序序列。

缺点：

如果输入的数据是有序或者近似有序的，就会出现极度不平衡的情况，可能导致搜索效率下降，时间复杂度退化成O(n)。

对于频繁地插入、删除操作，需要维护平衡二叉查找树，例如红黑树、AVL 树等，否则搜索效率也会下降。

对于存在大量重复数据的情况，需要做相应的处理，否则会导致树的深度增加，搜索效率下降。

对于结点过多的情况，由于树的空间开销较大，可能导致内存消耗过大，不适合对内存要求高的场景。