数据结构和算法（十一）之二叉搜索树

最新推荐文章于 2024-04-23 15:29:24 发布
最新推荐文章于 2024-04-23 15:29:24 发布
阅读量345 收藏
点赞数 1
分类专栏： 数据结构和算法 文章标签： 数据结构 算法 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yige001/article/details/124278847
版权

数据结构和算法（十一）之二叉搜索树

一. 二叉搜索树的概念

我们先来简单理解一下什么是二叉搜索树.

什么是二叉搜索树?

  • 二叉搜索树（BST，Binary Search Tree），也称二叉排序树或二叉查找树

  • 二叉搜索树是一颗二叉树, 可以为空；如果不为空，满足以下性质：

    • 非空左子树的所有键值小于其根结点的键值。
    • 非空右子树的所有键值大于其根结点的键值。
    • 左、右子树本身也都是二叉搜索树。

  • 下面哪些是二叉搜索树, 哪些不是?

  • 二叉搜索树的特点:

    • 二叉搜索树的特点就是相对较小的值总是保存在左结点上, 相对较大的值总是保存在右结点上.
    • 那么利用这个特点, 我们可以做什么事情呢?
    • 查找效率非常高, 这也是二叉搜索树中, 搜索的来源.

二叉搜索树的操作

  • 二叉搜索树有哪些常见的操作呢?
    • insert(key)：向树中插入一个新的键。
    • search(key)：在树中查找一个键，如果结点存在，则返回true；如果不存在，则返回false。
    • inOrderTraverse：通过中序遍历方式遍历所有结点。
    • preOrderTraverse：通过先序遍历方式遍历所有结点。
    • postOrderTraverse：通过后序遍历方式遍历所有结点。
    • min：返回树中最小的值 / 键。
    • max：返回树中最大的值 / 键。
    • remove(key)：从树中移除某个键。

二. 二叉搜索树的实现

现在, 我们通过代码来实现二叉搜索树.

创建二叉搜索树

  • 我们像封装其他数据结构一样, 先来封装一个 BinarySearchTree 的类

    // 创建节点类
class Node {
	constructor(key) {
		this.key = key;
		this.left = null;
		this.right = null;
	}
}

  • 代码解析:

    • 封装 BinarySearchTree 的构造函数.
    • 还需要封装一个用于保存每一个结点的类 Node.
      • 该类包含三个属性: 结点对应的 key, 指向的左子树, 指向的右子树
    • 对于 BinarySearchTree 来说, 只需要保存根结点即可, 因为其他结点都可以通过根结点找到.

向树中插入数据

  • 我们两个部分来完成这个功能.

  • 外界调用的 insert 方法

    // 向树中插入数据
insert(key){
    // 1.根据key创建对应的node
   	const newNode = new Node(key);
    
    // 2.判断根结点是否有值
    if (this.root === null) {
        this.root = newNode
    } else {
        this.insertNode(this.root, newNode)
    }
}

  • 代码解析:

    • 首先, 根据传入的 key, 创建对应的 Node.
    • 其次, 向树中插入数据需要分成两种情况:
      • 第一次插入, 直接修改根结点即可.
      • 其他次插入, 需要进行相关的比较决定插入的位置.
    • 在代码中的 insertNode 方法, 我们还没有实现, 也是我们接下来要完成的任务.

  • 插入非根结点

    insertNode(root, node) {
    if (newNode.key < node.key) { // 1.准备向左子树插入数据
        if (node.left === null) { // 1.1.node的左子树上没有内容
            node.left = newNode
        } else { // 1.2.node的左子树上已经有了内容
            this.insertNode(node.left, newNode)
        }
    } else { // 2.准备向右子树插入数据
        if (node.right === null) { // 2.1.node的右子树上没有内容
            node.right = newNode
        } else { // 2.2.node的右子树上有内容
            this.insertNode(node.right, newNode)
        }
    }
}

  • 代码解析:

    • 插入其他节点时, 我们需要判断该值到底是插入到左边还是插入到右边.
    • 判断的依据来自于新节点的 key 和原来节点的 key 值的比较.
      • 如果新节点的 newKey 小于原节点的 oldKey, 那么就向左边插入.
      • 如果新节点的 newKey 大于原节点的 oldKey, 那么就向右边插入.
    • 代码的 1 序号位置, 就是准备向左子树插入数据. 但是它本身又分成两种情况
      • 情况一 (代码 1.1 位置): 左子树上原来没有内容, 那么直接插入即可.
      • 情况二 (代码 1.2 位置): 左子树上已经有了内容, 那么就一次向下继续查找新的走向, 所以使用递归调用即可.
    • 代码的 2 序号位置, 和 1 序号位置几乎逻辑是相同的, 只是是向右去查找.
      • 情况一 (代码 2.1 位置): 左右树上原来没有内容, 那么直接插入即可.
      • 情况二 (代码 2.2 位置): 右子树上已经有了内容, 那么就一次向下继续查找新的走向, 所以使用递归调用即可.

  • 测试代码: 如果按照下面的代码插入, 最后形成什么样的树呢?

    // 测试代码
let bst = new BinarySerachTree()

