二叉树排序算法

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
package main

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

type Node struct {
	data int
	left *Node
	right *Node
}

type listInt []int

var sorted_list = make(listInt, 0, 10)

func (self listInt) exists(data int) bool {
	for _, v := range self {
		if data == v {
			return true
		}
	}

	return false
}

func (self *Node) add(data int) {
	if self.data == 0 {
		self.data = data
	}

	if data < self.data {
		if self.left == nil {
			node := Node {
				data: data,
				left: nil,
				right: nil,
			}
			self.left = &node
		} else {
			self.left.add(data)
		}

	} else if data > self.data {
		if self.right == nil {
			node := Node {
				data: data,
				left: nil,
				right: nil,
			}
			self.right = &node
		} else {
			self.right.add(data)
		}
	}
}


func (self *Node) sort() {
	if self.left != nil {
		self.left.sort()
	}

	sorted_list = append(sorted_list, self.data)

	if self.right != nil {
		self.right.sort()
	}

}


func main() {

	list := make(listInt, 10)
	var temp int

	rand.Seed(time.Now().UTC().UnixNano())
	for i, _ := range list {
		for {
			temp = rand.Intn(100)
			if ! list.exists(temp) {
				list[i] = temp
				break
			}
		}
	}

	fmt.Printf("%v\n", list)

	tree := new(Node)
	for _, v := range list {
		tree.add(v)
	}
	tree.sort()

	fmt.Printf("%v\n", sorted_list)
}
0%