/*
二分探索木が極端に片寄った形になったら、もっと性能の良い形、即ち左右の
バランスの取れた形に直す。このような木を平衡木(balanced tree)と呼ぶ。
木の作り直しはレコード(頂点)の挿入や削除の際に行われる。
その計算量がO(n)を超えるようならば、列の二分探索で十分であり、
平衡木を採用する意味がない。
従って、作り直しの計算量はO(log2(n))以下に抑えたい。
この観点から、常に完全二分木を保つのは望ましくない。ほどほどで良い。
片寄り方に限度を設けるため、次の制約を持つ二分探索木を、AVL-treeと呼ぶ。
制約:どの頂点においても、その左部分木の高さと右部分木の高さの差が
+1,0,-1のいずれかでなければならない。
*/
package main
import (
"fmt"
)
// AVL木(の頂点)。
// 同じ木の中でkeyは一意であること。
// 平衡係数の初期値は0。左部分木の方が高いほど+1、右部分木の方が高いほど-1する。
// 平衡係数が2以上または-2以下の頂点が出来たとき木を再構成する。
type btree struct {
key int
value string
left *btree
right *btree
balance int // 平衡係数
}
// 探索。木tの中でキーがkeyと一致する頂点のvalueを返す。
// そのような頂点が見つからなかった場合は空文字列を返す。
func search(t *btree, key int) string {
switch {
case t == nil:
return ""
case t.key < key:
return search(t.right, key)
case key < t.key:
return search(t.left, key)
}
return t.value
}
// 木tの適切な位置に新しい頂点を挿入した木を返す。
// valueに空文字列は使わないこと
func insert(t *btree, key int, value string) *btree {
t, _ = insertAux(t, key, value)
return t
}
// 木tの適切な位置に新しい頂点を挿入した木を返す。
// また、木の高さが増えたかどうかのフラグも返す。
func insertAux(t *btree, key int, value string) (*btree, bool) {
var gu bool // 木の高さが増えたらtrue
switch {
case t == nil:
t = &btree{key: key, value: value, balance: 0}
gu = true
case key < t.key:
t.left, gu = insertAux(t.left, key, value)
if gu {
t.balance++
if t.balance < 2 {
gu = !(t.balance == 0) // 平衡になったということは、高さが増えてないということ
} else if 0 < t.left.balance {
t, gu = leftSingleRotation(t), false
} else {
t, gu = leftDoubleRotation(t), false
}
}
case t.key < key:
t.right, gu = insertAux(t.right, key, value)
if gu {
t.balance--
if -2 < t.balance {
gu = !(t.balance == 0)
} else if t.right.balance < 0 {
t, gu = rightSingleRotation(t), false
} else {
t, gu = rightDoubleRotation(t), false
}
}
}
return t, gu
}
// 木tからkeyを持つ頂点を削除した木を返す。
func
remove(t
*btree
, key
int) *btree
{ t, _ = removeAux(t, key)
return t
}
// 木tからkeyを持つ頂点を削除した木を返す。
// また、木の高さが減ったかどうかのフラグも返す。
func removeAux(t *btree, key int) (*btree, bool) {
var su bool // 木の高さが減ったらtrue
switch {
case t == nil:
su = false
case key < t.key:
t.left, su = removeAux(t.left, key)
if su {
t.balance--
if -2 < t.balance {
su = (t.balance == 0) // 平衡になったということは、高さが減ったということ
} else if t.right.balance < 0 {
t, su = rightSingleRotation(t), true
} else {
t, su = rightDoubleRotation(t), true
}
}
case t.key < key:
t.right, su = removeAux(t.right, key)
if su {
t.balance++
if t.balance < 2 {
su = (t.balance == 0)
} else if 0 < t.left.balance {
t, su = leftSingleRotation(t), true
} else {
t, su = leftDoubleRotation(t), true
}
}
default:
t, su = removeRoot(t), true
}
return t, su
}
// 根tが表す木からtを削除して返す。
func removeRoot(t *btree) *btree {
// 左子が無いなら右子を持ちあげるだけ
if t.left == nil {
return t.right
}
// 左子の右子がないということは、左子はtの次に大きい頂点である
if t.left.right == nil {
l := t.left
l.right = t.right
l.recalcBalance()
return l
}
// まずtの次の次に大きい頂点pを探しだして
var p *btree
for p = t.left; p.right.right != nil; p = p.right {
}
// tの次に大きい頂点sを新しい根とする
s := p.right
p.right = s.left
p.recalcBalance()
s.left = t.left
s.right = t.right
s.recalcBalance()
return s
}
// 頂点tが左に、かつその左部分木が左に片寄っている場合、
// 一重回転してt.leftを根にする。
func leftSingleRotation(t *btree) *btree {
l := t.left
t.left = l.right
l.right = t
t.recalcBalance()
l.recalcBalance()
return l
}
// 頂点tが左に、かつその左部分木が右に片寄っている場合、
// 二重回転してt.leftの子を根にする。
func leftDoubleRotation(t *btree) *btree {
l := t.left
lr := l.right
if lr.right != nil {
l.right = nil
} else {
l.right = lr.left
}
lr.left = l
l.recalcBalance()
t.left = lr
return leftSingleRotation(t)
}
// 頂点tが右に、かつその右部分木が右に片寄っている場合、
// 一重回転してt.rightを根にする。
func rightSingleRotation(t *btree) *btree {
r := t.right
t.right = r.left
r.left = t
t.recalcBalance()
r.recalcBalance()
return r
}
// 頂点tが右に、かつその右部分木が左に片寄っている場合、
// 二重回転してt.rightの子を根にする。
func rightDoubleRotation(t *btree) *btree {
r := t.right
rr := r.left
if rr.left != nil {
r.left = nil
} else {
r.left = rr.right
}
rr.right = r
r.recalcBalance()
t.right = rr
return rightSingleRotation(t)
}
// 平衡係数を再計算する。
func (t *btree) recalcBalance() {
switch {
case t.left == nil && t.right == nil:
t.balance = 0
case t.right == nil:
t.balance = 1
case t.left == nil:
t.balance = -1
default:
lgc := t.left.left != nil || t.left.right != nil // 左の孫を持つならtrue
rgc := t.right.left != nil || t.right.right != nil // 右の孫を持つならtrue
switch {
case lgc && !rgc:
t.balance = 1
case !lgc && rgc:
t.balance = -1
default:
t.balance = 0
}
}
}
// 頂点のkey兼valueとしたい0個以上の整数を受け取り、tを生成して返す
func buildTree(keys []int) *btree {
var t *btree
for _, k := range keys {
t = insert(t, k, fmt.Sprint(k))
}
return t
}
// 木tの各頂点の値と平行係数を表示する
func pt(t *btree) {
dq := make([]*btree, 0, 100) // 同じ深さの節を保持するキュー
bf := make([]*btree, 0, 100) // dqに追加予定の節を一時保存するキュー
bf = append(bf, t)
// 同じ深さの節を全て表示したら、次の深さの節の処理に移ることの繰り返し
var e *btree
for allIsNil(bf) == false {
dq = append(dq, bf...)
bf = bf[len(bf):]
for 0 < len(dq) {
e, dq = dq[0], dq[1:]
if e != nil {
fmt.Printf("[%v:%v] ", e.value, e.balance)
bf = append(bf, e.left)
bf = append(bf, e.right)
} else {
fmt.Printf("[_:_] ")
bf = append(bf, nil)
bf = append(bf, nil)
}
}
fmt.Println()
}
fmt.Println()
}
// xsの全要素がnilであるときtrueを返す
func allIsNil(xs []*btree) bool {
res := true
for _, x := range xs {
res = (res && x == nil)
}
return res
}
func main() {
var t *btree
t = buildTree([]int{50, 30, 70, 20, 40, 60, 80, 25, 55, 65, 75, 85, 90})
pt(t)
fmt.Println("---- キー20を削除して構造の変化を見てみる")
pt(t)
}
/*
二分探索木が極端に片寄った形になったら、もっと性能の良い形、即ち左右の
バランスの取れた形に直す。このような木を平衡木(balanced tree)と呼ぶ。

木の作り直しはレコード(頂点)の挿入や削除の際に行われる。
その計算量がO(n)を超えるようならば、列の二分探索で十分であり、
平衡木を採用する意味がない。
従って、作り直しの計算量はO(log2(n))以下に抑えたい。
この観点から、常に完全二分木を保つのは望ましくない。ほどほどで良い。

片寄り方に限度を設けるため、次の制約を持つ二分探索木を、AVL-treeと呼ぶ。
制約：どの頂点においても、その左部分木の高さと右部分木の高さの差が
+1,0,-1のいずれかでなければならない。
*/
package main

