二叉查找树
二叉查找树（BST）：一种特殊的二叉树，相对较小的值保存在左节点中，较大的值保存在右节点中。
实现：
class Node {
constructor(data) {
// Node既保存数据也保存和其他节点的链接
this.data = data
this.left = null
this.right = null
}
toString() {
return this.data.toString()
}
}
class BST {
constructor() {
this.root = null
}
// 向树中加入新节点
insert(...datalist) {
for (let data of datalist) {
const node = new Node(data)
if (this.root === null) {
this.root = node
} else {
let current = this.root
let parent
while(true) {
parent = current
if (data < current.data) {
current = current.left
if (current === null) {
parent.left = node
break
}
} else {
current = current.right
if (current === null) {
parent.right = node
break
}
}
}
}
}
}
// 前序遍历：根节点 -> 左子树 -> 右子树
preOrder() {
const order = node => {
if (node !== null) {
console.log(`${node.data} `)
order(node.left)
order(node.right)
}
}
order(this.root)
}
// 中序遍历：左子树 -> 根节点 -> 右子树
inOrder() {
const order = node => {
if (node !== null) {
order(node.left)
console.log(`${node.data} `)
order(node.right)
}
}
order(this.root)
}
// 后序遍历：左子树 -> 右子树 -> 根节点
postOrder() {
const order = node => {
if (node !== null) {
order(node.left)
order(node.right)
console.log(`${node.data} `)
}
}
order(this.root)
}
// 找到最小值
findMin() {
let current = this.root
while(current.left !== null) {
current = current.left
}
return current.data
}
// 找到最大值
findMax() {
let current = this.root
while(current.right !== null) {
current = current.right
}
return current.data
}
// 找到指定值
find(data) {
let current = this.root
while(current !== null) {
if (data === current.data) {
return current
} else if (data < current.data) {
current = current.left
} else if (data > current.data) {
current = current.right
}
}
}
// 找到指定值
find(data) {
let current = this.root
while(current !== null) {
if (data === current.data) {
return current
} else if (data < current.data) {
current = current.left
} else if (data > current.data) {
current = current.right
}
}
return null
}
// 删除指定值
remove(data) {
const findMin = node => {
let current = node
while(current.left !== null) {
current = current.left
}
return current
}
const removeNode = (node, data) => {
if (node === null) {
return null
}
if (data === node.data) {
// 没有子节点的节点
if (node.left === null &&
node.right === null) {
return null
}
// 没有左子节点的节点
if (node.left === null) {
return node.right
}
// 没有右子节点的节点
if (node.right === null) {
return node.left
}
// 有两个子节点的节点
// 找到右子树上的最小值，并用该值创建一个临时节点
const tempNode = findMin(node.right)
// 将临时节点上的值复制到待删除节点
node.data = tempNode.data
// 然后再删除临时节点
node.right = removeNode(node.right, tempNode.data)
return node
} else if (data < node.data) {
// 移至当前节点的左子节点进行比较
node.left = removeNode(node.left, data)
return node
} else {
// 移至当前节点的右子节点进行比较
node.right = removeNode(node.right, data)
return node
}
}
this.root = removeNode(this.root, data)
}
// 返回BST中节点的个数
count() {
let arr = []
const order = node => {
if (node !== null) {
order(node.left, arr)
order(node.right, arr)
arr.push(node.data)
}
}
order(this.root)
return arr.length
}
// 返回BST中边的个数
edgesCount() {
let count = 0
const edgesCount = node => {
if (node.left !== null && node.right !== null) {
count++
edgesCount(node.left)
count++
edgesCount(node.right)
} else if (node.left !== null) {
count++
edgesCount(node.left)
} else if (node.right !== null) {
count++
edgesCount(node.right)
}
}
edgesCount(this.root)
return count
}
}
// test
const bst = new BST()
bst.insert(23,16,99,30,18,3,120,45)
console.log(bst.count()) // 8
bst.preOrder() // 23 16 3 18 99 30 45 120
bst.inOrder() // 3 16 18 23 30 45 99 120
bst.postOrder() // 3 18 16 45 30 120 99 23
bst.remove(99)
console.log(bst.count()) // 7
console.log(bst.findMin()) // 3
console.log(bst.findMax()) // 120
console.log(bst.find(30)) // Node {data: 30, left: null, right: Node}
console.log(bst.edgesCount()) // 6