#Tree
术语：
– 树
– 根
– 节点
– 叶子
– 层次， 根节点
– 深度
– 树的高度， 空树的深度为`-1`， 根的深度为`0`， 一个节点的高度为`0`, 所有的树叶的高度都为`0`。
—
##二叉树
每个节点最多有两个孩子，空树也是一棵二叉树,链表是一种特殊的二叉树。
## 二叉排序树(二叉搜索树，B树)
## 满二叉树
## 完全二叉树
## AVL树
AVL树本质上还是一棵二叉搜索树（因此读者可以看到我后面的代码是继承自二叉搜索树的），它的特点是：
1. 本身首先是一棵二叉搜索树。
2. 带有平衡条件：每个结点的左右子树的高度之差的绝对值（平衡因子）最多为1。
例如：
“`
5 5
/ \ / \
2 6 2 6
/ \ \ / \
1 4 7 1 4
/ /
3 3
“`
上图中，左边的是AVL树，而右边的不是。因为左边的树的每个结点的左右子树的高度之差的绝对值都最多为1，而右边的树由于结点6没有子树，导致根结点5的平衡因子为2。
假设有一个结点的平衡因子为2（在AVL树中，最大就是2，因为结点是一个一个地插入到树中的，一旦出现不平衡的状态就会立即进行调整，因此平衡因子最大不可能超过2），那么就需要进行调整。由于任意一个结点最多只有两个儿子，所以当高度不平衡时，只可能是以下四种情况造成的：
– 对该结点的左儿子的左子树进行了一次插入(`LL`)。
– 对该结点的左儿子的右子树进行了一次插入(`LR`)。
– 对该结点的右儿子的左子树进行了一次插入(`RL`)。
– 对该结点的右儿子的右子树进行了一次插入(`RR`)。
情况1和4是关于该点的镜像对称，同样，情况2和3也是一对镜像对称。因此，理论上只有两种情况，当然了，从编程的角度来看还是四种情况。
第一种情况是插入发生在“外边”的情况（即左-左的情况或右-右的情况），该情况可以通过对树的一次单旋转来完成调整。第二种情况是插入发生在“内部”的情况（即左-右的情况或右-左的情况），该情况要通过稍微复杂些的双旋转来处理。
`旋转：`
###单旋转
情况1(`LL`)：对该结点的左儿子的左子树进行了一次插入。
左边为调整前得节点，我们可以看出k2的左右子树已不再满足AVL平衡条件，调整后的为右图。
由于K2的左孩子已经变大了，所以应该降低K1的高度，把K1往上提，而K2相应也得往下降。k2下降在k1的右子树(因为k1的左子树增加了，所以不可能再把k2降到k1的左子树上)，Y变为K2的左子树(如果Y变成K2的有子树，那么k2的本身没有了左子树，还降为右子树，那么就一减一加，左右失调，平衡因子变成2)。
情况2(`LR`)：对该节点的左孩子进行了一次插入
先从最先失去平衡的节点开始分析，B的left为h，right为h+2，失去平衡，c往上提，B往下提，以致降低整棵树的高度（可以理解为`B，Bl，C，Cl，Cr`这颗树，先把A ignore），C已经平衡，但是A失去平衡，C往上提，A往下降，以致降低整棵树（`C，A，Ar`），Cr连到A的left防止A的right变大而失去平衡，最终C，B，A都已经平衡。
其实他们之间的方法都是一致的，高的节点往上提已经降低其高度，高的往下提，增加高度。这里的***高度可以理解为树的高度***, 他们采用的是一种策略，这是一种平衡左右子树的`趋势`
情况3(`RR`)：
情况4(`RL`)
实现代码：
—
—
## B-树，B+树
—
—
package main
import (
"fmt"
)
type DataType int
type Node AVLTreeNode
type AVLTree *AVLTreeNode
type AVLTreeNode struct {
key DataType
high int
left *AVLTreeNode
right *AVLTreeNode
}
func main() {
data := []DataType{3, 2, 1, 4, 5, 6, 7, 16, 15, 14, 13, 12, 11, 10, 8, 9}
fmt.Println(data)
var root AVLTree = nil
for _, value := range data {
root = avl_insert(root, value)
fmt.Println(" root -> key: ", root.key, "high :", root.high, "left", root.left, "right: ", root.right)
// preorder(root)
}
preorder(root)
fmt.Println()
midorder(root)
fmt.Println()
}
func highTree(p AVLTree) int {
if p == nil {
return -1
} else {
return p.high
}
}
func max(a, b int) int {
if a > b {
return a
} else {
return b
}
}
/*Please look LL*/
func left_left_rotation(k AVLTree) AVLTree {
var kl AVLTree
kl = k.left
k.left = kl.right
kl.right = k
k.high = max(highTree(k.left), highTree(k.right)) + 1
kl.high = max(highTree(kl.left), k.high) + 1
return kl
}
/*Please look RR*/
func right_right_rotation(k AVLTree) AVLTree {
var kr AVLTree
kr = k.right
k.right = kr.left
kr.left = k
k.high = max(highTree(k.left), highTree(k.right)) + 1
kr.high = max(k.high, highTree(kr.right)) + 1
return kr
}
/*so easy*/
func left_righ_rotation(k AVLTree) AVLTree {
k.left = right_right_rotation(k.left)
return left_left_rotation(k)
}
func right_left_rotation(k AVLTree) AVLTree {
k.right = left_left_rotation(k.right)
return right_right_rotation(k)
}
func avl_insert(avl AVLTree, key DataType) AVLTree {
if avl == nil {
avl = new(AVLTreeNode)
if avl == nil {
fmt.Println("avl tree create error!")
return nil
}else {
avl.key = key
avl.high = 0
avl.left = nil
avl.right = nil
}
} else if key < avl.key {
avl.left = avl_insert(avl.left, key)
if highTree(avl.left)-highTree(avl.right) == 2 {
if key < avl.left.key { //LL
avl = left_left_rotation(avl)
} else { // LR
avl = left_righ_rotation(avl)
}
}
} else if key > avl.key {
avl.right = avl_insert(avl.right, key)
if (highTree(avl.right) - highTree(avl.left)) == 2 {
if key < avl.right.key { // RL
avl = right_left_rotation(avl)
} else {
fmt.Println("right right", key)
avl = right_right_rotation(avl)
}
}
} else if key == avl.key {
fmt.Println("the key", key, "has existed!")
}
//notice: update high(may be this insert no rotation, so you should update high)
avl.high = max(highTree(avl.left), highTree(avl.right)) + 1
return avl
}
func preorder(avl AVLTree) {
if avl != nil {
fmt.Print(avl.key, "\t")
preorder(avl.left)
preorder(avl.right)
}
}
func midorder(avl AVLTree) {
if avl != nil {
midorder(avl.left)
fmt.Print(avl.key, "\t")
midorder(avl.right)
}
}
/*display avl tree*/
func display(avl AVLTree) {
}