import (
	"fmt"
)

// AVL木(の頂点)。
// 同じ木の中でkeyは一意であること。
// 平衡係数の初期値は0。左部分木の方が高いほど+1、右部分木の方が高いほど-1する。
// 平衡係数が2以上または-2以下の頂点が出来たとき木を再構成する。
type btree struct {
	key     int
	value   string
	left    *btree
	right   *btree
	balance int // 平衡係数
}

// 探索。木tの中でキーがkeyと一致する頂点のvalueを返す。
// そのような頂点が見つからなかった場合は空文字列を返す。
func search(t *btree, key int) string {
	switch {
	case t == nil:
		return ""
	case t.key < key:
		return search(t.right, key)
	case key < t.key:
		return search(t.left, key)
	}
	return t.value
}

// 木tの適切な位置に新しい頂点を挿入した木を返す。
// valueに空文字列は使わないこと
func insert(t *btree, key int, value string) *btree {
	t, _ = insertAux(t, key, value)
	return t
}

// 木tの適切な位置に新しい頂点を挿入した木を返す。
// また、木の高さが増えたかどうかのフラグも返す。
func insertAux(t *btree, key int, value string) (*btree, bool) {
	var gu bool // 木の高さが増えたらtrue
	switch {
	case t == nil:
		t = &btree{key: key, value: value, balance: 0}
		gu = true
	case key < t.key:
		t.left, gu = insertAux(t.left, key, value)
		if gu {
			t.balance++
			if t.balance < 2 {
				gu = !(t.balance == 0) // 平衡になったということは、高さが増えてないということ
			} else if 0 < t.left.balance {
				t, gu = leftSingleRotation(t), false
			} else {
				t, gu = leftDoubleRotation(t), false
			}
		}
	case t.key < key:
		t.right, gu = insertAux(t.right, key, value)
		if gu {
			t.balance--
			if -2 < t.balance {
				gu = !(t.balance == 0)
			} else if t.right.balance < 0 {
				t, gu = rightSingleRotation(t), false
			} else {
				t, gu = rightDoubleRotation(t), false
			}
		}
	}
	return t, gu
}

