Merge pull request #1 from wangzheng0822/master

同步

Author: Zephylaci

c-cpp/06_linkedlist/single_list.c

@@ -47,7 +47,8 @@ struct single_list* del(struct single_list **prev)
 
 	if (!prev)
 		return NULL;
-
+	if (*prev == null)
+		return NULL;
 	tmp = *prev;
 	*prev = (*prev)->next;
 	tmp->next = NULL;

go/41_dynamic_programming/backtracking/leastcoins.go

@@ -0,0 +1,102 @@
+package backtracking
+
+import (
+	"fmt"
+)
+
+const intMax = int(^uint(0) >> 1)
+
+var Cnt int
+
+// LeastCoins find least number of coins of which the total values are equals a given one
+func LeastCoins(targetTotal int, coinOptions []int) int {
+	minNum := intMax
+
+	memo := make([][]int, targetTotal+1)
+	for i := range memo {
+		memo[i] = make([]int, len(coinOptions))
+	}
+	fmt.Println("start")
+	leastCoins(&minNum, 0, targetTotal, len(coinOptions)-1, coinOptions, memo)
+	fmt.Println("end")
+
+	return minNum
+
+}
+
+func leastCoins(minNum *int, cNum, totalValue, opIndex int, coinOptions []int, memo [][]int) {
+	Cnt++
+	if 0 == totalValue {
+		if cNum < *minNum {
+			*minNum = cNum
+		}
+
+		return
+	}
+
+	if opIndex < 0 {
+		return
+	}
+
+	num4Option := 0
+	remaining := totalValue - coinOptions[opIndex]*num4Option
+	for remaining >= 0 {
+
+		if opIndex != 0 {
+			if shouldSkip(memo, remaining, opIndex-1, cNum+num4Option) {
+				goto Next
+			}
+		}
+		leastCoins(minNum, cNum+num4Option, remaining, opIndex-1, coinOptions, memo)
+
+	Next:
+		num4Option++
+		remaining = totalValue - coinOptions[opIndex]*num4Option
+
+	}
+
+}
+
+func shouldSkip(memo [][]int, totalValue, nextOpIdex, cNum int) bool {
+	if memo[totalValue][nextOpIdex] > 0 && memo[totalValue][nextOpIdex] <= cNum {
+		fmt.Printf("skip，%d, %d  as %d <= %d \n", totalValue, nextOpIdex, memo[totalValue][nextOpIdex], cNum)
+		return true
+	}
+	if memo[totalValue][nextOpIdex] == 0 || memo[totalValue][nextOpIdex] > cNum {
+		memo[totalValue][nextOpIdex] = cNum
+	}
+	return false
+}
+
+func LeastCoins2(targetTotal int, coinOptions []int) int {
+
+	minNum := intMax
+	memo := make([][]bool, targetTotal)
+	for i := range memo {
+		memo[i] = make([]bool, targetTotal/coinOptions[0])
+	}
+
+	fmt.Println("start")
+	leastCoins2(&minNum, targetTotal, coinOptions, 0, 0, memo)
+	fmt.Println("end")
+
+	return minNum
+
+}
+
+func leastCoins2(minNum *int, targetTotal int, coinOptions []int, cNum, cValue int, memo [][]bool) {
+	Cnt++
+	if cValue == targetTotal {
+		if *minNum > cNum {
+			*minNum = cNum
+		}
+		return
+	}
+
+	for _, coin := range coinOptions {
+		if coin+cValue <= targetTotal && !memo[cValue+coin-1][cNum] {
+			memo[cValue+coin-1][cNum] = true
+			leastCoins2(minNum, targetTotal, coinOptions, cNum+1, cValue+coin, memo)
+		}
+	}
+}

go/41_dynamic_programming/backtracking/leastcoins_test.go

