二叉平衡树旋转

二叉平衡树旋转

二叉平衡树操作

添加

二叉平衡树的添加节点，首先找到对应位置增加节点，其次查看左右子树的高度差是否符合标准，不然则调整。

删除

二叉平衡树删除，首先和二叉排序树同样的规则，删除对应节点，主要考虑一下三点情况

• 删除节点是叶子节点，则直接删除
• 删除节点有左或者右节点的存在，则将其存在的节点继承该删除节点的位置，则满足二叉排序树性质
• 删除节点存在左右节点，则找到其后继节点，替换后继节点的值，删除后继节点(也可使用前驱节点操作)

其次删除后向上查看是否符合左右子树平衡标准，不然则调整。

整体代码以及单测

package AVLT

type AVLT struct {
	value int
	h int
	left *AVLT
	right *AVLT
}

func InitAVLT(v int, h int) *AVLT{
	t := AVLT{
		value:v,
		h:h,
		left:nil,
		right:nil,
	}
	return &t
}

func FindMax(root *AVLT) *AVLT{
	if root == nil {
		return nil
	}
	if root.right == nil {
		return root
	}
	return FindMax(root.right)
}

func FindMin(root *AVLT) *AVLT{
	if root == nil {
		return nil
	}
	if root.left == nil {
		return root
	}
	return FindMin(root.left)
}

func GetHeight(root *AVLT) int {
	if root == nil {
		return 0
	}
	return root.h
}

func LL(root *AVLT) *AVLT{
	tmp := root.left
	root.left = tmp.right
	root.h = max(GetHeight(root.left),GetHeight(root.right)) + 1
	tmp.right = root
	root = tmp
	tmp.h = max(GetHeight(tmp.left),GetHeight(tmp.right)) + 1
	return tmp
}

func RR(root *AVLT) *AVLT{
	tmp := root.right
	root.right = tmp.left
	root.h = max(GetHeight(root.left),GetHeight(root.right)) + 1
	tmp.left = root
	root = tmp
	tmp.h = max(GetHeight(tmp.left),GetHeight(tmp.right)) + 1
	return tmp
}

func LR(root *AVLT) *AVLT{
	//tmp := root.left.RR()
	//root.left = tmp
	RR(root.left)
	return LL(root)
}

func RL(root *AVLT) *AVLT{
	//tmp := root.right.LL()
	//root.right = tmp
	LL(root.right)
	return RR(root)
}

func Insert(root *AVLT,x int) *AVLT{
	if root == nil {
		root = InitAVLT(x,1)
	} else if x < root.value {
		root.left = Insert(root.left,x)
		if GetHeight(root.left) - GetHeight(root.right) > 1 {
			if x < root.left.value {
				root = LL(root)
			} else {
				root = LR(root)
			}
		}
	} else if root.value < x {
		root.right = Insert(root.right,x)
		if GetHeight(root.right) - GetHeight(root.left) > 1 {
			if x > root.right.value {
				root = RR(root)
			} else {
				root = RL(root)
			}
		}
	}
	root.h = max(GetHeight(root.left),GetHeight(root.right)) + 1
	return root
}

func Delete(root *AVLT,x int) *AVLT{
	if root == nil {
		return nil
	} else if root.value == x {
		if root.left != nil && root.right != nil {
			if GetHeight(root.left) > GetHeight(root.right) {
				root.value = FindMax(root.left).value
				root.left = Delete(root.left,root.value)
			} else {
				root.value = FindMin(root.right).value
				root.right = Delete(root.right,root.value)
			}
		} else {
			if root.left != nil {
				root = root.left
			} else if root.right != nil {
				root = root.right
			} else {
				root = nil
			}
		}
	} else if root.value > x {
		root.left = Delete(root.left,x)
		if GetHeight(root.right) - GetHeight(root.left) > 1 {
			if GetHeight(root.right.left) > GetHeight(root.right.right) {
				root = RL(root)
			} else {
				root = RR(root)
			}
		} else {
			root.h = max(GetHeight(root.left),GetHeight(root.right)) + 1
		}
	} else {
		root.right = Delete(root.right,x)
		if GetHeight(root.left) - GetHeight(root.right) > 1 {
			if GetHeight(root.left.left) < GetHeight(root.left.right) {
				root = LR(root)
			} else {
				root = LL(root)
			}
		} else {
			root.h = max(GetHeight(root.left),GetHeight(root.right)) + 1
		}
	}
	return root;
}