// 木tからkeyを持つ頂点を削除した木を返す。
func remove(t *btree, key int) *btree {
	t, _ = removeAux(t, key)
	return t
}

// 木tからkeyを持つ頂点を削除した木を返す。
// また、木の高さが減ったかどうかのフラグも返す。
func removeAux(t *btree, key int) (*btree, bool) {
	var su bool // 木の高さが減ったらtrue
	switch {
	case t == nil:
		su = false
	case key < t.key:
		t.left, su = removeAux(t.left, key)
		if su {
			t.balance--
			if -2 < t.balance {
				su = (t.balance == 0) // 平衡になったということは、高さが減ったということ
			} else if t.right.balance < 0 {
				t, su = rightSingleRotation(t), true
			} else {
				t, su = rightDoubleRotation(t), true
			}
		}
	case t.key < key:
		t.right, su = removeAux(t.right, key)
		if su {
			t.balance++
			if t.balance < 2 {
				su = (t.balance == 0)
			} else if 0 < t.left.balance {
				t, su = leftSingleRotation(t), true
			} else {
				t, su = leftDoubleRotation(t), true
			}
		}
	default:
		t, su = removeRoot(t), true
	}
	return t, su
}

// 根tが表す木からtを削除して返す。
func removeRoot(t *btree) *btree {
	// 左子が無いなら右子を持ちあげるだけ
	if t.left == nil {
		return t.right
	}
	// 左子の右子がないということは、左子はtの次に大きい頂点である
	if t.left.right == nil {
		l := t.left
		l.right = t.right
		l.recalcBalance()
		return l
	}
	// まずtの次の次に大きい頂点pを探しだして
	var p *btree
	for p = t.left; p.right.right != nil; p = p.right {
	}
	// tの次に大きい頂点sを新しい根とする
	s := p.right
	p.right = s.left
	p.recalcBalance()
	s.left = t.left
	s.right = t.right
	s.recalcBalance()
	return s
}

