Go语言实现二叉查找树(Binary Search Trees)

官网有一个二叉排序树的例子，在此基础上增加了查找和删除节点功能。

代码:

package main

//Binary Search Trees
//author: Xiong Chuan Liang
//date: 2015-2-1

import (
	"fmt"
	"math/rand"
)

func main() {

	t := New(10, 1)

	if Search(t, 6) {
		fmt.Println("Search(6) true")
	} else {
		fmt.Println("Search(6) false")
	}
	Print(t)

	if Delete(t, 6) {
		fmt.Println("Delete(6) true")
	} else {
		fmt.Println("Delete(6) false")
	}
	Print(t)

	if Delete(t, 9) {
		fmt.Println("Delete(9) true")
	} else {
		fmt.Println("Delete(9) false")
	}
	Print(t)

	min, foundMin := GetMin(t)
	if foundMin {
		fmt.Println("GetMin() =", min)
	}

	max, foundMax := GetMax(t)
	if foundMax {
		fmt.Println("GetMax() =", max)
	}

	t2 := New(100, 1)
	fmt.Println(Compare(t2, New(100, 1)), " Compare() Same Contents")
	fmt.Println(Compare(t2, New(99, 1)), " Compare() Differing Sizes")

}

type Tree struct {
	Left  *Tree
	Value int
	Right *Tree
}

func New(n, k int) *Tree {
	var t *Tree
	for _, v := range rand.Perm(n) {
		t = Insert(t, (1+v)*k)
	}
	return t
}

func Insert(t *Tree, v int) *Tree {
	if t == nil {
		return &Tree{nil, v, nil}
	}
	if v < t.Value {
		t.Left = Insert(t.Left, v)
		return t
	}
	t.Right = Insert(t.Right, v)
	return t
}

//中序遍历
func Print(t *Tree) { //Recursive
	if t == nil {
		return
	}
	Print(t.Left)
	fmt.Println("node:", t.Value)
	Print(t.Right)
}

func Search(t *Tree, v int) bool {

	if t == nil {
		return false
	}
	switch {
	case v == t.Value:
		return true
	case v < t.Value:
		return Search(t.Left, v)
	case v > t.Value:
		return Search(t.Right, v)
	}
	return false
}

func GetMin(t *Tree) (int, bool) {
	if t == nil {
		return -1, false
	}

	for {
		if t.Left != nil {
			t = t.Left
		} else {
			return t.Value, true
		}
	}
}

func GetMax(t *Tree) (int, bool) {
	if t == nil {
		return -1, false
	}
	for {
		if t.Right != nil {
			t = t.Right
		} else {
			return t.Value, true
		}
	}
}

func Delete(t *Tree, v int) bool {
	if t == nil {
		return false
	}

	parent := t
	found := false
	for {
		if t == nil {
			break
		}
		if v == t.Value {
			found = true
			break
		}

		parent = t
		if v < t.Value { //left
			t = t.Left
		} else {
			t = t.Right
		}
	}

	if found == false {
		return false
	}
	return deleteNode(parent, t)
}

func deleteNode(parent, t *Tree) bool {
	if t.Left == nil && t.Right == nil {
		fmt.Println("delete() 左右树都为空 ")
		if parent.Left == t {
			parent.Left = nil
		} else if parent.Right == t {
			parent.Right = nil
		}
		t = nil
		return true
	}

	if t.Right == nil { //右树为空
		fmt.Println("delete() 右树为空 ")
		parent.Left = t.Left.Left
		parent.Value = t.Left.Value
		parent.Right = t.Left.Right
		t.Left = nil
		t = nil
		return true
	}

	if t.Left == nil { //左树为空
		fmt.Println("delete() 左树为空 ")
		parent.Left = t.Right.Left
		parent.Value = t.Right.Value
		parent.Right = t.Right.Right
		t.Right = nil
		t = nil
		return true
	}

	fmt.Println("delete() 左右树都不为空 ")
	previous := t
	//找到左子节点的最右叶节点，将其值替换至被删除节点
	//然后将这个最右叶节点清除，所以说，为了维持树，
	//这种情况下，这个最右叶节点才是真正被删除的节点
	next := t.Left
	for {
		if next.Right == nil {
			break
		}
		previous = next
		next = next.Right
	}

	t.Value = next.Value
	if previous.Left == next {
		previous.Left = next.Left
	} else {
		previous.Right = next.Right
	}
	next.Left = nil
	next.Right = nil
	next = nil
	return true
}

// Walk traverses a tree depth-first,
// sending each Value on a channel.
func Walk(t *Tree, ch chan int) {
	if t == nil {
		return
	}
	Walk(t.Left, ch)
	ch <- t.Value
	Walk(t.Right, ch)
}

// Walker launches Walk in a new goroutine,
// and returns a read-only channel of values.
func Walker(t *Tree) <-chan int {
	ch := make(chan int)
	go func() {
		Walk(t, ch)
		close(ch)
	}()
	return ch
}

// Compare reads values from two Walkers
// that run simultaneously, and returns true
// if t1 and t2 have the same contents.
func Compare(t1, t2 *Tree) bool {
	c1, c2 := Walker(t1), Walker(t2)
	for {
		v1, ok1 := <-c1
		v2, ok2 := <-c2
		if !ok1 || !ok2 {
			return ok1 == ok2
		}
		if v1 != v2 {
			break
		}
	}
	return false
}

运行效果:

Search(6) true
node: 1
node: 2
node: 3
node: 4
node: 5
node: 6
node: 7
node: 8
node: 9
node: 10
delete() 左右树都为空
Delete(6) true
node: 1
node: 2
node: 3
node: 4
node: 5
node: 7
node: 8
node: 9
node: 10
delete() 右树为空
Delete(9) true
node: 1
node: 2
node: 3
node: 4
node: 5
node: 8
node: 10
GetMin() = 1
GetMax() = 10
true  Compare() Same Contents
false  Compare() Differing Sizes

官网的例子中,Compare函数真是赞。

MAIL : [email protected]

BLOG: http://blog.csdn.net/xcl168