二分搜索树

1.二叉树

2.二分搜索树

2.1二分搜索树添加元素

基础的节点添加

package main

import "fmt"

type Node struct {
    e     int
    left  *Node
    right *Node
}
type binaryTree struct {
    size int
    root *Node
}

func NewBinaryTree() *binaryTree {
    return &binaryTree{}
}

func (tree *binaryTree) addNode(e int) {
    if tree.root == nil {
        tree.size++
        tree.root = &Node{
            e:     e,
            left:  nil,
            right: nil,
        }
    } else {
        tree.add(tree.root, e)
    }

}
func (tree *binaryTree) add(node *Node, e int) {
    if node.e == e {
        return
    } else if node.e > e && node.left == nil {
        tree.size++
        node.left = &Node{
            e:     e,
            left:  nil,
            right: nil,
        }
        return
    } else if node.e < e && node.right == nil {
        tree.size++
        node.right = &Node{
            e:     e,
            left:  nil,
            right: nil,
        }
        return
    }
    if node.e > e {
        tree.add(node.left, e)
    } else {
        tree.add(node.right, e)
    }

}
func main() {
    tree := NewBinaryTree()
    for _, i := range []int{3, 5, 1, 2, 4} {
        tree.addNode(i)
    }
    fmt.Println(tree)

}

修改后的节点添加

package main

import (
    "fmt"
)

type Node struct {
    e     int
    left  *Node
    right *Node
}
type binaryTree struct {
    size int
    root *Node
}

func NewBinaryTree() *binaryTree {
    return &binaryTree{}
}

func (tree *binaryTree) addNode(e int) {
    tree.root = tree.add(tree.root, e)

}
func (tree *binaryTree) add(node *Node, e int) *Node {
    if node == nil {
        tree.size++
        return &Node{
            e:     e,
            left:  nil,
            right: nil,
        }
    } else if node.e > e {
        node.left = tree.add(node.left, e)
    } else {
        node.right = tree.add(node.right, e)
    }
    return node

}
func main() {
    tree := NewBinaryTree()
    for _, i := range []int{3, 5, 1, 2, 4} {
        tree.addNode(i)
    }
    fmt.Println(tree)

}

有问题的节点添加

package main

import "fmt"

type Node struct {
    e     int
    left  *Node
    right *Node
}
type binaryTree struct {
    size int
    root *Node
}

func NewBinaryTree() *binaryTree {
    return &binaryTree{}
}

func (tree *binaryTree) addNode(e int) {
    tree.add(tree.root, e)

}
func (tree *binaryTree) add(node *Node, e int) {
    if node == nil {
        tree.size++
        node = &Node{
            e:     0,
            left:  nil,
            right: nil,
        }
    } else if node.e > e {
        tree.add(node.left, e)
    } else {
        tree.add(node.right, e)
    }

}
func main() {
    tree := NewBinaryTree()
    for _, i := range []int{3, 5, 1, 2, 4} {
        tree.addNode(i)
    }
    fmt.Println(tree)

}

这个add代码不能把新创建的Node节点添加到二分搜索树中。

为什么？这是因为node只是这个函数的一个参数变量，在整个函数结束的时候，node就会消失。

在这个实现中，node=&Node{}这句话是将node指向了新创建的节点。但在return后，node这个变量就消失了，会被GC 回收。

所以在这个代码中，新创建的node没有挂到原有的二分搜索树中。

非递归的节点添加

package main

import (
    "fmt"
)

type Node struct {
    e     int
    left  *Node
    right *Node
}
type binaryTree struct {
    size int
    root *Node
}

func NewBinaryTree() *binaryTree {
    return &binaryTree{}
}

func (tree *binaryTree) add(e int) {
    if tree.root == nil {
        tree.size++
        tree.root = &Node{
            e:     e,
            left:  nil,
            right: nil,
        }
        return
    }
    node := tree.root
    for {
        if node.e > e {
            if node.left == nil {
                tree.size++
                node.left = &Node{
                    e:     e,
                    left:  nil,
                    right: nil,
                }
                return
            } else {
                node = node.left
            }
        } else {
            if node.right == nil {
                tree.size++
                node.right = &Node{
                    e:     e,
                    left:  nil,
                    right: nil,
                }
                return
            } else {
                node = node.right
            }
        }
    }

}
func main() {
    tree := NewBinaryTree()
    for _, i := range []int{3, 5, 1, 2, 4} {
        tree.add(i)
    }
    fmt.Println(tree)

}

