python数据结构二叉树的查找算法_学习数据结构与算法之二叉搜索树

二叉搜索树简介

二叉树是一种非线性数据结构，其中的每个元素我们称为节点，二叉树中每个节点最多只能有两个子节点；没有父节点的节点称为根节点，没有子节点的节点称为叶节点。二叉搜索树是二叉树的一种，其特征是左侧子节点存储比父节点小的值，右侧子节点存储比父节点大(或等于父节点)的值。下图就是一颗典型的二叉搜索树:

二叉搜索树的实现

二叉搜索树的节点，我们用类似双向链表的方式存储节点(都包含两个对其他节点的引用)，但是这里两个引用指向的分别是左右两个子节点。

function BinarySearchTree () {

// 二叉树的键

var Node = function (key) {

// 键值

this.key = key

// 左节点

this.left = null

// 右节点

this.right = null

}

// 根节点

var root = null

}

二叉搜索树需要实现以下方法：

insert(key)：向树中插入一个新的键

search(key)：在树中查找一个键，如果节点存在返回tue，否则返回false

inOrderTraverse：通过中序遍历方式遍历所有节点

preOrderTraverse：通过先序遍历方式遍历节点

postOrderTraverse：通过后序遍历方式遍历所有节点

min：返回树中最小的值

max：返回树中最大的值

remove(key)：从树中移除某个键

注意：本文中很多地方使用了递归的方法，如果不了解递归，可以先看看这个知乎问题-递归

实现insert

// 用于插入节点

var insertNode = function (node, newNode) {

// 在二叉搜索树中，比父节点小的值存在左侧节点，大于等于父节点的存在右侧节点

// 若要插入一个节点(根节点已存在)，首先与根节点比大小，若比根节点小则应插入根节点的左侧

// 如果左侧已存在节点，则递归调用函数，将左侧节点传入递归函数作为当前节点

// 如果插入的节点比当前节点大且当前节点右侧为空，则插入右侧

// 如果插入节点比根节点大，原理同上

if (newNode.key < node.key) {

if (node.left === null) {

node.left = newNode

} else {

insertNode(node.left, newNode)

}

} else {

if (node.right === null) {

node.right = newNode

} else {

insertNode(node.right, newNode)

}

}

}

// 插入

this.insert = function (key) {

var node = new Node(key)

if (root === null) {

root = node

} else {

insertNode(root, node)

}

}

实现search

这里同样借助一个辅助函数使用，辅助函数同样是用了递归，简单比较输入的key与当前节点的key，当相等时(意味着找到了目标节点)就返回true；当查找完最末端的节点时，即传入的node为null时，就返回false，表示未找到。

有人可能会怀疑，这样真的找到吗？实际上，由于二叉搜索树子节点“左小右大”的性质，一个特定的值在二叉搜索树中的大致位置是可预见的(即使是插入那个值也不会跑出那个范围)。所以仅仅通过简单的比较key就能在某个范围中找到目标节点，而且这种方法不用遍历整棵树去找，非常节省性能。

var searchNode = function (node, key) {

if (node === null) {

false

}

if (key < node.key) {

return searchNode(node.left, key)

} else if (key > node.key) {

return searchNode(node.right, key)

} else {

return true

}

}

// 查找节点

this.search = function (key) {

return searchNode(root, key)

}

实现中序遍历

接下来就是三个遍历方法，先从中序遍历开始，其作用是按顺序(从小到大)访问整棵树的所有节点，也就是常见的升序排序。

其实这三种遍历并没有那么复杂，简单地观察一下回调函数(也就是访问key)的位置，就能看出来是哪种排序。

var inOrderTraverseNode = function (node, callback) {

if (node !== null) { // 停止递归的条件

inOrderTraverseNode(node.left, callback)

callback(node.key)

inOrderTraverseNode(node.right, callback)

}

}

// 中序遍历

this.inOrderTraverse = function (callback) {

inOrderTraverseNode(root, callback)

}

实现先序遍历

var preOrderTraverseNode = function (node, callback) {

if (node !== null) {

callback(node.key)

preOrderTraverseNode(node.left, callback)

preOrderTraverseNode(node.right, callback)

}

}

// 先序遍历

this.preOrderTraverse = function (callback) {

preOrderTraverseNode(root, callback)

}

实现后序遍历

var postOrderTraverseNode = function (node, callback) {

if (node !== null) {

postOrderTraverseNode(node.left, callback)

postOrderTraverseNode(node.right, callback)

callback(node.key)

}

}

// 后序遍历

this.postOrderTraverse = function (callback) {

postOrderTraverseNode(root, callback)

}

这里先停一下：的确看回调函数就能知道这是哪种遍历，但是这些函数递归理解起来确实有点困难，这里我建议在重复的大问题面前先拆成小问题来看：