// 插入数据
bst.insert(11)
bst.insert(7)
bst.insert(15)
bst.insert(5)
bst.insert(3)
bst.insert(9)
bst.insert(8)
bst.insert(10)
bst.insert(13)
bst.insert(12)
bst.insert(14)
bst.insert(20)
bst.insert(18)
bst.insert(25)

  • 形成的树:

  • 如果这个时候, 我新插入一个数据 6, 那么插入的位置和顺序应该怎样的呢?

    bst.insert(6)

  • 新的树:

遍历二叉搜索树

  • 前面, 我们向树中插入了很多的数据, 为了能很多的看到测试结果. 我们先来学习一下树的遍历.
    • 注意: 这里我们学习的树的遍历, 针对所有的二叉树都是适用的, 不仅仅是二叉搜索树.
  • 树的遍历:
    • 遍历一棵树是指访问树的每个结点 (也可以对每个结点进行某些操作, 我们这里就是简单的打印)
    • 但是树和线性结构不太一样, 线性结构我们通常按照从前到后的顺序遍历, 但是树呢?
    • 应该从树的顶端还是底端开始呢? 从左开始还是从右开始呢?
    • 二叉树的遍历常见的有三种方式: 先序遍历 / 中序遍历 / 后续遍历. (还有程序遍历, 使用较少, 可以使用队列来完成)
先序遍历

  • 遍历过程为：

    • ①访问根结点；
    • ②先序遍历其左子树；
    • ③先序遍历其右子树。

  • 遍历过程:

  • 遍历的代码实现

    preorderTraversal() {
	const result = [];
	this.preorderTraversalNode(this.root, result);
	return result;
}

preorderTraversalNode(node, result) {
	if (node === null) return result;
	result.push(node.key);
	this.preorderTraversalNode(node.left, result);
	this.preorderTraversalNode(node.right, result);
}

  • 测试代码:

    // 测试前序遍历结果
let resultString = ""
bst.preOrderTraversal(function (key) {
    resultString += key + " "
})
alert(resultString) // 11 7 5 3 6 9 8 10 15 13 12 14 20 18 25

  • 代码解析:

    • 遍历树最好用的办法就是递归, 因为每个节点都可能有自己的子节点, 所以递归调用是最好的方式.
    • 在先序遍历中, 我们在经过节点的时候, 会先将该节点打印出来.
    • 然后, 我们会遍历节点的左子树, 再然后遍历节点的右子树.

  • 代码先序遍历图解:

中序遍历

  • 遍历过程为:

    • ①中序遍历其左子树；
    • ②访问根结点；
    • ③中序遍历其右子树。

  • 遍历过程:

  • 遍历的代码实现:

    // 中序遍历
inorderTraversal() {
	const result = [];
	this.inorderTraversalNode(this.root, result);
	return result;
}

inorderTraversalNode(node, result) {
	if (node === null) return result;
	this.inorderTraversalNode(node.left, result);
	result.push(node.key);
	this.inorderTraversalNode(node.right, result);
}

  • 测试代码:

    // 测试中序遍历结果
resultString = ""
bst.inOrderTraversal(function (key) {
    resultString += key + " "
})
alert(resultString) // 3 5 6 7 8 9 10 11 12 13 14 15 18 20 25

  • 代码解析:

    • 先从最左边开始, 进行中序遍历.
    • 依次向右移动, 最后遍历最右边.
    • 可以根据代码和图片解析来查看. (这里不太好描述, 但是一图胜千言, 大家多看一下图片)

  • 代码中序遍历图解:

后序遍历

  • 遍历过程为：

    • ①后序遍历其左子树；
    • ②后序遍历其右子树；
    • ③访问根结点。

  • 遍历过程:

  • 遍历的代码实现:

    // 后续遍历
postorderTraversal() {
	const result = [];
	this.postorderTraversalNode(this.root, result);
	return result;
}

postorderTraversalNode(node, result) {
	if (node === null) return result;
	this.postorderTraversalNode(node.left, result);
	this.postorderTraversalNode(node.right, result);
	result.push(node.key);
}

  • 测试代码:

    // 测试后续遍历结果
resultString = ""
bst.postOrderTraversal(function (key) {
    resultString += key + " "
})
alert(resultString) // 3 6 5 8 10 9 7 12 14 13 18 25 20 15 11

  • 后续遍历

    • 先遍历左子树上的节点, 再遍历右子树上的节点, 最后遍历根节点. (仔细查看图片和代码)

  • 代码后续遍历图解:

最大值 & 最小值

  • 在二叉搜索树中搜索最值是一件非常简单的事情, 其实用眼睛看就可以看出来了.

  • 下面, 我们通过代码来实现一下.

  • 获取最大值 & 最小值:

    // 获取最大值和最小值
min() {
	if (!this.root) return null;
	let node = this.root;
	while (node.left !== null) {
		node = node.left;
	}
	return node.key;
}

max() {
	if (!this.root) return null;
	let node = this.root;
	while (node.right !== null) {
		node = node.right;
	}
	return node.key;
}

  • 代码解析:

    • 代码也是比较简单的:
      • 代码依次向左找到最左边的结点就是最小值,
      • 代码依次向右找到最右边的结点就是最大值.
    • 也可以使用递归来实现, 不过这里就没有什么必要了, 递归反而增加代码的复杂度.

  • 代码测试:

    // 获取最值
