init commit

archive/algorithm/geektime/c/06.c

@@ -0,0 +1,139 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <memory.h>
+
+struct node;
+typedef struct node Node;
+
+struct node
+{
+    int val;
+    Node *next;
+};
+
+void insert(Node *header, int val, int pos)
+{
+    Node *tmp = header;
+    int tmpPos = 0;
+    if (pos == -1)
+    {
+        pos = __INT_MAX__;
+    }
+
+    while (tmp->next != NULL && tmpPos < pos)
+    {
+        tmpPos++;
+        tmp = tmp->next;
+    }
+    Node *i = malloc(sizeof(Node));
+    i->next = tmp->next;
+    i->val = val;
+    tmp->next = i;
+}
+
+void delete (Node *header, int pos)
+{
+    Node *tmp = header;
+    int tmpPos = 0;
+    while (tmp->next != NULL && tmpPos < pos)
+    {
+        tmpPos++;
+        tmp = tmp->next;
+    }
+    Node *del = tmp->next;
+    if (del == NULL)
+    {
+        return;
+    }
+    tmp->next = tmp->next->next;
+}
+
+Node *reverse(Node *header)
+{
+    Node *last = NULL;
+    Node *tmp = header;
+    while (tmp = tmp->next)
+    {
+        Node *now = malloc(sizeof(Node));
+        memset(now, 0, sizeof(Node));
+        now->val = tmp->val;
+        now->next = last;
+        last = now;
+    }
+    Node *newHeader = malloc(sizeof(Node));
+    memset(newHeader, 0, sizeof(Node));
+    newHeader->next = last;
+    return newHeader;
+}
+
+int isRing(Node *header)
+{
+    if (header == NULL)
+    {
+        return 0;
+    }
+    Node *k = header, *m = header;
+    do
+    {
+        if (k->next == NULL)
+        {
+            return 0;
+        }
+        k = k->next;
+        if (k->next == NULL)
+        {
+            return 0;
+        }
+        k = k->next;
+        m = m->next;
+    } while (m != k);
+    return 1;
+}
+
+int main()
+{
+    Node *header = malloc(sizeof(Node));
+    header->val = -1;
+    header->next = NULL;
+
+    insert(header, 1, -1);
+    insert(header, 2, -1);
+    insert(header, 3, -1);
+    insert(header, 4, 2);
+    insert(header, 5, 0);
+    insert(header, 6, 0);
+
+    delete (header, 0);
+    Node *tmp = header;
+    while (tmp = tmp->next)
+    {
+        printf("%d\t", tmp->val);
+    }
+
+    Node *header2 = malloc(sizeof(Node));
+    header2->val = -1;
+    header2->next = NULL;
+    insert(header2, 10, -1);
+    insert(header2, 12, -1);
+    delete (header2, 0);
+    tmp = header2;
+    printf("\nheader2\n");
+    while (tmp = tmp->next)
+    {
+        printf("%d\t", tmp->val);
+    }
+
+    Node *r = reverse(header);
+    tmp = r;
+    printf("\reverse\n");
+    while (tmp = tmp->next)
+    {
+        printf("%d\t", tmp->val);
+    }
+
+    printf("\n%d\n", isRing(header));
+    header->next->next->next->next->next = header->next->next;
+    printf("\n%d\n", isRing(header));
+
+    return 0;
+}

archive/algorithm/geektime/sort.go

