Golang算法（二）数据结构

栈

type Stack struct {
	head *Node 
}

type Node struct {
	data interface{}
	next *Node
}

func NewStack()*Stack  {
	s:=&Stack{
		head: &Node{
			data: nil,
			next: &Node{},
		},
	}
	return s
}

func (s *Stack)Push(data interface{})  {
	n:=&Node{
		data: data,
		next: s.head,
	}
	s.head=n
}

func (s *Stack)Pop()(interface{},bool)  {
	if s.head==nil{
		return nil,false
	}
	n:=s.head
	s.head=s.head.next
	return n.data,true
}

队列

type Queue struct {
	head *Node
	tail *Node
}

func (q *Queue) Enqueue(data interface{}) {
	node:=&Node{
		data: data,
		next: nil,
	}
	if q.tail==nil{
		q.head=node
		q.tail=node
	}else {
		q.tail.next=node
		q.tail=node
	}
}

func (q *Queue) Dequeue()(interface{},bool) {
	if q.head==nil{
		return nil,false
	}
	d:=q.head.data
	q.head=q.head.next
	if q.head==nil{
		q.tail=nil
	}
	return d,true

}

func (q Queue) String() string    {
	node:=q.head
	var arr []interface{}
	for node!=nil {
		arr=append(arr,node.data)
		node=node.next
	}
	return fmt.Sprintf("%v",arr)
}

func NewQueue() *Queue {
	q:=&Queue{}
	return q
}

双向链表

type DoubleLinkedList struct {
	head *DoubleNode
}
type DoubleNode struct {
	data interface{}
	pre *DoubleNode
	next *DoubleNode
}

func NewDLL()*DoubleLinkedList  {
	d:=&DoubleLinkedList{}
	return d
}

func (d *DoubleLinkedList)Insert(data interface{})  {
	dn:=&DoubleNode{
		data: data,
		pre:  nil,
		next: d.head,
	}
	if d.head!=nil{
		d.head.pre=dn
	}
	d.head=dn
}

func (d *DoubleLinkedList)Search(data interface{}) bool {
	if d.head==nil{
		return false
	}
	n:=d.head
	for n!=nil{
		if n.data==data{
			return true
		}
		n=n.next
	}
	return false
}

func (D DoubleLinkedList) String() string    {
	node:=D.head
	var arr []interface{}
	for node!=nil {
		arr=append(arr,node.data)
		node=node.next
	}
	return fmt.Sprintf("%v",arr)
}

二叉搜索树

type BinaryTree struct {
	Root *TreeNode
}
type TreeNode struct {
	Data int
	Left *TreeNode
	Right *TreeNode
	Parent *TreeNode
}

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

func InOrder(t *TreeNode){
	if t!=nil{
		InOrder(t.Left)
		fmt.Print(t.Data,",")
		InOrder(t.Right)
	}
}

func PreOrder(t *TreeNode){
	if t!=nil{
		fmt.Print(t.Data,",")
		PreOrder(t.Left)
		PreOrder(t.Right)
	}
}

func PostOrder(t *TreeNode){
	if t!=nil{
		PostOrder(t.Left)
		PostOrder(t.Right)
		fmt.Print(t.Data,",")
	}
}

func (t *TreeNode)Serch(data int) *TreeNode{
	if t==nil{
		return nil
	}
	if t.Data==data{
		return t
	}else if data>t.Data{
		return t.Right.Serch(data)
	}else {
		return t.Left.Serch(data)
	}
}
func (t *BinaryTree)Insert(data int){
	n:=&TreeNode{
		Data: data,
	}
	if t.Root==nil{
		t.Root=n
		return
	}
	x:=t.Root
	var y *TreeNode
	for x!=nil{
		y=x
		if x.Data<data{
			x=x.Right
		} else {
			x=x.Left
		}
	}
	n.Parent=y
	//注意不能直接让x=n，因为x是nil，不是y的子节点
	if y.Data>data{
		y.Left=n
	}else {
		y.Right=n
	}
}
func (t *BinaryTree) Replace(src, dest *TreeNode) {
	if dest.Parent == nil {
		t.Root = src
	} else if dest == dest.Parent.Left {
		dest.Parent.Left = src
	} else {
		dest.Parent.Right = src
	}
	src.Parent = dest.Parent
}
func (t *BinaryTree) Delete(n *TreeNode) {
	if n.Left == nil {
		t.Replace(n.Right,n)
	}else if n.Right==nil{
		t.Replace(n.Left,n)
	}else {
		//找到n右子树上最小的值
		y:=n.Right.Minimum()
		if y!=n.Right{
			//如果最小值不是n的子节点，则需要和n的右子节点换一下，保证n的右子节点左侧没有挂在
			//，因为要让n的左侧挂在到n的右子节点上去
			t.Replace(y,n.Right)
			n.Right.Parent=y
		}
		t.Replace(y,n)
		//将n的左子树挂在到y上
		y.Left=n.Left
		n.Left.Parent=y
	}
}

func (n *TreeNode) Minimum() *TreeNode {
	x:=n
	for x!=nil&&x.Left!=nil {
		x = x.Left
	}
	return x
}

func (n *TreeNode) FillNode(data int, left, right, parent *TreeNode) {
	n.Left = left
	n.Right = right
	n.Parent = parent
	n.Data = data
}

红黑树

红黑树比二叉搜索树多一个属性：color
满足下列几个性质：
1.每个节点都是红色或者黑色的
2.根节点是黑色的
3.每个叶节点（NIL）是黑色的
4.如果一个节点是红色的，那么它的两个子节点都是黑色的
5.对于每个节点，从该节点到其所有叶子结点的简单路径上，均包含相同数目的黑色节点
引理：
1.一棵有n个内部个节点的红黑树的高度至多为2lg(n+1)