添加算法实例,leetCode第一题

Author: yezihack

Cache/lfu.go

@@ -2,8 +2,8 @@ package Cache
 
 import (
 	"fmt"
-	"github.com/chanxuehong/util/math"
 	"github.com/yezihack/math/DoubleLinedList"
+	"math"
 )
 
 /* LFU(least frequently used) 最不常用使用淘汰算法 */
@@ -49,7 +49,7 @@ func (f *LFUCache) updateFreq(node *DoubleLinedList.DoubleNode) {
 	node.Freq = freq
 	//新的频率了, 需要判断是否在缓存中
 	if _, ok := f.cacheFreq[freq]; !ok { //不存在缓存中, 则创建新的.
-		f.cacheFreq[freq] = DoubleLinedList.New(math.MaxUint)
+		f.cacheFreq[freq] = DoubleLinedList.New(math.MaxInt32)
 	}
 	f.cacheFreq[freq].Append(node)
 }

Cache/lru.go

@@ -4,7 +4,7 @@ import (
 	"github.com/yezihack/math/DoubleLinedList"
 )
 
-/* LRU(least recently used) 最少最近使用淘汰算法 */
+/* LRU(least recently used) 最近最少使用淘汰算法 */
 /*
 	实现思路:
 	1.使用到的数据, 放头部

DynamicProgramming/dp_test.go

@@ -0,0 +1,122 @@
+package DynamicProgramming
+
+import (
+	"testing"
+)
+
+//算法
+// 先正常思维
+// 逆向思维
+// 递推思维 逐一推导结果,在此发现规律.
+
+//动态规划算法Dynamic Programming(递推) 动态递推
+//对问题求解时,将问题分解成若干个子问题,
+/*
+求解方法:
+1.递归 + 记忆化 -> 递推
+2.状态的定义
+3.状态的转移方程
+4.最优子结构
+*/
+
+//第一个题 ,非波纳契
+//第一种解法:递归
+func fab(n int) int {
+	if n <= 2 {
+		return 1
+	}
+	return fab(n-1) + fab(n-2)
+}
+func TestFab(t *testing.T) {
+	var r int
+	r = fab(5)
+	if r != 5 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+	r = fab(6)
+	if r != 8 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+	r = fab(8)
+	if r != 21 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+}
+
+//第二种解法: 递归+记忆化
+//因为有重复的计算, 我们将其放入缓存中
+func fabCache(n int, cache map[int]int) int {
+	if n <= 2 {
+		return 1
+	}
+	if _, ok := cache[n]; !ok {
+		cache[n] = fabCache(n-1, cache) + fabCache(n-2, cache)
+	}
+	return cache[n]
+}
+func TestFabCache(t *testing.T) {
+	var r int
+	cache := make(map[int]int)
+	r = fabCache(5, cache)
+	if r != 5 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+	r = fabCache(6, cache)
+	if r != 8 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+	r = fabCache(8, cache)
+	if r != 21 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+}
+
+//第三种解法: 递推法
+//首先找出规律公式 f(n) = f(n-1) + f(n-2)
+func fabProgramming(n int) int {
+	a, b := 0, 1
+	for i := 0; i < n; i++ {
+		a, b = b, a+b
+	}
+	return a
+}
+
+func TestFabProgramming(t *testing.T) {
+	var r int
+	r = fabProgramming(5)
+	if r != 5 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+	r = fabProgramming(6)
+	if r != 8 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+	r = fabProgramming(8)
+	if r != 21 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+}
+func fabProgramming2(n int) int {
+	arr := make([]int, n+1)
+	arr[0] = 0
+	arr[1] = 1
+	for i := 2; i <= n; i++ {
+		arr[i] = arr[i-1] + arr[i-2]
+	}
+	return arr[n]
+}
+func TestFabProgramming2(t *testing.T) {
+	var r int
+	r = fabProgramming2(5)
+	if r != 5 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+	r = fabProgramming2(6)
+	if r != 8 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+	r = fabProgramming2(8)
+	if r != 21 {
+		t.Errorf("result is err, errResult: %d", r)
+	}
+}

LeetCode/1/two_sum_test.go

@@ -0,0 +1,28 @@
+package leet_code_test
+
+import (
+	"fmt"
+	"testing"
+)
+
+//https://leetcode-cn.com/problems/two-sum/
+
+//题目意思是: 给定一个目标值,找出数组里2个数相加等于目标值的下标
+func TestFindTwoSum(t *testing.T) {
+	list := []int{2, 3, 7, 8}
+	a, b := FindTwoSum(list, 15)
+	fmt.Println(a, b)
+}
+
+//思路: 利用相减的结果,错位存储map, 也就是说把相减的结果做key存入map里,待下次相减的结果在map里找到,并返回
+func FindTwoSum(list []int, target int) (int, int) {
+	checked := make(map[int]int)
+	for i := 0; i < len(list); i++ {
+		diff := target - list[i]        //相减获取差值
+		if _, ok := checked[diff]; ok { //判断是否存在map里
+			return checked[diff], i //返回map的值,与当前i为下标
+		}
+		checked[list[i]] = i //将相减的结果做key存储.
+	}
+	return -1, -1
+}