@@ -0,0 +1,151 @@
+package geektime
+
+func bubble_1(arr []int) []int {
+	ret := make([]int, len(arr))
+	copy(ret, arr)
+	for i := range ret {
+		for j := range ret[i:] {
+			j = i + j
+			if ret[i] > ret[j] {
+				ret[i], ret[j] = ret[j], ret[i]
+			}
+		}
+	}
+	return ret
+}
+
+func bubble_2(arr []int) []int {
+	ret := make([]int, len(arr))
+	copy(ret, arr)
+	for i := range ret {
+		flag := false
+		for j := range ret[i:] {
+			j = i + j
+			if ret[i] > ret[j] {
+				flag = true
+				ret[i], ret[j] = ret[j], ret[i]
+			}
+		}
+		if !flag {
+			break
+		}
+	}
+	return ret
+}
+
+func insert(arr []int) []int {
+	ret := make([]int, len(arr))
+	copy(ret, arr)
+	for i := 1; i < len(ret); i++ {
+		val := ret[i]
+		j := i - 1
+		for ; j >= 0; j-- {
+			if ret[j] > val {
+				ret[j+1] = ret[j]
+			} else {
+				break
+			}
+		}
+		ret[j+1] = val
+	}
+	return ret
+}
+
+func selection(arr []int) []int {
+	ret := make([]int, len(arr))
+	copy(ret, arr)
+	for i := range ret {
+		min := i
+		for j := range ret[i:] {
+			j = i + j
+			if ret[min] > ret[j] {
+				min = j
+			}
+		}
+		ret[min], ret[i] = ret[i], ret[min]
+	}
+	return ret
+}
+
+//归并排序
+func merge_sort(arr []int) []int {
+	ret := make([]int, len(arr))
+	copy(ret, arr)
+	dichotomize(ret, 0, len(ret)-1)
+	return ret
+}
+
+func dichotomize(arr []int, i, j int) (int, int) {
+	if i >= j {
+		return i, j
+	}
+	i1, j1 := dichotomize(arr, i, (j-i)/2+i)
+	i2, j2 := dichotomize(arr, (j-i)/2+i+1, j)
+	merge(arr, i1, j1, i2, j2)
+	return i, j
+}
+
+func merge(arr []int, i1, j1, i2, j2 int) {
+	pos2 := i2
+	tmp := make([]int, j2-i1+1)
+	tmppos := 0
+	pos1 := i1
+	for ; pos1 <= j1 && pos2 <= j2; tmppos++ {
+		if arr[pos1] > arr[pos2] {
+			tmp[tmppos] = arr[pos2]
+			pos2++
+		} else {
+			tmp[tmppos] = arr[pos1]
+			pos1++
+		}
+	}
+	//剩余
+	if pos1 <= j1 {
+		for ; pos1 <= j1; pos1++ {
+			tmp[tmppos] = arr[pos1]
+			tmppos++
+		}
+	} else {
+		for ; pos2 <= j2; pos2++ {
+			tmp[tmppos] = arr[pos2]
+			tmppos++
+		}
+	}
+	//copy
+	tmppos = 0
+	for i := i1; i <= j2; i++ {
+		arr[i] = tmp[tmppos]
+		tmppos++
+	}
+}
+
+func qsort(arr []int) []int {
+	ret := make([]int, len(arr))
+	copy(ret, arr)
+	return qsort_c(ret)
+}
+
+func qsort_c(arr []int) []int {
+	n := len(arr)
+	if n == 2 {
+		if arr[0] > arr[1] {
+			arr[0], arr[1] = arr[1], arr[0]
+			return arr
+		}
+		return arr
+	} else if n <= 1 {
+		return arr
+	}
+	val := arr[n/2]
+	arr[0], arr[n/2] = arr[n/2], arr[0]
+	j := 1
+	for i := 1; i < n; i++ {
+		if arr[i] < val {
+			arr[i], arr[j] = arr[j], arr[i]
+			j++
+		}
+	}
+	qsort_c(arr[:j])
+	qsort_c(arr[j:])
+	return arr
+}

archive/algorithm/geektime/sort_test.go

