quick sort

Author: xiaomeng79

algorithms/graphs/dijkstra/dijkstra.go

@@ -0,0 +1,44 @@
+package dijkstra
+
+import (
+	"github.com/xiaomeng79/go-algorithm/data-structures/graph"
+	"github.com/xiaomeng79/go-algorithm/data-structures/priority_queue"
+)
+
+//迪杰斯特拉算法计算的是从网中一个顶点到其它顶点之间的最短路径问题
+//http://data.biancheng.net/view/46.html
+
+func ShortestPath(g *graph.UnGraph, source graph.VertexId) map[graph.VertexId]graph.VertexId {
+	visited := make(map[graph.VertexId]bool, g.VerticesCount())
+	dist := make(map[graph.VertexId]int)
+	prev := make(map[graph.VertexId]graph.VertexId)
+	Q := priority_queue.NewMin()
+	vertices := g.VerticesIter()
+
+	dist[source] = 0
+	for vertex := range vertices {
+		if source != vertex {
+			dist[vertex] = 1000
+			prev[vertex] = 0
+		}
+		Q.Insert(*priority_queue.NewItem(vertex, dist[vertex]))
+	}
+
+	for Q.Len() > 0 {
+		u := Q.Extract().Value.(graph.VertexId)
+		visited[u] = true
+
+		for neighbour := range g.GetNeighbours(u).VerticesIter() {
+			if !visited[neighbour] {
+				alt := dist[u] + g.GetEdgeWeight(u, neighbour)
+
+				if alt < dist[neighbour] {
+					dist[neighbour] = alt
+					prev[neighbour] = u
+					Q.ChangePriority(neighbour, alt)
+				}
+			}
+		}
+	}
+	return prev
+}

algorithms/graphs/dijkstra/dijkstra_test.go

@@ -0,0 +1,34 @@
+package dijkstra
+
+import (
+	"fmt"
+	"github.com/xiaomeng79/go-algorithm/data-structures/graph"
+	"testing"
+)
+
+func TestShortestPath(t *testing.T) {
+	h := graph.NewUndirected()
+
+	for i := 0; i < 5; i++ {
+		h.AddVertex(graph.VertexId(i))
+	}
+
+	h.AddEdge(graph.VertexId(0), graph.VertexId(1), 10)
+	h.AddEdge(graph.VertexId(1), graph.VertexId(2), 20)
+	h.AddEdge(graph.VertexId(2), graph.VertexId(3), 40)
+	h.AddEdge(graph.VertexId(0), graph.VertexId(2), 50)
+	h.AddEdge(graph.VertexId(0), graph.VertexId(3), 80)
+	h.AddEdge(graph.VertexId(0), graph.VertexId(4), 10)
+	h.AddEdge(graph.VertexId(4), graph.VertexId(3), 10)
+
+	prev := ShortestPath(h, graph.VertexId(0))
+	fmt.Println(prev)
+	if prev[1] != graph.VertexId(0) ||
+		prev[2] != graph.VertexId(1) ||
+		prev[3] != graph.VertexId(4) ||
+		prev[4] != graph.VertexId(0) {
+
+		fmt.Println(prev)
+		t.Error()
+	}
+}

algorithms/graphs/topological/topological.go

@@ -0,0 +1,50 @@
+package topological
+
+import (
+	"github.com/xiaomeng79/go-algorithm/data-structures/graph"
+	"github.com/xiaomeng79/go-algorithm/data-structures/stack"
+)
+
+//拓扑排序指的是将有向无环图（又称“DAG”图）中的顶点按照图中指定的先后顺序进行排序。
+
+//拓扑排序实质上就是一种偏序到全序的排序算法
+
+//应用场景:排课问题，课程有依赖关系
+
+//对有向无环图进行拓扑排序，只需要遵循两个原则：
+//在图中选择一个没有前驱的顶点 V；
+//从图中删除顶点 V 和所有以该顶点为尾的弧。
+
+func Sort(g *graph.DirGraph) *stack.Stack {
+	var visit func(v graph.VertexId)
+	sorted := stack.New()
+	visited := make(map[graph.VertexId]bool)
+	marked := make(map[graph.VertexId]bool)
+
+	visit = func(v graph.VertexId) {
+		//判断是不是一个无环图
+		if marked[v] {
+			panic("not a DAG")
+		}
+		marked[v] = true
+		//获取出度的顶点
+		successors := g.GetSuccessors(v).VerticesIter()
+		for successor := range successors {
+			if !marked[successor] && !visited[successor] {
+				visit(successor)
+			}
+		}
+		visited[v] = true
+		marked[v] = false
+		sorted.Push(int(v))
+	}
+
+	vertices := g.VerticesIter()
+	for vertex := range vertices {
+		if !visited[vertex] {
+			visit(vertex)
+		}
+	}
+
+	return sorted
+}