func max(a,b int) int{
	if a<b {
		return b
	}
	return a
}

func min(a,b int) int {
	if a<b {
		return a
	}
	return b
}

func abs(a,b int) int {
	t1 := a-b
	if t1<0 {
		t1 = -1 * t1
	}
	t2 := b-a
	if t2<0 {
		t2 = -1 * t2
	}
	return max(t1,t2)
}
//===================单测=================
package AVLT

import (
	"fmt"
	"math/rand"
	"testing"
	"time"
)


func TestInsert(t *testing.T) {
	a := []int{1, 2, 3, 4, 5, 6, 7, 8}
	root := InitAVLT(0, 1)
	for i, _ := range a {
		root = Insert(root, a[i])
	}
	PrintAVLT(root,4)
}

func TestDelete(t *testing.T) {
	a := []int{1, 2, 3, 4, 5, 6, 7, 8}
	ra := []int{0,1, 2, 3, 4, 5, 6, 7, 8}
	root := InitAVLT(0, 1)
	for i, _ := range a {
		root = Insert(root, a[i])
	}
	ra = getRandomArray(ra)
	for i,_ := range ra {
		root  = Delete(root,ra[i])
		//PrintAVLT(root,4)
		PrintAVLTNoHeight(root,4)
		fmt.Println("===============")
	}
}

func PrintAVLT(root *AVLT, C int) {
	if root == nil {
		fmt.Println("weng")
		return
	}
	var q []*AVLT
	tmp := 1
	q = append(q,root)
	j := 0
	c := 0
	for j < len(q) && c < C{
		for i:=0;i<tmp && j+i < len(q);i++{
			if q[j+i].h == -2 {
				fmt.Printf("x,x  ")
			} else {
				fmt.Printf("%d,%d  ",q[j+i].value,q[j+i].h)
			}
			if q[j+i].left != nil && q[j+i].right != nil{
				q = append(q,q[j+i].left)
				q = append(q,q[j+i].right)
			} else if q[j+i].left == nil && q[j+i].right != nil{
				q = append(q,&AVLT{0,-2,nil,nil})
				q = append(q,q[j+i].right)
			} else if q[j+i].left != nil && q[j+i].right == nil{
				q = append(q,q[j+i].left)
				q = append(q,&AVLT{0,-2,nil,nil})
			} else  {
				q = append(q,&AVLT{0,-2,nil,nil})
				q = append(q,&AVLT{0,-2,nil,nil})
			}
		}
		fmt.Println()
		j += tmp
		tmp = tmp * 2
		c += 1
	}
}

func PrintAVLTNoHeight(root *AVLT, C int) {
	if root == nil {
		fmt.Println("weng")
		return
	}
	var q []*AVLT
	tmp := 1
	q = append(q,root)
	j := 0
	c := 0
	for j < len(q) && c < C{
		for i:=0;i<tmp && j+i < len(q);i++{
			if q[j+i].h == -2 {
				fmt.Printf("x  ")
			} else {
				fmt.Printf("%d  ",q[j+i].value)
			}
			if q[j+i].left != nil && q[j+i].right != nil{
				q = append(q,q[j+i].left)
				q = append(q,q[j+i].right)
			} else if q[j+i].left == nil && q[j+i].right != nil{
				q = append(q,&AVLT{0,-2,nil,nil})
				q = append(q,q[j+i].right)
			} else if q[j+i].left != nil && q[j+i].right == nil{
				q = append(q,q[j+i].left)
				q = append(q,&AVLT{0,-2,nil,nil})
			} else  {
				q = append(q,&AVLT{0,-2,nil,nil})
				q = append(q,&AVLT{0,-2,nil,nil})
			}
		}
		fmt.Println()
		j += tmp
		tmp = tmp * 2
		c += 1
	}
}

func getRandomArray(vs []int) []int {
	rand.Seed(time.Now().UnixNano())
	for i := 0; i < 6; i++ {
		ri := rand.Intn(6)
		tmp := vs[i]
		vs[i] = vs[ri]
		vs[ri] = tmp
	}
	return vs
}