二叉树

Author: xiaomeng79

data-structures/README.md

@@ -0,0 +1,61 @@
+## 数据结构
+
+[概念](https://blog.csdn.net/qq_31196849/article/details/78529724)
+
+[数据结构汇总](https://www.jianshu.com/p/2469a4d9708e)
+
+[算法时间复杂度的计算](http://univasity.iteye.com/blog/1164707)
+
+### 逻辑结构:
+
+具体问题抽象出来的数学模型
+
+1. 集合(数据元素之间无关系)
+2. 线性结构(1:1)
+3. 树形结构(1:n)
+4. 图状结构(n:n)
+
+### 存储结构/物理结构：
+
+数据在计算机内存中的存储(顺序结构 链式结构 索引结构 哈希结构)
+
+### 抽象数据类型(ADT):
+
+ADT=（D，S, P） D是数据对象 S是D上的关系集 P是对D的基本操作集  
+类似面向对象程序中的类
+
+
+### 算法和其5个特性：
+
+算法是描述计算机解决给定问题的操作过程，即为决解某一特定问题而由若干条指令组成的有穷序列
+
+有穷行 确定性 可行行 输入 输出
+
+### 线性表
+
+线性表是n(n>0)个相同类型数据元素构成的有限序列，其中n为线性表的长度
+
+1. 顺序存储(顺序表):数组(连续的存储单元)
+2. 链式存储:每个元素（data + next指针，不连续的存储单元，链表不是随机存取结构，只能顺序存取
+
+#### 链表
+
+1. 单向链表：
+2. 循环链表:表中的尾节点指向头节点，形成一个环，操作和线性链表基本一致，没有NULL指针，故终止条件为，是否等于某一个指定的指针
+3. 双向链表:双向链表是在单链表的每个结点里再增加一个指向其直接前驱的指针域prior。这样就形成了链表中有两个方向不同的链
+
+### 栈和队列
+
+#### 栈(LIFO)
+
+限制在表的一端进行插入和删除运算的特殊线性表
+
+##### 栈的存储
+
+顺序栈:利用一组地址连续的存储单元依次存放自栈底到栈顶的数据元素
+
+#### 队列(FIFO)
+
+
+
+

data-structures/binaryTree/bst.go

@@ -0,0 +1,169 @@
+package binaryTree
+
+//二叉树
+//二叉树是每个节点最多有两个子树的树结构
+type ElementType int//节点数据
+//结点
+type Node struct {
+	Value ElementType
+	Parent *Node
+	Left *Node
+	Right *Node
+}
+
+//创建节点
+func NewNode(v ElementType) *Node {
+	return &Node{Value:v}
+}
+
+/*
+*节点比较
+* n>m:1 n<m:-1 n=m:0
+ */
+func (n *Node) Compare(m *Node) int {
+	if n.Value < m.Value {
+		return -1
+	} else if n.Value > m.Value {
+		return 1
+	} else {
+		return 0
+	}
+}
+
+//树
+type Tree struct {
+	Head *Node
+	Size int
+}
+
+//创建树
+func NewTree(n *Node) *Tree {
+	if n == nil {
+		return &Tree{}
+	}
+	return &Tree{Head:n,Size:1}
+}
+
+//插入,相同的节点值，放到右子树
+func (t *Tree) Insert(i ElementType) {
+	n := NewNode(i)//创建节点
+	if t.Head == nil {//判断树的根节点
+		t.Head = n
+		t.Size++
+		return
+	}
+
+	h := t.Head
+
+	for {
+		if n.Compare(h) == -1 {//小于parent，到左子节点
+			if h.Left == nil {//无左子节点
+				h.Left = n
+				n.Parent = h
+				break
+			} else {
+				h = h.Left
+			}
+		} else {//大于parent
+			if h.Right == nil {
+				h.Right = n
+				n.Parent = h
+				break
+			} else {
+				h = h.Right
+			}
+		}
+	}
+	t.Size++
+}
+
+//搜索
+func (t *Tree) Search(i ElementType) *Node {
+	h := t.Head
+	n := NewNode(i)
+	for h != nil {
+		switch h.Compare(n) {
+		case -1:
+			h = h.Right
+		case 1:
+			h = h.Left
+		case 0:
+			return h
+		default:
+			panic("Node not found")
+		}
+	}
+	panic("Node not found")
+}
+
+//删除
+func (t *Tree) Delete(i ElementType) bool {
+	var parent *Node
+
+	h := t.Head
+	n := NewNode(i)
+
+	for h != nil {
+		switch n.Compare(h) {
+		case -1:
+			parent = h
+			h = h.Left
+		case 1:
+			parent = h
+			h = h.Right
+		case 0:
+			if h.Left != nil {
+				right := h.Right
+				h.Value = h.Left.Value
+				h.Left = h.Left.Left
+				h.Right = h.Left.Right
+
+				if right != nil {
+					subTree := &Tree{Head: h}
+					IterOnTree(right, func(n *Node) {
+						subTree.Insert(n.Value)
+					})
+				}
+				t.Size--
+				return true
+			}
+
+			if h.Right != nil {
+				h.Value = h.Right.Value
+				h.Left = h.Right.Left
+				h.Right = h.Right.Right
+
+				t.Size--
+				return true
+			}
+
+			if parent == nil {
+				t.Head = nil
+				t.Size--
+				return true
+			}
+
+			if parent.Left == n {
+				parent.Left = nil
+			} else {
+				parent.Right = nil
+			}
+			t.Size--
+			return true
+		}
+	}
+	return false
+}
+
+func IterOnTree(n *Node, f func(*Node)) bool {
+	if n == nil {
+		return true
+	}
+	if !IterOnTree(n.Left, f) {
+		return false
+	}
+
+	f(n)
+
+	return IterOnTree(n.Right, f)
+}

data-structures/binaryTree/bst_test.go

@@ -0,0 +1,29 @@
+package binaryTree
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+
+func TestNode_Compare(t *testing.T) {
+	n := NewNode(1)
+	m := NewNode(2)
+	k := NewNode(1)
+	assert.Equal(t,-1,n.Compare(m))
+	assert.Equal(t,0,n.Compare(k))
+	assert.Equal(t,1,m.Compare(k))
+}
+
+func TestTree(t *testing.T) {
+	max_size := 10
+	tree := NewTree(nil)
+	for i := 0; i < max_size ; i++  {
+		tree.Insert(ElementType(i))
+	}
+	assert.Equal(t,10,tree.Size)
+	assert.Equal(t,ElementType(5),tree.Search(5).Value)
+	assert.Equal(t,true,tree.Delete(5))
+	assert.Equal(t,9,tree.Size)
+
+}