algorithms/graphs/topological/topological_test.go

@@ -0,0 +1,41 @@
+package topological
+
+import (
+	"fmt"
+	"github.com/xiaomeng79/go-algorithm/data-structures/graph"
+	"testing"
+)
+
+func TestSort(t *testing.T) {
+	h := graph.NewDirected()
+
+	h.AddVertex(graph.VertexId(2))
+	h.AddVertex(graph.VertexId(3))
+	h.AddVertex(graph.VertexId(5))
+	h.AddVertex(graph.VertexId(7))
+	h.AddVertex(graph.VertexId(8))
+	h.AddVertex(graph.VertexId(9))
+	h.AddVertex(graph.VertexId(10))
+	h.AddVertex(graph.VertexId(11))
+
+	h.AddEdge(graph.VertexId(7), graph.VertexId(8), 1)
+	h.AddEdge(graph.VertexId(7), graph.VertexId(11), 1)
+	h.AddEdge(graph.VertexId(5), graph.VertexId(11), 1)
+	h.AddEdge(graph.VertexId(3), graph.VertexId(8), 1)
+	h.AddEdge(graph.VertexId(3), graph.VertexId(10), 1)
+	h.AddEdge(graph.VertexId(8), graph.VertexId(9), 1)
+	h.AddEdge(graph.VertexId(11), graph.VertexId(10), 1)
+	h.AddEdge(graph.VertexId(11), graph.VertexId(2), 1)
+	h.AddEdge(graph.VertexId(11), graph.VertexId(9), 1)
+
+	s := Sort(h)
+	i, _ := s.Pop()
+	first := graph.VertexId(i)
+	if first != 7 &&
+		first != 5 &&
+		first != 3 {
+		fmt.Print(first, first != 7)
+		t.Error()
+	}
+
+}

algorithms/sort/README.md

@@ -10,4 +10,6 @@
 排序则必有先后大小高低，基本操作是：将元素通过比较来调整位置。
 
 排序本质是消除逆序。采用“交换相邻元素”的办法来消除逆序，每次正好只消除一个，因此必须执行O(N^2)的交换次数。
