queue

Author: xiaomeng79

Makefile

@@ -0,0 +1,16 @@
+#
+
+.PHONY : build
+build : fmt test
+	@echo "可以提交"
+
+.PHONY : fmt
+fmt :
+	@echo "格式化代码"
+	@gofmt -l -w ./
+
+
+.PHONY : test
+test :
+	@echo "测试代码"
+	go test -v ./...

data-structures/binaryTree/bst.go

@@ -2,18 +2,18 @@ package binaryTree
 
 //二叉树
 //二叉树是每个节点最多有两个子树的树结构
-type ElementType int//节点数据
+type ElementType int //节点数据
 //结点
 type Node struct {
-	Value ElementType
+	Value  ElementType
 	Parent *Node
-	Left *Node
-	Right *Node
+	Left   *Node
+	Right  *Node
 }
 
 //创建节点
 func NewNode(v ElementType) *Node {
-	return &Node{Value:v}
+	return &Node{Value: v}
 }
 
 /*
@@ -41,13 +41,13 @@ func NewTree(n *Node) *Tree {
 	if n == nil {
 		return &Tree{}
 	}
-	return &Tree{Head:n,Size:1}
+	return &Tree{Head: n, Size: 1}
 }
 
 //插入,相同的节点值，放到右子树
 func (t *Tree) Insert(i ElementType) {
-	n := NewNode(i)//创建节点
-	if t.Head == nil {//判断树的根节点
+	n := NewNode(i)    //创建节点
+	if t.Head == nil { //判断树的根节点
 		t.Head = n
 		t.Size++
 		return
@@ -56,15 +56,15 @@ func (t *Tree) Insert(i ElementType) {
 	h := t.Head
 
 	for {
-		if n.Compare(h) == -1 {//小于parent，到左子节点
-			if h.Left == nil {//无左子节点
+		if n.Compare(h) == -1 { //小于parent，到左子节点
+			if h.Left == nil { //无左子节点
 				h.Left = n
 				n.Parent = h
 				break
 			} else {
 				h = h.Left
 			}
-		} else {//大于parent
+		} else { //大于parent
 			if h.Right == nil {
 				h.Right = n
 				n.Parent = h
@@ -166,4 +166,4 @@ func IterOnTree(n *Node, f func(*Node)) bool {
 	f(n)
 
 	return IterOnTree(n.Right, f)
-}
+}

data-structures/binaryTree/bst_test.go

@@ -5,25 +5,25 @@ import (
 	"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))
+
+	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++  {
+	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)
+	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)
 
 }

data-structures/queue/list_queue.go

@@ -0,0 +1,29 @@
+package queue
+
+import "container/list"
+
+//使用go标准库的list实现
+type ListQueue struct {
+	l *list.List
+}
+
+func NewListQueue() *ListQueue {
+	l := list.New()
+	return &ListQueue{l}
+}
+
+func (lq *ListQueue) Shift() (el interface{}) {
+	e := lq.l.Front()
+	el = e.Value
+	lq.l.Remove(e)
+	return
+}
+
+func (lq *ListQueue) Push(el interface{}) {
+	lq.l.PushBack(el)
+	return
+}
+
+func (lq *ListQueue) Len() int {
+	return lq.l.Len()
+}

data-structures/queue/queue.go

@@ -0,0 +1,45 @@
+package queue
+
+import "sync"
+
+type Queue struct {
+	queue []interface{}
+	len   int
+	lock  *sync.Mutex
+}
+
+func New() *Queue {
+	q := &Queue{}
+	q.queue = make([]interface{}, 0)
+	q.len = 0
+	q.lock = new(sync.Mutex)
+	return q
+}
+
+func (q *Queue) Len() int {
+	return q.len
+}
+
+func (q *Queue) isEmpty() bool {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+	return q.len == 0
+}
+
+func (q *Queue) Shift() (el interface{}) {
+	el, q.queue = q.queue[0], q.queue[1:]
+	q.len--
+	return
+}
+
+func (q *Queue) Push(el interface{}) {
+	q.queue = append(q.queue, el)
+	q.len++
+	return
+}
+
+func (q *Queue) Peek() (el interface{}) {
+	q.lock.Lock()
+	defer q.lock.Unlock()
+	return q.queue[0]
+}

data-structures/queue/queue_test.go

@@ -0,0 +1,32 @@
+package queue
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+)
+
+func TestNew(t *testing.T) {
+	queue := New()
+	assert.Equal(t, true, queue.isEmpty())
+	queue.Push(1)
+	queue.Push(2)
+	queue.Push(3)
+	assert.Equal(t, 3, queue.Len())
+	assert.Equal(t, 1, queue.Shift().(int))
+	assert.Equal(t, 2, queue.Shift().(int))
+	assert.Equal(t, 3, queue.Peek().(int))
+	assert.Equal(t, 3, queue.Shift().(int))
+
+}
+
+func TestNewListQueue(t *testing.T) {
+	queue := NewListQueue()
+	queue.Push(1)
+	queue.Push(2)
+	queue.Push(3)
+	assert.Equal(t, 3, queue.Len())
+	assert.Equal(t, 1, queue.Shift().(int))
+	assert.Equal(t, 2, queue.Shift().(int))
+	assert.Equal(t, 3, queue.Shift().(int))
+	assert.Equal(t, 0, queue.Len())
+}

data-structures/stack/stack.go

@@ -0,0 +1 @@
+package stack

data-structures/stack/stack_test.go

@@ -0,0 +1 @@
+package stack

sort/bubble/bubble_test.go

@@ -2,29 +2,28 @@ package bubble
 
 import (
 	"github.com/stretchr/testify/assert"
-	"testing"
 	"github.com/xiaomeng79/go-algorithm/sort/testdata"
 	"github.com/xiaomeng79/go-algorithm/sort/utils"
+	"testing"
 )
 
-
 func TestBubbleSort(t *testing.T) {
 	for _, v := range testdata.Values {
 		assert.Exactly(t, v.Sort, BubbleSort(v.Nosort), "no eq")
 	}
 }
 
-func benchmarkBubbleSort(n int,b *testing.B) {
+func benchmarkBubbleSort(n int, b *testing.B) {
 	b.StopTimer()
 	list := utils.GetArrayOfSize(n)
 	b.ReportAllocs()
 	b.StartTimer()
-	for i:=0;i < b.N;i++ {
+	for i := 0; i < b.N; i++ {
 		BubbleSort(list)
 	}
 }
 
-func BenchmarkBubbleSort100(b *testing.B) { benchmarkBubbleSort(100, b) }
+func BenchmarkBubbleSort100(b *testing.B)    { benchmarkBubbleSort(100, b) }
 func BenchmarkBubbleSort1000(b *testing.B)   { benchmarkBubbleSort(1000, b) }
 func BenchmarkBubbleSort10000(b *testing.B)  { benchmarkBubbleSort(10000, b) }
 func BenchmarkBubbleSort100000(b *testing.B) { benchmarkBubbleSort(100000, b) }

sort/insertion/insertion.go

@@ -29,13 +29,13 @@ func InsertionSort2(arr []int) []int {
 
 	for i := 1; i < length; i++ {
 		backup := arr[i]
-		j := i -1;
+		j := i - 1
 		//将选出的被排数比较后插入左边有序区
-		for  j >= 0 && backup < arr[j] {//注意j >= 0必须在前边，否则会数组越界
-			arr[j+1] = arr[j]//移动有序数组
-			j -- //反向移动下标
+		for j >= 0 && backup < arr[j] { //注意j >= 0必须在前边，否则会数组越界
+			arr[j+1] = arr[j] //移动有序数组
+			j--               //反向移动下标
 		}
-		arr[j + 1] = backup //插队插入移动后的空位
+		arr[j+1] = backup //插队插入移动后的空位
 	}
 	return arr
 }

sort/insertion/insertion_test.go

@@ -2,30 +2,28 @@ package insertion
 
 import (
 	"github.com/stretchr/testify/assert"
-	"testing"
 	"github.com/xiaomeng79/go-algorithm/sort/testdata"
 	"github.com/xiaomeng79/go-algorithm/sort/utils"
+	"testing"
 )
 
-
 func TestInsertionSort(t *testing.T) {
 	for _, v := range testdata.Values {
 		assert.Exactly(t, v.Sort, InsertionSort(v.Nosort), "no eq")
 	}
 }
 
-func benchmarkInsertionSort(n int,b *testing.B) {
+func benchmarkInsertionSort(n int, b *testing.B) {
 	b.StopTimer()
 	list := utils.GetArrayOfSize(n)
 	b.ReportAllocs()
 	b.StartTimer()
-	for i:=0;i < b.N;i++ {
+	for i := 0; i < b.N; i++ {
 		InsertionSort(list)
 	}
 }
 
-func BenchmarkInsertionSort100(b *testing.B) { benchmarkInsertionSort(100, b) }
+func BenchmarkInsertionSort100(b *testing.B)    { benchmarkInsertionSort(100, b) }
 func BenchmarkInsertionSort1000(b *testing.B)   { benchmarkInsertionSort(1000, b) }
 func BenchmarkInsertionSort10000(b *testing.B)  { benchmarkInsertionSort(10000, b) }
 func BenchmarkInsertionSort100000(b *testing.B) { benchmarkInsertionSort(100000, b) }
-

sort/selection/selection.go

@@ -11,18 +11,15 @@ package selection
 
 func SelectionSort(arr []int) []int {
 	length := len(arr)
-	for i:= 0;i < length-1;i++ {//注意这里使用length-1少一次，
+	for i := 0; i < length-1; i++ { //注意这里使用length-1少一次，
 		minIndex := i
-		for j:= i+1;j<length;j++ {
+		for j := i + 1; j < length; j++ {
 			if arr[j] < arr[minIndex] {
 				minIndex = j
 			}
 		}
 		//
-		arr[minIndex],arr[i] = arr[i],arr[minIndex]
+		arr[minIndex], arr[i] = arr[i], arr[minIndex]
 	}
 	return arr
 }
-
-
-

sort/selection/selection_test.go

@@ -1,10 +1,10 @@
 package selection
 
 import (
-	"testing"
 	"github.com/stretchr/testify/assert"
 	"github.com/xiaomeng79/go-algorithm/sort/testdata"
 	"github.com/xiaomeng79/go-algorithm/sort/utils"
+	"testing"
 )
 
 func TestSelectionSort(t *testing.T) {
@@ -13,20 +13,17 @@ func TestSelectionSort(t *testing.T) {
 	}
 }
 
-
-func benchmarkSelectionSort(n int,b *testing.B) {
+func benchmarkSelectionSort(n int, b *testing.B) {
 	b.StopTimer()
 	list := utils.GetArrayOfSize(n)
 	b.ReportAllocs()
 	b.StartTimer()
-	for i:=0;i < b.N;i++ {
+	for i := 0; i < b.N; i++ {
 		SelectionSort(list)
 	}
 }
 
-
-func BenchmarkSelectionSort100(b *testing.B) { benchmarkSelectionSort(100, b) }
+func BenchmarkSelectionSort100(b *testing.B)    { benchmarkSelectionSort(100, b) }
 func BenchmarkSelectionSort1000(b *testing.B)   { benchmarkSelectionSort(1000, b) }
 func BenchmarkSelectionSort10000(b *testing.B)  { benchmarkSelectionSort(10000, b) }
 func BenchmarkSelectionSort100000(b *testing.B) { benchmarkSelectionSort(100000, b) }
-