@@ -0,0 +1,159 @@
+package geektime
+
+import (
+	"github.com/stretchr/testify/assert"
+	"math/rand"
+	"testing"
+)
+
+var sortArr100, sortArr1000 []int
+
+func TestMain(m *testing.M) {
+	sortArr100 = randIntSlice(100)
+	sortArr1000 = randIntSlice(1000)
+	m.Run()
+}
+
+func Test_bubble(t *testing.T) {
+	arr := []int{5, 3, 4, 1, 2}
+	ret := bubble_1(arr)
+	assert.Equal(t, []int{1, 2, 3, 4, 5}, ret)
+	ret = bubble_2(arr)
+	assert.Equal(t, []int{1, 2, 3, 4, 5}, ret)
+	arr = randIntSlice(10)
+	ret = bubble_1(arr)
+	ret2 := bubble_2(arr)
+	assert.Equal(t, ret2, ret)
+}
+
+func randIntSlice(n int) []int {
+	ret := make([]int, n)
+	for i := 0; i < n; i++ {
+		ret[i] = rand.Int()
+	}
+	return ret
+}
+
+func BenchmarkBubble1100(b *testing.B) {
+	arr := sortArr100
+	for i := 0; i < b.N; i++ {
+		bubble_1(arr)
+	}
+}
+
+func BenchmarkBubble11000(b *testing.B) {
+	arr := sortArr1000
+	for i := 0; i < b.N; i++ {
+		bubble_1(arr)
+	}
+}
+
+func BenchmarkBubble2100(b *testing.B) {
+	arr := sortArr100
+	for i := 0; i < b.N; i++ {
+		bubble_2(arr)
+	}
+}
+
+func BenchmarkBubble21000(b *testing.B) {
+	arr := sortArr1000
+	for i := 0; i < b.N; i++ {
+		bubble_2(arr)
+	}
+}
+
+func Test_insert(t *testing.T) {
+	arr := []int{5, 3, 4, 1, 2}
+	ret := insert(arr)
+	assert.Equal(t, []int{1, 2, 3, 4, 5}, ret)
+	arr = randIntSlice(10)
+	ret = bubble_1(arr)
+	ret2 := insert(arr)
+	assert.Equal(t, ret, ret2)
+}
+
+func BenchmarkInsert100(b *testing.B) {
+	arr := sortArr100
+	for i := 0; i < b.N; i++ {
+		insert(arr)
+	}
+}
+
+func BenchmarkInsert1000(b *testing.B) {
+	arr := sortArr1000
+	for i := 0; i < b.N; i++ {
+		insert(arr)
+	}
+}
+
+func Test_selection(t *testing.T) {
+	arr := []int{5, 3, 4, 1, 2}
+	ret := selection(arr)
+	assert.Equal(t, []int{1, 2, 3, 4, 5}, ret)
+	arr = randIntSlice(10)
+	ret = bubble_1(arr)
+	ret2 := selection(arr)
+	assert.Equal(t, ret, ret2)
+}
+
+func BenchmarkSelect100(b *testing.B) {
+	arr := sortArr100
+	for i := 0; i < b.N; i++ {
+		selection(arr)
+	}
+}
+
+func BenchmarkSelect1000(b *testing.B) {
+	arr := sortArr1000
+	for i := 0; i < b.N; i++ {
+		selection(arr)
+	}
+}
+
+func Test_merge_sort(t *testing.T) {
+	arr := []int{5, 3, 4, 1, 2, 6}
+	ret := merge_sort(arr)
+	assert.Equal(t, []int{1, 2, 3, 4, 5, 6}, ret)
+	arr = randIntSlice(10)
+	ret = bubble_1(arr)
+	ret2 := merge_sort(arr)
+	assert.Equal(t, ret, ret2)
+}
+
+func BenchmarkMerge100(b *testing.B) {
+	arr := sortArr100
+	for i := 0; i < b.N; i++ {
+		merge_sort(arr)
+	}
+}
+
+func BenchmarkMerge1000(b *testing.B) {
+	arr := sortArr1000
+	for i := 0; i < b.N; i++ {
+		merge_sort(arr)
+	}
+}
+
+func Test_qsort(t *testing.T) {
+	arr := []int{5, 3, 4, 1, 2, 6}
+	ret := qsort(arr)
+	assert.Equal(t, []int{1, 2, 3, 4, 5, 6}, ret)
+	arr = randIntSlice(10)
+	ret = bubble_1(arr)
+	ret2 := qsort(arr)
+	assert.Equal(t, ret, ret2)
+}
+
+func BenchmarkQuickSort100(b *testing.B) {
+	arr := sortArr100
+	for i := 0; i < b.N; i++ {
+		qsort(arr)
+	}
+}
+
+func BenchmarkQuickSort1000(b *testing.B) {
+	arr := sortArr1000
+	for i := 0; i < b.N; i++ {
+		qsort(arr)
+	}
+}