-基于交换元素的排序要想突破这个下界，必须执行一些比较，交换相隔比较远的元素，使得一次交换能消除一个以上的逆序。这样才能降低时间复杂度。
+基于交换元素的排序要想突破这个下界，必须执行一些比较，交换相隔比较远的元素，使得一次交换能消除一个以上的逆序。这样才能降低时间复杂度。
+
+![时间复杂度](https://github.com/hustcc/JS-Sorting-Algorithm/raw/master/res/sort.png)

algorithms/sort/bubble/bubble.go

@@ -9,14 +9,32 @@ package bubble
 //3. 针对所有的元素重复以上的步骤，除了最后一个。
 //4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
 
-func BubbleSort(arr []int) []int {
-	length := len(arr)            //获取最大长度
-	for i := 0; i < length; i++ { //比较次数
-		for j := 0; j < length-1-i; j++ { //比较长度
-			if arr[j] > arr[j+1] {
-				arr[j], arr[j+1] = arr[j+1], arr[j]
+//时间复杂度:O(n²)
+
+//推荐
+func BubbleSort(arr []int) {
+	for itemCount := len(arr) - 1; ; itemCount-- {
+		swap := false //下一次判断是否发生交换，没交换，说明已经有序
+		for i := 1; i <= itemCount; i++ {
+			if arr[i-1] > arr[i] {
+				arr[i-1], arr[i] = arr[i], arr[i-1]
+				swap = true
 			}
 		}
+		if swap == false {
+			break
+		}
 	}
-	return arr
 }
+
+//func BubbleSort(arr []int) []int {
+//	length := len(arr)            //获取最大长度
+//	for i := 0; i < length; i++ { //比较次数
+//		for j := 0; j < length-1-i; j++ { //比较长度
+//			if arr[j] > arr[j+1] {
+//				arr[j], arr[j+1] = arr[j+1], arr[j]
+//			}
+//		}
+//	}
+//	return arr
+//}

algorithms/sort/bubble/bubble_test.go

@@ -9,7 +9,8 @@ import (
 
 func TestBubbleSort(t *testing.T) {
 	for _, v := range testdata.Values {
-		assert.Exactly(t, v.Sort, BubbleSort(v.Nosort), "no eq")
+		BubbleSort(v.Nosort)
+		assert.Exactly(t, v.Sort, v.Nosort, "no eq")
 	}
 }
 

algorithms/sort/heap/heap.go

@@ -0,0 +1,18 @@
+package heap
+
+import "github.com/xiaomeng79/go-algorithm/data-structures/heap"
+
+//堆排序（Heapsort）是指利用堆这种数据结构所设计的一种排序算法
+//堆排序的平均时间复杂度为 Ο(nlogn)
+
+func HeapSort(arr []int) []int {
+	h := heap.NewMin()
+	for i := 0; i < len(arr); i++ {
+		h.Insert(heap.Int(arr[i]))
+	}
+
+	for i := 0; i < len(arr); i++ {
+		arr[i] = int(h.Extract().(heap.Int))
+	}
+	return arr
+}

algorithms/sort/heap/heap_test.go

@@ -0,0 +1,30 @@
+package heap
+
+import (
+	"github.com/stretchr/testify/assert"
+	"github.com/xiaomeng79/go-algorithm/algorithms/sort/testdata"
+	"github.com/xiaomeng79/go-algorithm/algorithms/sort/utils"
+	"testing"
+)
+
+func TestHeapSort(t *testing.T) {
+	for _, v := range testdata.Values {
+		assert.Exactly(t, v.Sort, HeapSort(v.Nosort), "no eq")
+	}
+}
+
+func benchmarkHeapSort(n int, b *testing.B) {
+	b.StopTimer()
+	list := utils.GetArrayOfSize(n)
+	b.ReportAllocs()
+	b.StartTimer()
+	for i := 0; i < b.N; i++ {
+		HeapSort(list)
+	}
+}
+
+func BenchmarkHeapSort100(b *testing.B)   { benchmarkHeapSort(100, b) }
+func BenchmarkHeapSort1000(b *testing.B)  { benchmarkHeapSort(1000, b) }
+func BenchmarkHeapSort10000(b *testing.B) { benchmarkHeapSort(10000, b) }
+
+//func BenchmarkHeapSort100000(b *testing.B) { benchmarkHeapSort(100000, b) }

algorithms/sort/quick/quick.go

@@ -0,0 +1,44 @@
+package quick
+
+//快速排序:快速排序应该算是在冒泡排序基础上的递归分治法
+
+//算法步骤:
+//从数列中挑出一个元素，称为 “基准”（pivot）;
+//
+//重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区退出之后，该基准就处于数列的中间位置。这个称为分区（partition）操作；
+//
+//递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序；
+//
+//递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
+
+func QuickSort(arr []int) []int {
+	return quickSort(arr, 0, len(arr)-1)
+}
+
+func quickSort(arr []int, left, right int) []int {
+	if left < right {
+		partitionIndex := partition(arr, left, right)
+		quickSort(arr, left, partitionIndex-1)
+		quickSort(arr, partitionIndex+1, right)
+	}
+	return arr
+}
+
+func partition(arr []int, left, right int) int {
+	pivot := left
+	index := pivot + 1
+
+	for i := index; i <= right; i++ {
+		if arr[i] < arr[pivot] {
+			swap(arr, i, index)
+			index += 1
+		}
+	}
+	swap(arr, pivot, index-1)
+	return index - 1
+
+}
+
+func swap(arr []int, i, j int) {
+	arr[i], arr[j] = arr[j], arr[i]
+}