alert(bst.min()) // 3
alert(bst.max()) // 25

搜索特定的值

  • 二叉搜索树不仅仅获取最值效率非常高, 搜索特定的值效率也非常高.

    search(key) {
	return this.searchNode(this.root, key);
}

// 通过递归实现
searchNode(node, key) {
	if (node === null) return false;
	if (key < node.key) {
		return this.searchNode(node.left, key);
	} else if (key > node.key) {
		return this.searchNode(node.right, key);
	} else {
		return true;
	}
}

  • 代码解析:

    • 这里我们还是使用了递归的方式. 待会儿我们来写一个非递归的实现.
    • 递归必须有退出条件, 我们这里是两种情况下退出.
      • node === null, 也就是后面不再有节点的时候.
      • 找到对应的 key, 也就是 node.key === key 的时候.
    • 在其他情况下, 根据 node. 的 key 和传入的 key 进行比较来决定向左还是向右查找.
      • 如果 node.key > key, 那么说明传入的值更小, 需要向左查找.
      • 如果 node.key < key, 那么说明传入的值更大, 需要向右查找.

  • 测试代码:

    // 查找特定的值
alert(bst.search(10)) // true
alert(bst.search(21)) // false

  • 非递归代码实现:

    search2(key) {
	let node = this.root;

	while (node !== null) {
		if (key < node.key) {
			node = node.left;
		} else if (key > node.key) {
			node = node.right;
		} else {
			return true;
		}
	}

	return false;
}

  • 递归 or 循环?

    • 其实递归和循环之间可以相互转换.
    • 大多数情况下, 递归调用可以简化代码, 但是也会增加空间的复杂度.
    • 循环空间复杂度较低, 但是代码会相对复杂.
    • 可以根据实际的情况自行选择, 不需要套死必须使用某种方式.

三. 二叉搜索树的删除

二叉搜索树的删除有些复杂, 为了大家更加清晰的理解其中的原理, 我单独讲解这部分内容.

删除节点的思路

  • 删除节点要从查找要删的节点开始, 找到节点后, 需要考虑三种情况:

    • 该节点是也结点 (没有字节点, 比较简单)
    • 该节点有一个子节点 (也相对简单)
    • 该节点有两个子节点.(情况比较复杂, 我们后面慢慢道来)

  • 我们先从查找要删除的节点入手

    // 删除结点
remove(key) {
	let currentNode = this.root;
	let parentNode = null;
	let isLeftChild = true;

	// 循环查找到要删除的节点 currentNode，以及他的parentNode、isLeftChild
	while (currentNode.key !== key) {
		parentNode = currentNode;

		// 小于，往左查找
		if (key < currentNode.key) {
			isLeftChild = true;
			currentNode = currentNode.left;
		} else {
			// 否则往右查找
			isLeftChild = false;
			currentNode = currentNode.right;
		}

		// 找到最后没找到相等的节点，返回 false
		if (currentNode === null) {
			return false;
		}
	}
    return true
}

  • 代码解析:

    • 在上面的代码序号 1 位置中, 我们先保存了一些临时变量.
      • current: 用于一会儿找到的要删除的节点对应的 node.
      • parent: 用于保存 current 节点的父节点. 因为如果 current 有子节点, 那么在删除 current 节点的时候, 必然需要将 parent 的 left 或者 right 指向它的某一个子节点. 所以需要保存起来 current 的 parent. (树中的节点关系不能向上的, 和链表非常相似)
      • isLeftChild: boolean 类型, 它用户记录我们是在 current 是在父节点的左侧还是右侧, 以便到时候设置 parent 的 left 或者 right
    • 在上面的代码序号 2 位置中, 开始查找对应的 key.
      • 还是之前的思路, 依次向下找到节点, 同时记录 current/parent/isLeftChild 这些变量
      • 如果遍历到 current === null, 那么说明在二叉搜索树中没有该 key, 直接返回 false 即可.
      • 如果找到, 后面就需要我们进一步考虑更加复杂的情况了.

情况一: 没有子节点

  • 情况一: 没有子节点.

    • 这种情况相对比较简单, 我们需要检测 current 的 left 以及 right 是否都为 null.
    • 都为 null 之后还要检测一个东西, 就是是否 current 就是根, 都为 null, 并且为跟根, 那么相当于要清空二叉树 (当然, 只是清空了根, 因为只有它).
    • 否则就把父节点的 left 或者 right 字段设置为 null 即可.

  • 图解过程:

    • 如果只有一个单独的根, 直接删除即可

    • 如果是叶结点, 那么处理方式如下:

  • 代码实现如下:

    // 3.删除的结点是叶结点
if (currentNode.left === null && currentNode.right === null) {
		if (currentNode === this.root) {
			this.root = null;
		} else if (isLeftChild) {
			parentNode.left = null;
		} else {
			parentNode.right = null;
		}
}

  • 代码解析:

    • 首先, 判断是否是叶结点. 通过 current 的 left&right 是否为 null
    • 上面条件成立, 再判断 current 是否是根结点: 回答是, 那么就将 this.root = null 即可.
    • 如果不是根, 再判断是左结点, 还是右结点, 以便于将 parent 的 left 或者 right 设置为 null