请看这个最简单的二叉树

如果现在先序遍历这个二叉树，它的顺序应该是M -> H -> Z；中序遍历的顺序是H -> M -> Z；后序遍历是：H -> Z -> M

那么再看下面这棵大树的中序遍历就会好理解了：先从根节点左侧子树开始遍历，左侧子树里面又有小左侧子树，里面最小的由3，5，6组成的子树就和上面最简单的二叉树一样了。这时遍历从3开始，以正常的中序遍历顺序3 -> 5 -> 6。当遍历完6之后我们可以将这个小的子树看成一个整体，这个整体和上面的父节点7以及右边的子树也组成了一个简单的二叉树结构，然后正常遍历7 -> 右侧子树，右侧子树中依旧按照中序遍历的顺序：8 -> 9 -> 10，按此顺序不断遍历完所有的节点。

实现min和max

这个两个方法其实挺简单的，最小的节点就在二叉搜索树的最左；反之，最大的就在最右。

var minNode = function(node) {

// 如果node存在，则开始搜索。能避免树的根节点为Null的情况

if (node) {

// 只要树的左侧子节点不为null，则把左子节点赋值给当前节点。

// 若左子节点为null，则该节点肯定为最小值。

while (node && node.left !== null) {

node = node.left

}

return node.key

}

return null

}

var maxNode = function(node) {

if (node) {

while (node && node.right !== null) {

node = node.right

}

return node.key

}

return null

}

// 找到最小节点

this.min = function () {

return minNode(root)

}

// 找到最大节点

this.max = function () {

return maxNode(root)

}

实现remove

好了，现在剩下最后一个方法了，先深吸一口气。。。

接下来实现的方法号称全书最复杂的方法，鉴于本人目前水平有限，我只能将自己看懂的思路写出来，如果讲得不好大家可以去看原书《学习JavaScript数据结构与算法》。

下面进入正题：

移除二叉搜索树中的一个节点需要考虑三种情况：

删除的是叶节点(没有子节点的节点)

删除的节点有一侧子节点

删除的节点有两侧子节点

还是老原则，化繁为简。

先看第一个比较简单的：既然它没有子节点，那就先找到它，再直接将它与父节点的联系切断就行了；

第二个就稍微复杂一点：你得先把它删掉，然后把它的子节点接到它的父节点上去；

第三个最复杂：你不能直接删掉它，你应该在它的右侧子树里面找到最小的那个节点把它替换掉，然后为防止重复，把替换它的节点删掉就万事大吉了。

这里前两种情况都还能理解，所以我只解释为什么是右侧子树的最小节点。

其实这是为了防止顺序乱掉而做的处理，举个例子：

还是之前的那张图，我要删掉15这个节点，那么这时无论是把20还是13接到根节点11下面都会导致二叉搜索树“左小右大”的结构大乱(就像曹操如果没有接班人就死了北方就会大乱)，因此最好的办法是找一个比他大一点的节点来替换它(找一个强一点的接班人坐他的位子维持秩序)。

这里为啥是大一点而不是大很多？因为大太多也会导致结构混乱(过于强势成为暴君就不给底下人活路了)。所以就选了一个大一点的节点替换到这个位置上来，同时为防止重复就删掉了原来的节点(接班人不能身兼两职所以要辞掉原来的职位)。

说到这里我就直接贴代码了，反正现在让我写，一时半会是写不出来的，因此仅供观摩：

// 这个辅助函数和minNode函数是一样的，只不过返回值不一样

var findMinNode = function (node) {

if (node === null) {

while (node && node.left !== null) {

node = node.left

}

return node

}

return null

}

var removeNode = function (node, key) {

if (node === null) {

return null

}

if (key < node.key) {

node.left = removeNode(node.left, key)

return node

} else if (key > node.key) {

node.right = removeNode(node.right, key)

return node

} else {

// 第一种情况：删除叶节点

if (node.left === null && node.right === null) {

node = null

return node

}

// 第二种情况：删除一侧有子节点的节点

// 将一侧的子节点替换为当前节点

if (node.left === null) {

node = node.right

return node

} else if (node.right === null) {

node = node.left

return node

}

// 第三种情况：删除两侧都有子节点的节点

// 找到当前节点右侧子树中最小的那个节点，替换掉要删除的节点

// 然后再把右侧子树中最小的节点移除

var aux = findMinNode(node.right)

node.key = aux.key

node.right = removeNode(node.right, aux.key)

return node

}

}

// 删除节点

this.remove = function (key) {

root = removeNode(root, key)

}

源代码在此：

小结

实现二叉搜索树花了好长时间，后面的图也是挺麻烦的数据结构，但是这段时间不停地学习数据结构也是让自己得到了很大成长。继续加油～