@@ -0,0 +1,56 @@
+package backtracking
+
+import "testing"
+
+func TestFindLeastCoins(t *testing.T) {
+
+	coinOptions := []int{1, 3, 5, 10, 50}
+
+	Cnt = 0
+	result := LeastCoins(9, coinOptions)
+
+	t.Log("test 1 =====================")
+	if result != 3 {
+		t.Logf("least coins %d", result)
+		t.Error("failed")
+	}
+	t.Logf("cnt===%d", Cnt)
+
+	Cnt = 0
+	t.Log("test 2 =====================")
+	result = LeastCoins(36, coinOptions)
+
+	if result != 5 {
+		t.Logf("least coins %d", result)
+		t.Error("failed")
+	}
+	t.Logf("cnt===%d", Cnt)
+
+}
+
+func TestFindLeastCoins2(t *testing.T) {
+
+	coinOptions := []int{1, 3, 5, 10, 50}
+
+	Cnt = 0
+	result := LeastCoins2(9, coinOptions)
+
+	t.Log("test 1 =====================")
+	if result != 3 {
+		t.Logf("least coins %d", result)
+		t.Error("failed")
+	}
+
+	t.Logf("cnt===%d", Cnt)
+
+	Cnt = 0
+	t.Log("test 2 =====================")
+	result = LeastCoins2(36, coinOptions)
+
+	if result != 5 {
+		t.Logf("least coins %d", result)
+		t.Error("failed")
+	}
+	t.Logf("cnt===%d", Cnt)
+
+}

go/41_dynamic_programming/dp/leastcoins.go

@@ -0,0 +1,63 @@
+package dp
+
+var Cnt int
+
+// minNum(v) = 1 + min(minNum(v-i))
+func LeastCoins(targetTotal int, coinOptions []int) int {
+	memo := make([]int, targetTotal)
+
+	cMinNum := leastCoins(targetTotal, coinOptions, memo)
+
+	return cMinNum
+
+}
+
+// State Transition Table
+func LeastCoins2(targetTotal int, coinOptions []int) int {
+	memo := make([]int, targetTotal)
+
+	for i := 1; i <= targetTotal; i++ {
+
+		minNum := -1
+		for _, coin := range coinOptions {
+			Cnt++
+			if i < coin {
+				break
+			}
+			if i == coin {
+				minNum = 1
+				break
+			}
+			if minNum == -1 || minNum > memo[i-coin-1]+1 {
+				minNum = memo[i-coin-1] + 1
+			}
+		}
+		memo[i-1] = minNum
+	}
+
+	return memo[targetTotal-1]
+
+}
+
+func leastCoins(targetTotal int, coinOptions, memo []int) int {
+	Cnt++
+	if targetTotal == 0 {
+		return 0
+	}
+	if memo[targetTotal-1] != 0 {
+		return memo[targetTotal-1]
+	}
+	cMinNum := -1
+	for _, coin := range coinOptions {
+		if targetTotal-coin < 0 {
+			continue
+		}
+		cNum := 1 + leastCoins(targetTotal-coin, coinOptions, memo)
+		if cMinNum == -1 || cNum < cMinNum {
+			cMinNum = cNum
+		}
+
+	}
+	memo[targetTotal-1] = cMinNum
+	return cMinNum
+}

go/41_dynamic_programming/dp/leastcoins_test.go

@@ -0,0 +1,55 @@
+package dp
+
+import "testing"
+
+func TestFindLeastCoins(t *testing.T) {
+
+	coinOptions := []int{1, 3, 5, 10, 50}
+
+	Cnt = 0
+	result := LeastCoins(9, coinOptions)
+
+	t.Log("test 1 =====================")
+	if result != 3 {
+		t.Logf("least coins %d", result)
+		t.Error("failed")
+	}
+	t.Logf("cnt===%d", Cnt)
+
+	Cnt = 0
+	t.Log("test 2 =====================")
+	result = LeastCoins(36, coinOptions)
+
+	if result != 5 {
+		t.Logf("least coins %d", result)
+		t.Error("failed")
+	}
+	t.Logf("cnt===%d", Cnt)
+
+}
+
+func TestFindLeastCoins2(t *testing.T) {
+
+	coinOptions := []int{1, 3, 5, 10, 50}
+
+	Cnt = 0
+	result := LeastCoins2(9, coinOptions)
+
+	t.Log("test 1 =====================")
+	if result != 3 {
+		t.Logf("least coins %d", result)
+		t.Error("failed")
+	}
+	t.Logf("cnt===%d", Cnt)
+
+	Cnt = 0
+	t.Log("test 2 =====================")
+	result = LeastCoins2(36, coinOptions)
+
+	if result != 5 {
+		t.Logf("least coins %d", result)
+		t.Error("failed")
+	}
+	t.Logf("cnt===%d", Cnt)
+
+}