// 頂点tが左に、かつその左部分木が左に片寄っている場合、
// 一重回転してt.leftを根にする。
func leftSingleRotation(t *btree) *btree {
	l := t.left
	t.left = l.right
	l.right = t
	t.recalcBalance()
	l.recalcBalance()
	return l
}

// 頂点tが左に、かつその左部分木が右に片寄っている場合、
// 二重回転してt.leftの子を根にする。
func leftDoubleRotation(t *btree) *btree {
	l := t.left
	lr := l.right
	if lr.right != nil {
		l.right = nil
	} else {
		l.right = lr.left
	}
	lr.left = l
	l.recalcBalance()
	t.left = lr
	return leftSingleRotation(t)
}

// 頂点tが右に、かつその右部分木が右に片寄っている場合、
// 一重回転してt.rightを根にする。
func rightSingleRotation(t *btree) *btree {
	r := t.right
	t.right = r.left
	r.left = t
	t.recalcBalance()
	r.recalcBalance()
	return r
}

// 頂点tが右に、かつその右部分木が左に片寄っている場合、
// 二重回転してt.rightの子を根にする。
func rightDoubleRotation(t *btree) *btree {
	r := t.right
	rr := r.left
	if rr.left != nil {
		r.left = nil
	} else {
		r.left = rr.right
	}
	rr.right = r
	r.recalcBalance()
	t.right = rr
	return rightSingleRotation(t)
}

// 平衡係数を再計算する。
func (t *btree) recalcBalance() {
	switch {
	case t.left == nil && t.right == nil:
		t.balance = 0
	case t.right == nil:
		t.balance = 1
	case t.left == nil:
		t.balance = -1
	default:
		lgc := t.left.left != nil || t.left.right != nil   // 左の孫を持つならtrue
		rgc := t.right.left != nil || t.right.right != nil // 右の孫を持つならtrue
		switch {
		case lgc && !rgc:
			t.balance = 1
		case !lgc && rgc:
			t.balance = -1
		default:
			t.balance = 0
		}
	}
}



// 頂点のkey兼valueとしたい0個以上の整数を受け取り、tを生成して返す
func buildTree(keys []int) *btree {
	var t *btree
	for _, k := range keys {
		t = insert(t, k, fmt.Sprint(k))
	}
	return t
}

// 木tの各頂点の値と平行係数を表示する
func pt(t *btree) {
	dq := make([]*btree, 0, 100) // 同じ深さの節を保持するキュー
	bf := make([]*btree, 0, 100) // dqに追加予定の節を一時保存するキュー
	bf = append(bf, t)
	// 同じ深さの節を全て表示したら、次の深さの節の処理に移ることの繰り返し
	var e *btree
	for allIsNil(bf) == false {
		dq = append(dq, bf...)
		bf = bf[len(bf):]
		for 0 < len(dq) {
			e, dq = dq[0], dq[1:]
			if e != nil {
				fmt.Printf("[%v:%v] ", e.value, e.balance)
				bf = append(bf, e.left)
				bf = append(bf, e.right)
			} else {
				fmt.Printf("[_:_] ")
				bf = append(bf, nil)
				bf = append(bf, nil)
			}
		}
		fmt.Println()
	}
	fmt.Println()
}

// xsの全要素がnilであるときtrueを返す
func allIsNil(xs []*btree) bool {
	res := true
	for _, x := range xs {
		res = (res && x == nil)
	}
	return res
}

func main() {
	var t *btree

	t = buildTree([]int{50, 30, 70, 20, 40, 60, 80, 25, 55, 65, 75, 85, 90})
	pt(t)
	fmt.Println("---- キー20を削除して構造の変化を見てみる")
	t = remove(t, 20)
	pt(t)
}