情况二: 一个子节点

  • 情况二: 有一个子节点

    • 这种情况也不是很难.
    • 要删除的 current 结点, 只有 2 个连接 (如果有两个子结点, 就是三个连接了), 一个连接父节点, 一个连接唯一的子节点.
    • 需要从这三者之间: 爷爷 - 自己 - 儿子, 将自己 (current) 剪短, 让爷爷直接连接儿子即可.
    • 这个过程要求改变父节点的 left 或者 right, 指向要删除节点的子节点.
    • 当然, 在这个过程中还要考虑是否 current 就是根.

  • 图解过程:

    • 如果是根的情况, 大家可以自己画一下, 比较简单, 这里不再给出.
    • 如果不是根, 并且只有一个子节点的情况.

  • 代码实现如下:

    // 4.删除有一个子节点的节点
else if (current.right === null) {
    if (currentNode === this.root) {
		this.root = currentNode.left;
	} else if (isLeftChild) {
		parentNode.left = currentNode.left;
	} else {
		parentNode.right = currentNode.left;
	}
} else if (current.left === null) {
	if (currentNode === this.root) {
		this.root = currentNode.right;
	} else if (isLeftChild) {
		parentNode.left = currentNode.right;
	} else {
		parentNode.right = currentNode.right;
	}
}

  • 代码解析:

    • 首先, 我们需要判断是 current 的 left 还是 right 为 null. 因为这样才能决定, 只有我们从 current 中取儿子的时候, 取的是 current.left 还是 current.right 来给别的地方赋值.
    • 三种情况:
      • current 是根节点, 那么直接将 this.root = son.
      • current 不是根节点, 是父节点的 left 节点, 那么 parent.left = son.
      • current 不是根节点, 是父节点的 right 节点, 那么 parent.right = son.
    • 分析清楚的话, 还比较简单.

情况三: 两个子节点

  • 情况三: 有两个子节点.

    • 事情变得非常复杂, 也非常有趣了.

  • 我们先来思考一下我提出的一些问题:

  • 先来, 我们来总结一下删除有两个节点的规律:

    • 如果我们要删除的节点有两个子节点, 甚至子节点还有子节点, 这种情况下我们需要从下面的子节点中找到一个节点, 来替换当前的节点.
    • 但是找到的这个节点有什么特征呢? 应该是 current 节点下面所有节点中最接近 current 节点的.
      • 要么比 current 节点小一点点, 要么比 current 节点大一点点.
      • 总结你最接近 current, 你就可以用来替换 current 的位置.
    • 这个节点怎么找呢?
      • 比 current 小一点点的节点, 一定是 current 左子树的最大值.
      • 比 current 大一点点的节点, 一定是 current 右子树的最小值.
    • 前驱 & 后继
      • 而在二叉搜索树中, 这两个特别的节点, 有两个特比的名字.
      • 比 current 小一点点的节点, 称为 current 节点的前驱.
      • 比 current 大一点点的节点, 称为 current 节点的后继.
    • 也就是为了能够删除有两个子节点的 current, 要么找到它的前驱, 要么找到它的后继.
    • 所以, 接下来, 我们先找到这样的节点 (前驱或者后继都可以, 我这里以找后继为例)

  • 寻找后继的代码实现:

    // 找后继的方法
getSuccessor(delNode) {
	// 定义变量，保存要找到的后续
	let successor = delNode;
	let current = delNode.right;
	let successorParent = delNode;

	// 循环查找 current 的右子树结点
	while (current !== null) {
		successorParent = successor;
		successor = current;
		current = current.left;
	}

	// 判断寻找到的后续节点是否直接就是要删除节点的 right
	if (successor !== delNode.right) {
		successorParent.left = successor.right;
		successor.right = delNode.right;
	}
	return successor;
}

  • 代码解析:

    • 代码是根据传入的 delNode 来寻找后继节点.
    • 本身代码比较简单, 但是后面有一个序号 3 的代码, 相对较难理解.
    • 我们这里先不做讨论, 先把找到后继后进行的操作写完, 再后头理解这段代码.
    • 序号 3: TODO

  • 找到后继后的处理代码:

    // 5.删除有两个节点的节点
