add

Author: limingzhong

src/calculate/calculate.go

@@ -0,0 +1,83 @@
+package calculate
+
+func calculate(s string) int {
+	// 遍历s, 遇到数字追加到当前tempNum
+	// sign 保存上一次的出现的符号，用于与当前数字进行组合，默认'+'
+	// stack 用来保存所有数字与操作符的组合 +4 -3 *2 +1
+	// 遇到 + - 将tempNum入栈，
+	// 遇到 * / 将栈顶取出, 与当前数结合，再入栈
+	// 将所有栈结果累加
+
+	sign := '+'
+	tempNum := 0
+	stack := make([]int, 0)
+
+	for i := 0; i < len(s); i++ {
+		c := s[i]
+		if c >= '0' && c <= '9' {
+			tempNum = tempNum*10 + int(c-'0')
+		} else {
+			// 遇上操作符，需要将数字入栈，同时更新操作符缓存
+			switch sign {
+			case '+':
+				stack = append(stack, tempNum)
+			case '-':
+				stack = append(stack, -tempNum)
+			case '*':
+				//top := stack[len(stack)-1]
+				//stack[len(stack)-1] = top*tempNum
+				stack[len(stack)-1] *= tempNum
+			case '/':
+				stack[len(stack)-1] /= tempNum
+			}
+
+			// 更新sign tempNum
+			sign = rune(c)
+			tempNum = 0
+		}
+	}
+	res := 0
+	for i := 0; i < len(stack); i++ {
+		res += stack[i]
+	}
+	return res
+}
+
+func calculateV1(s string) int {
+
+}
+
+func calc(s string, i *int) int {
+	// 计算不包含括号的表达式
+
+	res := 0
+	sign := '+'
+	tempNum := 0
+
+	for *i < len(s) {
+		c := s[*i]
+		if c >= '0' && c <= 9 {
+			tempNum = tempNum*10 + int(c-'0')
+		}
+
+		if c == '+' || c == '-' || *i == len(s)-1 {
+			switch sign {
+			case '+':
+				res += tempNum
+			case '-':
+				res -= tempNum
+			}
+			sign = rune(c)
+			tempNum = 0
+		}
+
+		*i++
+		if c == '(' {
+			tempNum = calc(s, i)
+		}
+		if c == ')' {
+			break
+		}
+	}
+	return res
+}

src/interview/question.go

@@ -0,0 +1,114 @@
+package interview
+
+import (
+	"context"
+	"fmt"
+	"time"
+)
+
+func cacl(index string, a, b int) int {
+	ret := a + b
+	fmt.Println(index, a, b, ret)
+	return ret
+}
+
+func DeferAction() {
+	a := 1
+	b := 2
+
+	defer cacl("1", a, cacl("10", a, b))
+
+	b = 0
+	defer cacl("2", a, cacl("20", a, b))
+	b = 3
+
+	panic("exit")
+
+	// output
+	// 10 1 2 3
+	// 20 1 0 1
+	// 2 1 1 2
+	// 1 1 3 4
+	// panic: exit
+}
+
+func CloseChan() {
+	type A struct {
+		val int
+	}
+
+	c := make(chan *A, 10)
+
+	c <- &A{val: 1}
+	c <- &A{val: 2}
+	close(c)
+
+	for i := range c {
+		fmt.Println(i)
+	}
+
+	fmt.Println(<-c)
+	fmt.Println(<-c)
+
+	// output
+
+	//&{1}
+	//&{2}
+	//<nil>
+	//<nil>
+}
+
+func MapInit() {
+	type A struct {
+		val int
+	}
+
+	// 以下用法错误 map的值是无法取址的，也就无法对结构体里的field进行操作; 因为map是无序的，并且随时存在扩容缩容，其地址也就不固定
+	// m := map[string]A{"x": {1}}
+	// m["x"].val = 2
+
+	// 解决方案
+	// m := map[string]&A
+}
+
+func ConText() {
+	ctx, _ := context.WithCancel(context.Background())
+	//defer cancel()
+	ctx, cancel := context.WithTimeout(ctx, 5*time.Second)
+
+	resp := make(chan int, 3)
+	err := make(chan interface{}, 3)
+
+	operation := func(pid int, ctx context.Context, dst int, resp chan int, err chan interface{}) {
+		n := 1
+		for {
+			select {
+			case <-ctx.Done():
+				fmt.Println(pid, "canceled", ctx.Err())
+				err <- ctx.Err()
+				return
+			case <-time.After(time.Second):
+				fmt.Println(pid, "1 second pass", n)
+				n++
+				if n == dst {
+					resp <- pid
+					return
+				}
+			}
+		}
+	}
+
+	go operation(1, ctx, 10, resp, err)
+	go operation(2, ctx, 10, resp, err)
+	go operation(3, ctx, 7, resp, err)
+
+	select {
+	case pid := <-resp:
+		fmt.Println(pid, "find dst and cancel other goroutines")
+	case e := <-err:
+		fmt.Println(e)
+	}
+
+	cancel()
+	time.Sleep(1 * time.Second) // wait for goroutines return
+}

src/interview/question_test.go

@@ -0,0 +1,15 @@
+package interview
+
+import "testing"
+
+func TestDeferAction(t *testing.T) {
+	DeferAction()
+}
+
+func TestCloseChan(t *testing.T) {
+	CloseChan()
+}
+
+func TestConText(t *testing.T) {
+	ConText()
+}

src/sort/quick_sort.go

@@ -0,0 +1,58 @@
+package sort
+
+func Quicksort(nums []int, start, end int) {
+	if start >= end {
+		return
+	}
+	p := partition(nums, start, end)
+	Quicksort(nums, start, p-1)
+	Quicksort(nums, p+1, end)
+}
+
+func partition(nums []int, start, end int) int {
+	base := nums[end]
+	i := start
+	for j := start; j < end; j++ {
+		if nums[j] < base {
+			nums[i], nums[j] = nums[j], nums[i]
+			i++
+		}
+	}
+	nums[i], nums[end] = nums[end], nums[i]
+	return i
+}
+
+func Mergesort(nums []int) []int {
+	if len(nums) <= 1 {
+		return nums
+	}
+
+	mid := len(nums) / 2
+	left := Mergesort(nums[:mid])
+	right := Mergesort(nums[mid:])
+
+	return merge(left, right)
+}
+
+func merge(nums1, nums2 []int) []int {
+	res := make([]int, 0)
+	i, j := 0, 0
+	for i < len(nums1) && j < len(nums2) {
+		if nums1[i] <= nums2[j] {
+			res = append(res, nums1[i])
+			i++
+		} else {
+			res = append(res, nums2[j])
+			j++
+		}
+	}
+
+	if i < len(nums1) {
+		res = append(res, nums1[i:]...)
+	}
+	if j < len(nums2) {
+		res = append(res, nums2[j:]...)
+	}
+
+	return res
+}

src/sort/quick_sort_test.go

@@ -0,0 +1,18 @@
+package sort
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestQuicksort(t *testing.T) {
+	nums := []int{1, 3, 2, 5, 6, 4}
+	Quicksort(nums, 0, len(nums)-1)
+	fmt.Println(nums)
+}
+
+func TestMergesort(t *testing.T) {
+	nums := []int{1, 3, 2, 5, 6, 4}
+	res := Mergesort(nums)
+	fmt.Println(res)
+}

src/str/str.go

@@ -21,6 +21,7 @@ func Contain(haystack string, needle string) int {
 			return i
 		}
 	}
+	pause
 	return -1
 }