javascript/16_binary/binary-find.js

@@ -68,10 +68,10 @@ const biaryFindLastSmall = (sortedArr, target) => {
     let high = sortedArr.length - 1
     while (low <= high) {
         const mid = Math.floor((low + high) / 2)
-        if (sortedArr[mid] > target) {
+        if (target < sortedArr[mid]) {
             high = mid - 1
         } else {
-            if (mid === sortedArr.length - 1 || sortedArr[mid + 1] > target) return mid
+            if (mid === sortedArr.length - 1 || sortedArr[mid + 1] >= target) return mid
             low = mid + 1
         }
     }
@@ -87,4 +87,4 @@ console.log(`FindLast: ${last}`)
 const FisrtBig = biaryFindFistBig(arr, 5)
 console.log(`FindFisrtBig: ${FisrtBig}`)
 const LastSmall = biaryFindLastSmall(arr, 4)
-console.log(`FindLastSmall: ${LastSmall}`)
+console.log(`FindLastSmall: ${LastSmall}`)

javascript/17_skiplist/SkipList.js

@@ -5,28 +5,34 @@
 
 const MAX_LEVEL = 16;
 
-class Node{
-    data = -1;
-    maxLevel = 0;
-    refer = new Array(MAX_LEVEL);
+class Node {
+    constructor({
+        data = -1,
+        maxLevel = 0,
+        refer = new Array(MAX_LEVEL)
+    } = {}) {
+        this.data = data;
+        this.maxLevel = maxLevel;
+        this.refer = refer
+    }
 }
 
 class SkipList{
-    levelCount = 1;
-    head = new Node();
-
-    static randomLevel() {
+    constructor() {
+        this.head = new Node();
+        this.levelCount = 1;
+    }
+    randomLevel() {
         let level = 1;
-        for(let i = 1; i < MAX_LEVEL; i++) {
-            if(Math.random() < 0.5) {
+        for (let i = 1; i < MAX_LEVEL; i++) {
+            if (Math.random() < 0.5) {
                 level++;
             }
         }
         return level;
     }
-
     insert(value) {
-        const level = SkipList.randomLevel();
+        const level = this.randomLevel();
         const newNode = new Node();
         newNode.data = value;
         newNode.maxLevel = level;
@@ -88,8 +94,40 @@ class SkipList{
     printAll() {
         let p = this.head;
         while(p.refer[0] !== undefined) {
-            // console.log(p.refer[0].data)
+            console.log(p.refer[0].data)
             p = p.refer[0];
         }
     }
 }
+
+test();
+function test() {
+    let list = new SkipList();
+    let length = 20000;
+    //顺序插入
+    for (let i = 1; i <= 10; i++) {
+        list.insert(i);
+    }
+    //输出一次
+    list.printAll();
+    console.time('create length-10')
+    //插入剩下的
+    for (let i = 11; i <= length - 10; i++) {
+        list.insert(i);
+    }
+    console.timeEnd('create length-10')
+    //搜索 10次
+    for (let j = 0; j < 10; j++) {
+        let key = Math.floor(Math.random() * length + 1);
+        console.log(key, list.find(key))
+    }
+    //搜索不存在的值
+    console.log('null:', list.find(length + 1));
+    //搜索5000次统计时间
+    console.time('search 5000');
+    for (let j = 0; j < 5000; j++) {
+        let key = Math.floor(Math.random() * length + 1);
+    }
+    console.timeEnd('search 5000');
+}
+