else {
    // 1.找到后续节点
	let successor = this.getSuccessor(currentNode);

	// 2.判断是否为根结点
	if (currentNode === this.root) {
		this.root = successor;
	} else if (isLeftChild) {
		parentNode.left = successor;
	} else {
		parentNode.right = successor;
	}

	// 3.将后续的左节点改为被删除的左节点
	successor.left = currentNode.left;
}

  • 代码解析:

    • 序号 1: 调用刚才封装的方法, 获取后继节点.
    • 序号 2: 判断三种情况:
      • 情况一: 是根节点, 那么 this.root = successor. 并且 successor 的 left 应该等于 current 的 left
      • 情况二: 是父节点的左结点, parent.left = successor, 并且 successor 的 left 应该等于 current 的 left
      • 情况三: 是父节点的右结点, parent.right = successor, 并且 successor 的 left 应该等于 current 的 left
    • 需要 3: 就是将 successor.left = current.left 从判断中抽取出来.

  • 回头头看 TODO 的情况

    • 上面的代码实现, 对于删除 9 是适用的. 做法就是将 7 节点的 left 赋值为 10. 10 节点的 left 应该赋值为 8 即可.
    • 但是, 对于删除 15 我们还缺少什么呢?
      • 已经完成: 11 的 left 指向了 18, 18 的 right 指向了 13.
      • 没有完成: 19 怎么办? 20 这个左子树怎么办?
      • 很明显, 19 应该放在 20 的左边, 20 应该放在 18 的右边.
      • 19 放在 20 的左边代码: successorParent.left = successor.right
      • 20 放在 18 的右边代码: successor.right = delNode.right
    • 搞定, 收工!!!

删除节点完整代码

  • 最后, 还是给出完整代码

    	remove(key) {
		let currentNode = this.root;
		let parentNode = null;
		let isLeftChild = true;

		// 循环查找到要删除的节点 currentNode，以及他的 parentNode、isLeftChild
		while (currentNode.key !== key) {
			parentNode = currentNode;

			// 小于，往左查找
			if (key < currentNode.key) {
				isLeftChild = true;
				currentNode = currentNode.left;
			} else {
				// 否则往右查找
				isLeftChild = false;
				currentNode = currentNode.right;
			}

			// 找到最后没找到相等的节点，返回 false
			if (currentNode === null) {
				return false;
			}
		}

		// 1.删除的是叶子结点的情况
		if (currentNode.left === null && currentNode.right === null) {
			if (currentNode === this.root) {
				this.root = null;
			} else if (isLeftChild) {
				parentNode.left = null;
			} else {
				parentNode.right = null;
			}

			// 2.删除的是只是一个子节点的节点
		} else if (currentNode.right === null) {
			// currentNode 只存在左节点
			// 2.1、currentNode 只存在<左节点>的情况
			// 2.1.1、currentNode 等于root
			// 2.1.2、parentNode.left等于currentNode
			// 2.1.3、parentNode.right等于currentNode

			if (currentNode === this.root) {
				this.root = currentNode.left;
			} else if (isLeftChild) {
				parentNode.left = currentNode.left;
			} else {
				parentNode.right = currentNode.left;
			}
		} else if (currentNode.left === null) {
			// 2.2、currentNode 只存在<右节点>的情况
			// 2.1.1、currentNode 等于root
			// 2.1.2、parentNode.left 等于 currentNode
			// 2.1.1、parentNode.rigth 等于 currentNode

			if (currentNode === this.root) {
				this.root = currentNode.right;
			} else if (isLeftChild) {
				parentNode.left = currentNode.right;
			} else {
				parentNode.right = currentNode.right;
			}

			// 3.删除的是有两个子节点的节点
		} else {
			// 1.找到后续节点
			let successor = this.getSuccessor(currentNode);

			// 2.判断是否为根结点
			if (currentNode === this.root) {
				this.root = successor;
			} else if (isLeftChild) {
				parentNode.left = successor;
			} else {
				parentNode.right = successor;
			}

			// 3.将后续的左节点改为被删除的左节点
			successor.left = currentNode.left;
		}
	}

删除节点的回顾

  • 看到这里, 你就会发现删除节点相当棘手.
  • 实际上, 因为它非常复杂, 一些程序员都尝试着避开删除操作.
    • 他们的做法是在 Node 类中添加一个 boolean 的字段, 比如名称为 isDeleted.
    • 要删除一个节点时, 就将此字段设置为 true.
    • 其他操作, 比如 find() 在查找之前先判断这个节点是不是标记为删除.
    • 这样相对比较简单, 每次删除节点不会改变原有的树结构.
    • 但是在二叉树的存储中, 还保留着那些本该已经被删除掉的节点.
  • 上面的做法看起来很聪明, 其实是一种逃避.
    • 这样会造成很大空间的浪费, 特别是针对数据量较大的情况.
    • 而且, 作为程序员要学会通过这些复杂的操作, 锻炼自己的逻辑, 而不是避重就轻.

四. 二叉搜索树完整代码

  • 最后, 我们还是给出二叉搜索树的完整代码

    // 创建节点类
class Node {
	constructor(key) {
		this.key = key;
		this.left = null;
		this.right = null;
	}
}

// 封装二叉搜索树（特点：左子树节点值 < ）
export class BinarySearchTree {
	constructor() {
		this.root = null;
	}

	/*******
	 * @description: 插入数据
	 * @param {*} key
	 * @return {*}
	 */
	insert(key) {
		const newNode = new Node(key);

		if (this.root === null) {
			this.root = newNode;
		} else {
			this.insertNode(this.root, newNode);
		}
	}

	insertNode(root, node) {
		if (node.key < root.key) {
			// 往左边查找插入
			if (root.left === null) {
				root.left = node;
			} else {
				this.insertNode(root.left, node);
			}
		} else {
			// 往右边查找插入
			if (root.right === null) {
				root.right = node;
			} else {
				this.insertNode(root.right, node);
			}
		}
	}