2.2元素查找-contains

package main

import "fmt"

type Node struct {
    e     int
    left  *Node
    right *Node
}
type tree struct {
    size int
    root *Node
}

func NewTree() *tree {
    return &tree{}
}

func (t *tree) add(e int) {
    t.root = t.addR(t.root, e)

}
func (t *tree) addR(node *Node, e int) *Node {
    if node == nil {
        t.size++
        return &Node{e: e}
    } else if node.e > e {
        node.left = t.addR(node.left, e)
    } else {
        node.right = t.addR(node.right, e)
    }
    return node
}
func (t *tree) contains(e int) bool {
    return t.containsR(t.root,e)

}
func (t *tree) containsR(node *Node, e int) bool {
    if node==nil{
        return false
    }
    if node.e==e{
        return true
    }else if node.e>e{
        return t.containsR(node.left,e)
    }else{
        return t.containsR(node.right,e)
    }
}

func main() {
    tree := NewTree()
    for _, i := range []int{3, 5, 1, 2, 4} {
        tree.add(i)
    }
    fmt.Println(tree.contains(6))

}

2.3前序遍历--根节点->左节点->右节点

真正访问父节点发生在第一个蓝色的点

func (t *tree) preOrderR(node *Node) {
    if node == nil {
        return
    }
    fmt.Println(node.e)
    t.preOrderR(node.left)
    t.preOrderR(node.right)
}

package main

import "fmt"

type Node struct {
    e     int
    left  *Node
    right *Node
}
type tree struct {
    size int
    root *Node
}

func NewTree() *tree {
    return &tree{}
}

func (t *tree) add(e int) {
    t.root = t.addR(t.root, e)

}
func (t *tree) addR(node *Node, e int) *Node {
    if node == nil {
        t.size++
        return &Node{e: e}
    } else if node.e > e {
        node.left = t.addR(node.left, e)
    } else {
        node.right = t.addR(node.right, e)
    }
    return node
}
func (t *tree) contains(e int) bool {
    return t.containsR(t.root, e)

}
func (t *tree) containsR(node *Node, e int) bool {
    if node == nil {
        return false
    }
    if node.e == e {
        return true
    } else if node.e > e {
        return t.containsR(node.left, e)
    } else {
        return t.containsR(node.right, e)
    }
}
func (t *tree) preOrder() {
    t.preOrderR(t.root)

}



func main() {
    tree := NewTree()
    for _, i := range []int{3, 5, 1, 2, 4} {
        tree.add(i)
    }
    tree.preOrder()

}

2.4中序遍历--结果是顺序的--左节点->根节点->右节点

真正访问父节点发生在第二个蓝色的点

func (t *tree) preOrderR(node *Node) {
    if node == nil {
        return
    }
    
    t.preOrderR(node.left)
    fmt.Println(node.e)
    t.preOrderR(node.right)
}

2.5后序遍历

真正访问父节点发生在第三个蓝色的点

func (t *tree) postOrderR(node *Node) {
    if node == nil {
        return
    }

    t.preOrderR(node.left)
    t.preOrderR(node.right)
    fmt.Println(node.e)
}

2.6层序遍历--广度优先--利用队列

func (t *tree) levelOrder() {
    q := newQueue(3)
    q.Push(t.root)
    for {
        if q.IsEmpty() {
            return
        }
        cur := q.Pop().(*Node)
        fmt.Println(cur.e)
        if cur.left != nil {
            q.Push(cur.left)
        }
        if cur.right != nil {
            q.Push(cur.right)
        }

    }
}

广度优先的意义

2.7删除节点-从删除最小、最大到删除任意节点

package main

import (
    "fmt"
)

type queue struct {
    data []interface{}
    size int
}

func newQueue(cp int) *queue {
    return &queue{
        size: 0,
        data: make([]interface{}, 0, cp),
    }

}
func (q *queue) Push(e interface{}) {
    q.data = append(q.data, e)
    q.size++
}
func (q *queue) Pop() interface{} {
    e := q.data[0]
    q.data = q.data[1:]
    q.size--
    return e
}
func (q *queue) Size() int {
    return q.size
}
func (q *queue) IsEmpty() bool {
    return q.size == 0
}

type Node struct {
    e     int
    left  *Node
    right *Node
}
type tree struct {
    size int
    root *Node
}

func NewTree() *tree {
    return &tree{}
}

