Tree(树)数据结构是多层结构。与Array，Stack和Queue相比，它也是一种非线性数据结构。这种结构在插入和搜索操作时效率很高。我们来看看树型数据结构的一些概念。
无序树：树中任意节点的子结点之间没有顺序关系，这种树称为无序树,也称为自由树；
有序树：树中任意节点的子结点之间有顺序关系，这种树称为有序树；
二叉树：每个节点最多含有两个子树的树称为二叉树；
满二叉树：叶节点除外的所有节点均含有两个子树的树被称为满二叉树；
完全二叉树：除最后一层外，所有层都是满节点，且最后一层缺右边连续节点的二叉树称为完全二叉树；
哈夫曼树（最优二叉树）：带权路径最短的二叉树称为哈夫曼树或最优二叉树。
二叉树
1、空二叉树——如图1（a） [3] ；
2、只有一个根节点的二叉树——如图1（b） [3] ；
3、只有左子树——如图1（c） [3] ；
4、只有右子树——如图1（d） [3] ；
5、完全二叉树——如图1（e） [3] 。
root：树的根节点，无父节点
parent node：上层的直接节点，只有一个
child node：下层的直接节点可以有多个
siblings：共享同一个父节点
leaf：没有孩子的节点
Edge：节点之间的分支或链接
path：从起始节点到目标节点的边
Height of Nod：特定节点到叶节点的最长路径的边数
Height of Tree：根节点到叶节点的最长路径的边数
Depth of Node：从根节点到特定节点的边数
Degree of Node：子节点数
这里以二叉树为例。每个节点最多有两个节点，左边节点比当前节点小，右边节点比当前节点大。
二叉树是递归定义的，其节点有左右子树之分，逻辑上二叉树有五种基本形态： [3]
二叉树中的常用方法：
add：将节点插入树
findMin：获取最小节点
findMax：获取最大节点
find：搜索特定节点
isPresent：确定某个节点的存在
remove：从树中删除节点
JavaScript中的示例：
class Node {
constructor(data, left = null, right = null) {
this.data = data;
this.left = left;
this.right = right;
}
}
class BST {
constructor() {
this.root = null;
}
add(data) {
const node = this.root;
if (node === null) {
this.root = new Node(data);
return;
} else {
const searchTree = function (node) {
if (data < node.data) {
if (node.left === null) {
node.left = new Node(data);
return;
} else if (node.left !== null) {
return searchTree(node.left);
}
} else if (data > node.data) {
if (node.right === null) {
node.right = new Node(data);
return;
} else if (node.right !== null) {
return searchTree(node.right);
}
} else {
return null;
}
};
return searchTree(node);
}
}
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.data !== data) {
if (data < current.data) {
current = current.left
} else {
current = current.right;
}
if (current === null) {
return null;
}
}
return current;
}
isPresent(data) {
let current = this.root;
while (current) {
if (data === current.data) {
return true;
}
if (data < current.data) {
current = current.left;
} else {
current = current.right;
}
}
return false;
}
remove(data) {
const removeNode = function (node, data) {
if (node == null) {
return null;
}
if (data == node.data) {
// no child node
if (node.left == null && node.right == null) {
return null;
}
// no left node
if (node.left == null) {
return node.right;
}
// no right node
if (node.right == null) {
return node.left;
}
// has 2 child nodes
var tempNode = node.right;
while (tempNode.left !== null) {
tempNode = tempNode.left;
}
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);
}
}
测试一下：
const bst = new BST();
bst.add(4);
bst.add(2);
bst.add(6);
bst.add(1);
bst.add(3);
bst.add(5);
bst.add(7);
bst.remove(4);
console.log(bst.findMin());
console.log(bst.findMax());
bst.remove(7);
console.log(bst.findMax());
console.log(bst.isPresent(4));
1
7
6
false