base/README.md

@@ -1,4 +1,4 @@
-# 什么时间和空间复杂度
+# 什么是时间和空间复杂度
 
 # 时间复杂度
 > 首先要说的是，时间复杂度的计算并不是计算程序具体运行的时间，而是算法执行语句的次数。
@@ -23,7 +23,7 @@
 - 如f（n）=2*n3+2n+100则O（n）=n3。
 
 # 空间复杂度
-> 空间复杂度是对一个算法在运行过程中临时占用存储空间大小的量度。
+> 空间复杂度是对一个算法在运行过程中临时占用存储空间大小的度量。
 
 ### 计算方法：
 - ①忽略常数，用O(1)表示

base/base_test.go

@@ -0,0 +1,14 @@
+package base
+
+import (
+	"fmt"
+	"math"
+	"testing"
+)
+
+func TestLog(t *testing.T) {
+	fmt.Println(math.Log2(8))
+	fmt.Println(math.Log2(128))
+	fmt.Println(math.Log2(128 * 2))
+	fmt.Println(math.Log2(1000000000))
+}

base/main.go

@@ -0,0 +1,34 @@
+package base
+
+import (
+	"fmt"
+	"testing"
+)
+
+//最大公约数
+func recursionCommonDivisor(a, b int) int {
+	if b == 0 {
+		return a
+	}
+	return recursionCommonDivisor(b, a%b)
+}
+func forCommonDivisor(a, b int) int {
+	fmt.Printf("first:a:%d, b:%d \n", a, b)
+	for b != 0 {
+		ret := a % b
+		a = b
+		b = ret
+		fmt.Printf("a:%d, b:%d，ret: %d\n", a, b, ret)
+	}
+	return a
+}
+func TestRecursionCommonDivisor(t *testing.T) {
+	var a, b int
+	a, b = 105, 24
+	fmt.Println(recursionCommonDivisor(a, b))
+	fmt.Println(forCommonDivisor(a, b))
+	fmt.Println(forCommonDivisor(1680, 640))
+	fmt.Println(105 % 24)
+	fmt.Println(24 % 105)
+
+}

base/max_common_divisor_test.go

@@ -0,0 +1,62 @@
+package bianry_search
+
+import (
+	"testing"
+)
+
+//二分查找
+//数组必须是有序的.否则免谈
+//每一次查找都是折半查找. 比对目标值, 四种情况, 如下:
+//第一种情况:相等则返回下标
+//第二种情况: 目标值小于中间值, 则修改high值,即high - 1
+//第三种情况: 目标值大于中间值, 则修改low值, 即low + 1
+//第四种情况: 未找到.返回 -1
+func binarySearch(arr []int, search int) int {
+	low := 0             //定义最低位
+	high := len(arr) - 1 //定义最高位, 即数组的最后的下标
+	for low <= high {    //缩小到只包含一个元素
+		mid := (low + high) / 2
+		if search == arr[mid] {
+			return mid
+		} else if search < arr[mid] {
+			high = mid - 1
+		} else if search > arr[mid] {
+			low = mid + 1
+		} else {
+			return -1
+		}
+	}
+	return -1
+}
+func TestBinarySearch(t *testing.T) {
+	arr := []int{1, 3, 7, 9, 10, 22, 88}
+	tests := []struct {
+		name string
+		args int
+		want int
+	}{
+		{
+			"二分查找1",
+			1,
+			0,
+		},
+		{
+			"二分查找2",
+			22,
+			5,
+		},
+		{
+			"二分查找3",
+			100,
+			-1,
+		},
+	}
+	for _, item := range tests {
+		t.Run(item.name, func(t *testing.T) {
+			result := binarySearch(arr, item.args)
+			if result != item.want {
+				t.Errorf("want: %d, err:%d\n", item.want, result)
+			}
+		})
+	}
+}

bianry_search/binary_search_test.go

@@ -0,0 +1,29 @@
+package greedy
+
+import (
+	"fmt"
+	"math"
+	"testing"
+)
+
+//贪心算法 对问题的求解,只做出当前的最好的选择
+
+//找零钱 13
+func FindGreedy(v int) []int {
+	a := []int{10, 8, 5, 3, 2, 1}
+	result := make([]int, 0)
+	for i := 0; i < len(a); i++ {
+		cnt := math.Floor(float64(v) / float64(a[i]))
+		if cnt > 0 && v > 0 && v >= a[i]*int(cnt) {
+			v -= a[i] * int(cnt)
+			for j := 0; j < int(cnt); j++ {
+				result = append(result, a[i])
+			}
+		}
+	}
+	return result
+}
+func TestFindGreedy(t *testing.T) {
+	s := FindGreedy(132)
+	fmt.Println(s)
+}