希尔排序

Author: xiaomeng79

bubble/bubble_test.go

@@ -0,0 +1,13 @@
+排序：
+将多个元素按照一定规则的顺序进行排列。
+
+如：
+数值排序
+字母排序
+优先级排序
+
+分析：
+排序则必有先后大小高低，基本操作是：将元素通过比较来调整位置。
+
+排序本质是消除逆序。采用“交换相邻元素”的办法来消除逆序，每次正好只消除一个，因此必须执行O(N^2)的交换次数。
+基于交换元素的排序要想突破这个下界，必须执行一些比较，交换相隔比较远的元素，使得一次交换能消除一个以上的逆序。这样才能降低时间复杂度。

insertion/insertion_test.go

@@ -0,0 +1,30 @@
+package bubble
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"github.com/xiaomeng79/go-algorithm/sort/testdata"
+	"github.com/xiaomeng79/go-algorithm/sort/utils"
+)
+
+
+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) {
+	b.StopTimer()
+	list := utils.GetArrayOfSize(n)
+	b.ReportAllocs()
+	b.StartTimer()
+	for i:=0;i < b.N;i++ {
+		BubbleSort(list)
+	}
+}
+
+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) }

selection/selection_test.go

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

sort/README.md

@@ -0,0 +1,31 @@
+package insertion
+
+import (
+	"github.com/stretchr/testify/assert"
+	"testing"
+	"github.com/xiaomeng79/go-algorithm/sort/testdata"
+	"github.com/xiaomeng79/go-algorithm/sort/utils"
+)
+
+
+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) {
+	b.StopTimer()
+	list := utils.GetArrayOfSize(n)
+	b.ReportAllocs()
+	b.StartTimer()
+	for i:=0;i < b.N;i++ {
+		InsertionSort(list)
+	}
+}
+
+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) }
+

bubble/bubble.go renamed to sort/bubble/bubble.go

@@ -0,0 +1,32 @@
+package selection
+
+import (
+	"testing"
+	"github.com/stretchr/testify/assert"
+	"github.com/xiaomeng79/go-algorithm/sort/testdata"
+	"github.com/xiaomeng79/go-algorithm/sort/utils"
+)
+
+func TestSelectionSort(t *testing.T) {
+	for _, v := range testdata.Values {
+		assert.Exactly(t, v.Sort, SelectionSort(v.Nosort), "no eq")
+	}
+}
+
+
+func benchmarkSelectionSort(n int,b *testing.B) {
+	b.StopTimer()
+	list := utils.GetArrayOfSize(n)
+	b.ReportAllocs()
+	b.StartTimer()
+	for i:=0;i < b.N;i++ {
+		SelectionSort(list)
+	}
+}
+
+
+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) }
+

sort/bubble/bubble_test.go

@@ -0,0 +1,40 @@
+//希尔排序
+package shell
+
+//原理：也称递减增量排序算法,先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，待整个序列中的记录“基本有序”时，再对全体记录进行依次直接插入排序。
+//稳定性：不稳定
+//比较: 1万以内用插入排序，以上使用希尔排序
+//算法步骤:
+//1. 选择一个增量序列 t1，t2，……，tk，其中 ti > tj, tk = 1；
+//2. 按增量序列个数 k，对序列进行 k 趟排序；
+//3. 每趟排序，根据对应的增量 ti，将待排序列分割成若干长度为 m 的子序列，分别对各子表进行直接插入排序。仅增量因子为 1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。
+
+func ShellSort(arr []int) []int{
+	length := len(arr)
+	//设置增量
+	gap := length/2
+	//结束条件，增量为<=0
+	for gap > 0 {
+		//根据增量，进行分组插入排序
+		for i:=0;i<gap;i++ {
+			insertsort(arr,i,gap)
+		}
+		//分组完，组排序后，重新设置增量
+		gap /= 2
+	}
+	return arr
+}
+
+func insertsort(arr []int,start,gap int) {
+	length := len(arr)
+	for i:=start +gap;i<length;i+=gap {
+		preindex := i-gap
+		cur := arr[i]
+		for preindex >= 0 && cur < arr[preindex] {
+			arr[preindex + gap] = arr[preindex]
+			preindex -= gap
+		}
+		arr[preindex + gap] = cur
+	}
+}
+

insertion/insertion.go renamed to sort/insertion/insertion.go

@@ -0,0 +1,30 @@
+package shell
+
+import (
+	"testing"
+	"github.com/stretchr/testify/assert"
+	"github.com/xiaomeng79/go-algorithm/sort/testdata"
+	"github.com/xiaomeng79/go-algorithm/sort/utils"
+)
+
+func TestShell(t *testing.T) {
+	for _, v := range testdata.Values {
+		assert.Exactly(t, v.Sort, ShellSort(v.Nosort), "no eq")
+	}
+}
+
+
+func benchmarkShellSort(n int,b *testing.B) {
+	b.StopTimer()
+	list := utils.GetArrayOfSize(n)
+	b.ReportAllocs()
+	b.StartTimer()
+	for i:=0;i < b.N;i++ {
+		ShellSort(list)
+	}
+}
+
+func BenchmarkShellSort100(b *testing.B) { benchmarkShellSort(100, b) }
+func BenchmarkShellSort1000(b *testing.B)   { benchmarkShellSort(1000, b) }
+func BenchmarkShellSort10000(b *testing.B)  { benchmarkShellSort(10000, b) }
+func BenchmarkShellSort100000(b *testing.B) { benchmarkShellSort(100000, b) }

sort/insertion/insertion_test.go

@@ -9,5 +9,4 @@ var (
 		{[]int{3}, []int{3}},
 		{[]int{3, -1, -6, 34, -78}, []int{-78, -6, -1, 3, 34}},
 	}
-	Value = []int{3, 44, 56, 38, 77, 38, 26}
 )

selection/selection.go renamed to sort/selection/selection.go

@@ -0,0 +1 @@
+#### 生成随机数

sort/selection/selection_test.go

@@ -0,0 +1,62 @@
+package utils
+
+import (
+	"os"
+	"path/filepath"
+	"bufio"
+	"strconv"
+)
+
+const (
+	File_Name = "../utils/intarray.txt"
+	Num_Vol = 100000
+)
+
+//获取文件绝对路径
+func absPath() string {
+	_fpath,err := filepath.Abs(File_Name)
+	if err != nil{
+		panic(err)
+	}
+	return _fpath
+}
+
+//判断随机数文件是否存在
+func pathExists() bool {
+	_fpath := absPath()
+	_,err := os.Stat(_fpath)
+	if os.IsNotExist(err) {
+		return false
+	}
+	return true
+}
+//生成随机数文件
+func gen() {
+	_fpath := absPath()
+	GenRandFile(Num_Vol,_fpath)
+}
+
+//获取随机数
+func GetArrayOfSize(n int) []int {
+	_fpath := absPath()
+	//判断文件是否存在
+	if !pathExists() {
+		gen()//不存在创建
+	}
+	//存在读取
+	f ,err := os.Open(_fpath)
+	if err != nil {
+		panic(err)
+	}
+	defer f.Close()
+	numbers := make([]int,n)
+	scanner := bufio.NewScanner(f)
+
+	for i:=0;i<n;i++ {
+		scanner.Scan()
+		s,_ := strconv.Atoi(scanner.Text())
+		numbers = append(numbers,s)
+	}
+	return numbers
+}
+