	// ----------- 二叉树遍历 ----------//
	/*******
	 * @description: 先序遍历（根左右DLR）
	 * @param {*}
	 * @return {*} result
	 */
	preorderTraversal() {
		const result = [];
		this.preorderTraversalNode(this.root, result);
		return result;
	}

	preorderTraversalNode(node, result) {
		if (node === null) return result;
		result.push(node.key);
		this.preorderTraversalNode(node.left, result);
		this.preorderTraversalNode(node.right, result);
	}

	/*******
	 * @description: 中序遍历（左根右LDR）
	 * @param {*}
	 * @return {*} result
	 */
	inorderTraversal() {
		const result = [];
		this.inorderTraversalNode(this.root, result);
		return result;
	}

	inorderTraversalNode(node, result) {
		if (node === null) return result;
		this.inorderTraversalNode(node.left, result);
		result.push(node.key);
		this.inorderTraversalNode(node.right, result);
	}

	/*******
	 * @description: 后序遍历（左右根 LRD）
	 * @param {*}
	 * @return {*} restult
	 */
	postorderTraversal() {
		const result = [];
		this.postorderTraversalNode(this.root, result);
		return result;
	}

	postorderTraversalNode(node, result) {
		if (node === null) return result;
		this.postorderTraversalNode(node.left, result);
		this.postorderTraversalNode(node.right, result);
		result.push(node.key);
	}

	/*******
	 * @description: 获取二叉搜索树最小值
	 * @param {*}
	 * @return {*} node.key
	 */
	min() {
		if (!this.root) return null;
		let node = this.root;
		while (node.left !== null) {
			node = node.left;
		}
		return node.key;
	}

	/*******
	 * @description:获取二叉搜索树最大值
	 * @param {*}
	 * @return {*} node.key
	 */
	max() {
		if (!this.root) return null;
		let node = this.root;
		while (node.right !== null) {
			node = node.right;
		}
		return node.key;
	}

	/*******
	 * @description: 查找二叉搜索树中是否有相同的key
	 * @param {*} key
	 * @return {*}
	 */
	search(key) {
		return this.searchNode(this.root, key);
	}

	// 通过递归实现
	searchNode(node, key) {
		if (node === null) return false;
		if (key < node.key) {
			return this.searchNode(node.left, key);
		} else if (key > node.key) {
			return this.searchNode(node.right, key);
		} else {
			return true;
		}
	}

	/*******
	 * @description: 通过 while 循环实现
	 * @param {*} key
	 * @return {*}
	 */

	/*******
	 * @description: 删除节点
	 * @param {*} key
	 * @return {*}
	 */
	remove(key) {
		let currentNode = this.root;
		let parentNode = null;
		let isLeftChild = true;

		// 循环查找到要删除的节点 currentNode，以及他的 parentNode、isLeftChild
		while (currentNode.key !== key) {
			parentNode = currentNode;

			// 小于，往左查找
			if (key < currentNode.key) {
				isLeftChild = true;
				currentNode = currentNode.left;
			} else {
				// 否则往右查找
				isLeftChild = false;
				currentNode = currentNode.right;
			}

			// 找到最后没找到相等的节点，返回 false
			if (currentNode === null) {
				return false;
			}
		}

		// 1.删除的是叶子结点的情况
		if (currentNode.left === null && currentNode.right === null) {
			if (currentNode === this.root) {
				this.root = null;
			} else if (isLeftChild) {
				parentNode.left = null;
			} else {
				parentNode.right = null;
			}

			// 2.删除的是只是一个子节点的节点
		} else if (currentNode.right === null) {
			// currentNode 只存在左节点
			// 2.1、currentNode 只存在<左节点>的情况
			// 2.1.1、currentNode 等于root
			// 2.1.2、parentNode.left等于currentNode
			// 2.1.3、parentNode.right等于currentNode

			if (currentNode === this.root) {
				this.root = currentNode.left;
			} else if (isLeftChild) {
				parentNode.left = currentNode.left;
			} else {
				parentNode.right = currentNode.left;
			}
		} else if (currentNode.left === null) {
			// 2.2、currentNode 只存在<右节点>的情况
			// 2.1.1、currentNode 等于root
			// 2.1.2、parentNode.left 等于 currentNode
			// 2.1.1、parentNode.rigth 等于 currentNode

			if (currentNode === this.root) {
				this.root = currentNode.right;
			} else if (isLeftChild) {
				parentNode.left = currentNode.right;
			} else {
				parentNode.right = currentNode.right;
			}

			// 3.删除的是有两个子节点的节点
		} else {
			// 1.找到后续节点
			let successor = this.getSuccessor(currentNode);

			// 2.判断是否为根结点
			if (currentNode === this.root) {
				this.root = successor;
			} else if (isLeftChild) {
				parentNode.left = successor;
			} else {
				parentNode.right = successor;
			}

			// 3.将后续的左节点改为被删除的左节点
			successor.left = currentNode.left;
		}
	}