func (t *tree) add(e int) {
    t.root = t.addR(t.root, e)

}
func (t *tree) addR(node *Node, e int) *Node {
    if node == nil {
        t.size++
        return &Node{e: e}
    } else if node.e > e {
        node.left = t.addR(node.left, e)
    } else {
        node.right = t.addR(node.right, e)
    }
    return node
}
func (t *tree) contains(e int) bool {
    return t.containsR(t.root, e)

}
func (t *tree) containsR(node *Node, e int) bool {
    if node == nil {
        return false
    }
    if node.e == e {
        return true
    } else if node.e > e {
        return t.containsR(node.left, e)
    } else {
        return t.containsR(node.right, e)
    }
}
func (t *tree) preOrder() {
    t.preOrderR(t.root)

}
func (t *tree) preOrderR(node *Node) {
    if node == nil {
        return
    }
    fmt.Println(node.e)
    t.preOrderR(node.left)
    t.preOrderR(node.right)
}
func (t *tree) inOrder() {
    t.inOrderR(t.root)
}
func (t *tree) inOrderR(node *Node) {
    if node == nil {
        return
    }

    t.preOrderR(node.left)
    fmt.Println(node.e)
    t.preOrderR(node.right)
}
func (t *tree) postOrder() {
    t.postOrderR(t.root)
}
func (t *tree) postOrderR(node *Node) {
    if node == nil {
        return
    }

    t.preOrderR(node.left)
    t.preOrderR(node.right)
    fmt.Println(node.e)
}
func (t *tree) levelOrder() {
    q := newQueue(3)
    q.Push(t.root)
    for {
        if q.IsEmpty() {
            return
        }
        cur := q.Pop().(*Node)
        fmt.Println(cur.e)
        if cur.left != nil {
            q.Push(cur.left)
        }
        if cur.right != nil {
            q.Push(cur.right)
        }

    }
}
func (t *tree) min() *Node {
    return t.minR(t.root)
}
func (t *tree) minR(node *Node) *Node {
    if node == nil {
        return nil
    }
    if node.left == nil {
        return node
    }
    return t.minR(node.left)
}
func (t *tree) removeMin() *Node {
    t.root = t.removeMinR(t.root)
    return t.min()
}
func (t *tree) removeMinR(node *Node) *Node {
    if node.left == nil {
        t.size--
        rightNode := node.right
        node.right = nil
        return rightNode
    }
    node.left = t.removeMinR(node.left)
    return node
}
func (t *tree) max() *Node {
    return t.minR(t.root)
}
func (t *tree) maxR(node *Node) *Node {
    if node == nil {
        return nil
    }
    if node.right == nil {
        return node
    }
    return t.maxR(node.right)
}
func (t *tree) removeMax() *Node {
    t.root = t.removeMaxR(t.root)
    return t.max()
}
func (t *tree) removeMaxR(node *Node) *Node {
    if node.right == nil {
        t.size--
        leftNode := node.left
        node.left = nil
        return leftNode
    }
    node.right = t.removeMaxR(node.right)
    return node
}
func (t *tree) remove(e int) {
    t.root = t.removeR(t.root, e)
}
func (t *tree) removeR(node *Node, e int) *Node {
    if node == nil {
        return nil
    }
    if node.e > e {
        node.left = t.removeR(node.left, e)
        return node
    } else if node.e < e {
        node.right = t.removeR(node.right, e)
        return node
    } else { //e == node.e
        //没有左子树
        if node.left == nil {
            t.size--
            rightNode := node.right
            node.right = nil
            return rightNode
        }
        //没有右子树
        if node.right == nil {
            t.size--
            leftNode := node.left
            node.left = nil
            return leftNode
        }
        //待删除节点左右子树都不为空
        //找到比待删除节点大的最小节点，即待删除节点右子树的最小节点
        //用这个节点顶替待删除的节点

        //由于在removeMinR中进行过一次size--，实际那个节点没有被删除，所以这里不需要再多进行一次size--了
        successor := t.minR(node.right)
        //这个要写在前面，先把successor从右子树中移除，然后在进行赋值操作
        successor.right = t.removeMinR(node.right)
        successor.left = node.left

        node.left = nil
        node.right = nil

        return successor

    }

}
func main() {
    tree := NewTree()
    for _, i := range []int{3, 5, 1, 2, 4} {
        tree.add(i)
    }

    tree.remove(3)
    fmt.Println(tree)

}