平衡二叉树的旋转:有4类,每类中又有两类
1、左旋转:当插入的结点为失衡点的右子树的右子树中(左右孩子都行),如下图所示,A,B是同一种情况,虚线部分表示不存在。这两种情况都是左旋转,代码一样(A中140为新插入的点,B中130为新插入的点)
2、先右旋转,再左旋转:当插入的结点在失衡点的右子树的左子树中(左右孩子都行),如下图所示,A,B是同一种情况,代码一样
3、右旋转:当插入的结点为失衡点的左子树的左子树中,如下图所示,A,B是同一种情况,虚线部分表示不存在。这两种情况都是右旋转,代码一样
4、先左旋转,再右旋转:当插入的结点为失衡点的左子树的右子树中(左右孩子都行),如下图所示,A,B是同一种情况,代码一样
代码:
package main
import "fmt"
type AVL struct {
value int //值
height int //深度
left *AVL //左子树
right *AVL //右子树
}
//查找元素
func (t *AVL) Search(value int) bool {
if t == nil {
return false
}
compare := value - t.value
if compare < 0 {
return t.left.Search(value)
}else if compare > 0 {
return t.right.Search(value)
}else {
return true
}
}
func (t *AVL) leftRotate() *AVL { //左旋转
headNode := t.right
t.right = headNode.left
headNode.left = t
//更新结点高度
t.height = max(t.left.getHeight(),t.right.getHeight()) + 1
headNode.height = max(headNode.left.getHeight(),headNode.right.getHeight()) + 1
return headNode
}
func (t *AVL) rightRotate() *AVL { //右旋转
headNode := t.left
t.left = headNode.right
headNode.right = t
//更新结点高度
t.height = max(t.left.getHeight(),t.right.getHeight()) +1
headNode.height = max(headNode.left.getHeight(),headNode.right.getHeight()) + 1
return headNode
}
func (t *AVL) rightThenLeftRotate() *AVL { //右旋转,之后左旋转
//以失衡点右结点先右旋转
sonHeadNode := t.right.rightRotate()
t.right = sonHeadNode
//再以失衡点左旋转
return t.leftRotate()
}
func (t *AVL) LeftThenRightRotate() *AVL { //左旋转,之后右旋转
//以失衡点左结点先左旋转
sonHeadNode := t.left.leftRotate()
t.left = sonHeadNode
//再以失衡点左旋转
return t.rightRotate()
}
func (t *AVL) adjust() *AVL {
if t.right.getHeight() - t.left.getHeight() == 2 {
if t.right.right.getHeight() > t.right.left.getHeight() {
t = t.leftRotate()
}else {
t = t.rightThenLeftRotate()
}
}else if t.left.getHeight() - t.right.getHeight() == 2 {
if t.left.left.getHeight() > t.left.right.getHeight() {
t = t.rightRotate()
} else {
t = t.LeftThenRightRotate()
}
}
return t
}
//添加元素
func (t *AVL) Insert(value int) *AVL {
if t == nil {
newNode := AVL{value,1,nil,nil}
return &newNode
}
if value < t.value {
t.left = t.left.Insert(value)
t = t.adjust()
}else if value > t.value{
t.right = t.right.Insert(value)
t = t.adjust()
}else {
fmt.Println("the node exit")
}
t.height = max(t.left.getHeight(),t.right.getHeight()) + 1
return t
}
/*删除元素
*1、如果被删除结点只有一个子结点,就直接将A的子结点连至A的父结点上,并将A删除
*2、如果被删除结点有两个子结点,将该结点右子数内的最小结点取代A。
*3、查看是否平衡,该调整调整
*/
func (t *AVL) Delete(value int) *AVL {
if t ==nil {
return t
}
compare := value - t.value
if compare < 0 {
t.left = t.left.Delete(value)
}else if compare > 0{
t.right = t.right.Delete(value)
}else { //找到结点,删除结点()
if t.left != nil && t.right != nil {
t.value = t.right.getMin()
t.right = t.right.Delete(t.value)
} else if t.left !=nil {
t = t.left
}else {//只有一个右孩子或没孩子
t = t.right
}
}
if t != nil {
t.height = max(t.left.getHeight(),t.right.getHeight()) + 1
t = t.adjust()
}
return t
}
//按顺序获得树中元素
func (t *AVL) getAll() []int {
values := []int{}
return addValues(values,t)
}
//将一个节点加入切片中
func addValues(values []int,t *AVL) []int {
if t != nil {
values = addValues(values,t.left)
values = append(values,t.value)
fmt.Println(t.value,t.height)
values = addValues(values,t.right)
}
return values
}
//查找子树最小值
func (t *AVL) getMin() int {
if t == nil {
return -1
}
if t.left == nil {
return t.value
} else {
return t.left.getMin()
}
}
//查找子树最大值
func (t *AVL) getMax() int {
if t == nil {
return -1
}
if t.right == nil {
return t.value
} else {
return t.right.getMax()
}
}
//查找最小结点
func (t *AVL) getMinNode() *AVL {
if t == nil {
return nil
}else {
for t.left != nil {
t = t.left
}
}
return t
}
//查找最大结点
func (t *AVL) getMaxNode() *AVL {
if t == nil {
return nil
}else {
for t.right != nil {
t = t.right
}
}
return t
}
//得到树高
func (t *AVL) getHeight() int {
if t == nil {
return 0
}
return t.height
}
func max(a int,b int) int{
if a > b {
return a
}else {
return b
}
}
func main() {
bsTree := AVL{100,1,nil,nil}
newTree := bsTree.Insert(60)
newTree = bsTree.Insert(120)
newTree = bsTree.Insert(110)
newTree = bsTree.Insert(130)
newTree = bsTree.Insert(105)
fmt.Println(newTree.getAll())
newTree.Delete(110)
fmt.Println(newTree.getAll())
}