	/*******
	 * @description: 获取后续节点，即从要删除的节点的右边开始查找最小值
	 * @param {*} delNode
	 * @return {*}
	 */
	getSuccessor(delNode) {
		// 定义变量，保存要找到的后续
		let successor = delNode;
		let current = delNode.right;
		let successorParent = delNode;

		// 循环查找 current 的右子树结点
		while (current !== null) {
			successorParent = successor;
			successor = current;
			current = current.left;
		}

		// 判断寻找到的后续节点是否直接就是要删除节点的 right
		if (successor !== delNode.right) {
			successorParent.left = successor.right;
			successor.right = delNode.right;
		}
		return successor;
	}
}
yige001
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
二叉搜索树的特点
weixin_52370850的博客
01-19 510
题目链接：https://leetcode-cn.com/problems/range-sum-of-bst/ 三个层次： 1.本质是查找所有符合条件的元素，朴素思想是 检查每个元素，本题目中利用规律不断对搜索空间剪枝 2.二叉搜索树的中序遍历是一个有序数组，假设根节点的值为val，则所有比val大的点在右边，比val小的点在左边。 3.是否有java代码可以借鉴？无 ...
数据结构与算法经典80
abcd1f2的专栏
02-16 607
由于这些题，实在太火了。所以，应广大网友建议要求，在此把之前已整理公布的前80题， 现在，一次性分享出来。此也算是前80题第一次集体亮相。 此些题，已有上万人，看到或见识到，若私自据为己有，必定为有知之人识破，付出代价。 所以，作者声明： 本人July对以上所有任何内容和资料享有版权，转载请注明作者本人July出处。 向你的厚道致敬。谢谢。 把二元查找树转变成排序的双向链表
二叉搜索树（BST）详细解释及常见应用
最新发布
fucheng的博客
04-23 351
二叉搜索树（BST）详细解释及常见应用
04-树6 Complete Binary Search Tree 完全二叉搜索树
Roland_WuZF的博客
10-24 4673
这道题大意是这样，输入N个不同的非负整数，需要将其按照二叉搜索树的规则，排成一个完全二叉树。二叉搜索树是指每个每个节点的所有左元素都比它小，右边都比它大；完全二叉树指的是，除了最后一层，其余每一层都满，最后一层从左往右排。 之后层序遍历，输出。 一开始想法是，构造，然后输出。并不能码出来（水平不够） 之后去查了别人的算法，又被别人的机智惊艳到了！   基本想法是这样，完全二叉树有这
练习题 No.16 二叉搜索树
一名小学生的辛酸奋斗史
05-11 349
要求自己写一个二叉搜索树。限制条件无输入格式无输出格式无测试输入无测试输出无解题思路删除操作 需要 删除的节点没有左二子的话，那么就把右儿子提上去 需要 删除的节点的左二子没有右儿子，那么就把左二子提上去 以上二种情况都不满足的话，就把左二子的子孙中最大的结点提到需要删除的节点上 代码#include <iostream>using namespace std; template<class
算法 二叉树 BST树
XXXTENTAC1ON的博客
05-07 2212
二叉排序树BST树的定义BST树结构BST树的创建递归中序遍历非递归中序遍历逆向非递归中序遍历删除结点 BST树的定义 BST树又称为：二叉排序树，二叉搜索树 二叉搜索树或者是一颗空树，或者是具有下列性质的二叉树 每个结点都有一个作为搜索依据的关键码(key)，所有结点的关键码互不相同 左子树（如果存在）上所有结点的关键码都小于根节点的关键码 右子树（如果存在）上所有结点的关键码都大于根节点的关键码 左子树和右子树也是二叉搜索树 总结：如果对一颗二叉搜索树进行中序遍历，可以按从小到大的顺序，将各结
javascript数据结构之二叉搜索树实现方法
11-24
二叉搜索树是一种特殊的数据结构，它在计算机科学中用于高效地存储和检索有序数据。在JavaScript中，我们可以创建一个二叉搜索树类来实现这些功能。以下是对标题和描述中提到的知识点的详细说明： 1. **二叉搜索树...
javascript算法之二叉搜索树的示例代码
01-19
二叉搜索树由于其独特的数据结构，使得其无论在增删，还是查找，时间复杂度都是O(h)，h为二叉树的高度。因此二叉树应该尽量的矮，即左右节点尽量平衡。 二叉搜索树的构造 要构造二叉搜索树，首先要构造二叉树的节点...
C#二叉搜索树插入算法实例分析
09-03
二叉搜索树（Binary Search Tree，BST）是一种特殊的二叉树结构，它的每个节点都包含一个键（key）、一个关联的值、一个指向左子树的引用和一个指向右子树的引用。在二叉搜索树中，对于任意节点，其左子树中的所有...
二叉搜索树的实现与应用
11-04
本资源是博文【数据结构】二叉搜索树的完整源代码文件，包含K模型搜索树的递归、非递归实现；KV模型搜索树的递归和非递归实现。以及两种模型的测试和应用，主要体现在单词翻译、统计次数、检查单词拼写。可结合以下...
算法设计与分析-最优二叉搜索树PPT
11-05
二叉搜索树是一种满足特定条件的数据结构，每个节点的左子树上的所有节点的值都小于该节点的值，而右子树上的所有节点的值都大于该节点的值。这样的结构确保了搜索操作的高效性。 在最优二叉搜索树的概念中，我们有...
二叉搜索树的基本特征和模拟实现
yam_sunshine的博客
04-24 799
一、二叉搜索树的定义 二叉搜索树又称二叉排序树，它或者是一颗空树，或者是一棵排序树，它具有如下性质： 1、若它的左子树不为空，则它的左子树的所有节点的值都小于根节点的值 2、若它的右子树不为空，则它的右子树的所有节点的值都大于根节点的值 3、它的左右子树也都是二叉搜索树 二、二叉树的主要操作分析 1、二叉树的插入 a.若二叉树为空，则直接插入，然后返回true b.若二叉树不为空，按照二叉搜索树的...
二叉搜索树面试题总结
HanSion.Z
08-23 1838
0.什么是二叉搜索树 二叉搜索树就是左子树所有结点都小于根结点，右子树所有结点都打于根节点。当然这个定义递归的，它的左右子树也满足这个特点 例如： 0.定义结构 typedef int BSTDataType; //定义二叉搜索树结点类型 typedef struct BSTreeNode { BSTDataType _data; struct ...
《算法导论笔记》——十分钟带你了解二叉搜索树（BST）！
lost-person的博客
07-27 3万+
搜索树数据结构支持许多动态集合操作，包括SEARCH（查找指定结点）、MINIMUM（最小关键字结点）、MAXMUM（最大关键字结点）、PREDECESSOR（结点的先驱）、SUCCESSOR（结点的后继）、INSERT（结点的插入）和DELETE（结点的删除）等。因此，我们使用一棵搜索树既可以作为一个字典又可以作为一个优先队列。 二叉搜索树上的基本操作所花费的时间与这棵树的高度成正比。对于...
（一）BST树（二叉搜索树）
qq_42119136的博客
06-29 4972
（一）BST树（二叉搜索树） 1.BST二叉搜索树 1.1BST树的定义 1 BST树也是一个二叉树，故满足递归定义; 2 其次每个节点只存在一个值; 3 需满足左子树值<=根值<=右子树，故按照中序遍历会得到一个非递减序列。 BST涉及操作主要增，删，查，除了删麻烦一点，其他操作均可递归实现，二叉查找树的一般性质： 1.在一棵二叉查找树上，执行查找、插入、删除等操作，的时间复杂度为O（log2n）。因为，一棵由n个结点，随机构造的二叉查找树的高度为log2n，所以顺理成章，一般操作的执行时间为
二叉搜索树(二叉排序树)
热门推荐
爱敲代码的三毛的博客
09-09 4万+
一.概念 二叉搜索树又称二叉排序树，具有以下性质： 若它的左子树不为空，则左子树上所有节点的值都小于根节点的值 若它的右子树不为空，则右子树上所有节点的值都大于根节点的值 它的左右子树也分别为二叉搜索树 注意：二叉搜索树中序遍历的结果是有序的 二、基本操作 1.查找元素 思路：二叉搜索树的左子树永远是比根节点小的，而它的右子树则都是比根节点大的值。当前节点比要找的大就往左走，当前元素比要找的小就往右走 public Node search(int key) { if(root ==
数据结构-二叉排序树（BST树）
理科男同学
11-15 9488
1，二叉排序树介绍 二叉排序树（Binary Sort Tree）或者是一颗空树；或者是具有如下性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 它的左、右子树又分别为二叉排序树。 显然二叉排序树的定义是一个递归形式的定义，所以后面景禹要讲的插入、查找和删除都是基于递归的形式。特别说明：如果有相同的值，可以将该节点放在左子节点或右子节点 1.1，二叉排序树的构建 假设我们有初始的无序...
数据结构-二叉搜索树 详解
HeartFireY的博客
06-06 2328
一、二叉搜索树 简介 二叉搜索树(BST, Binary Search Tree)是一种基于二叉树的树形数据结构，定义(满足的性质)如下 空树是二叉搜索树 若二叉搜索树的左子树不为空，则其左子树上所有点的权值均小于其根节点的权值； 若二叉搜索树的右子树不为空，则其右子树上所有点的权值均大于其根节点的权值； 二叉搜索树的左右子树均为二叉搜索树 不难发现，二叉搜索树是采用递归进行定
BST -- 二叉搜索树（Binary Search Tree）
Daria_的博客
07-10 531
文章目录一、BST树是具有下列性质的二叉树二、定义BST树三、BST的相关操作1.BST树的插入非递归插入递归插入2.BST树的删除非递归删除递归删除3.查询BST树中是否存在值为data的结点非递归方式查找递归方式查找4.返回BST树中所有结点的个数（递归方式）5.计算BST树的高度（递归方式）6.BST树的遍历前序遍历（VLR）中序遍历（LVR）后序遍历（RVL）层序遍历 一、BST树是具有下...
高级数据结构：AVL树与平衡二叉搜索树解析
"刘汝佳讲解的高级数据结构课程，主要涵盖了ACM竞赛中常见的高级数据结构，包括平衡二叉树、可并优先队列、线段树和树状数组的基础知识，以及RMQ（Range Minimum Query）和LCA（Lowest Common Ancestor）的应用。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

yige001

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值