feat: add solutions

Author: minicloudsky

.github/workflow/go-test.yml

@@ -0,0 +1,41 @@
+name: Go Unit Tests
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    branches: [ "master" ]
+
+jobs:
+  test:
+    name: Run Unit Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Go
+        uses: actions/setup-go@v4
+        with:
+          go-version: '1.21'
+
+      - name: Cache Go Modules
+        uses: actions/cache@v3
+        with:
+          path: |
+            ~/go/pkg/mod
+            ./vendor
+          key: ${{ runner.os }}-go-${{ hashFiles('**/go.sum') }}
+          restore-keys: |
+            ${{ runner.os }}-go-
+
+      - name: Download dependencies
+        run: go mod download
+
+      - name: Run Tests
+        run: go test -v -race -coverprofile=coverage.out -covermode=atomic ./...
+
+      # - name: Upload coverage report
+      #   uses: codecov/codecov-action@v3
+      #   with:
+      #     files: coverage.out

data-structure/binary_tree/binary_tree.go

@@ -58,3 +58,29 @@ func printBinaryTree(root *TreeNode, n int) {
 	// 参数n控制输出值数量, 否则二叉树最后一层叶子节点的孩子节点也会被打印(但是这些孩子节点是不存在的).
 	fmt.Println(result[:n])
 }
+
+func preOrder(root *TreeNode) {
+	if root == nil {
+		return
+	}
+	fmt.Println(root.Val)
+	preOrder(root.Left)
+	preOrder(root.Right)
+}
+func inOrder(root *TreeNode) {
+	if root == nil {
+		return
+	}
+	inOrder(root.Left)
+	fmt.Println(root.Val)
+	inOrder(root.Right)
+}
+
+func postOrder(root *TreeNode) {
+	if root == nil {
+		return
+	}
+	postOrder(root.Left)
+	postOrder(root.Right)
+	fmt.Println(root.Val)
+}

data-structure/binary_tree/binary_tree_test.go

@@ -7,3 +7,11 @@ func TestBinaryTree(t *testing.T) {
 	root := constructBinaryTree(array)
 	printBinaryTree(root, len(array))
 }
+
+func TestDfs(t *testing.T) {
+	array := []int{4, 1, 6, 0, 2, 5, 7, -1, -1, -1, 3, -1, -1, -1, 8}
+	root := constructBinaryTree(array)
+	//preOrder(root)
+	//inOrder(root)
+	postOrder(root)
+}

golang/channel/producer_consumer.go

@@ -0,0 +1,38 @@
+package main
+
+import (
+	"fmt"
+	"runtime"
+	"sync"
+)
+
+func producer(c chan int, val int, errChan chan error) {
+	c <- val
+}
+
+func consumer(c chan int, errChan chan error, wg *sync.WaitGroup) {
+	select {
+	case val, ok := <-c:
+		if ok {
+			fmt.Println(val)
+		}
+	case err := <-errChan:
+		fmt.Printf("err: %v received, return", err)
+		return
+	}
+}
+
+func main() {
+	c := make(chan int, 100)
+	errChan := make(chan error, 1)
+	wg := &sync.WaitGroup{}
+	for i := 0; i < 100; i++ {
+		go producer(c, i, errChan)
+		fmt.Println("channel size: ", len(c))
+		wg.Add(1)
+		go consumer(c, errChan, wg)
+	}
+	errChan <- fmt.Errorf("send finished")
+	wg.Wait()
+	runtime.NumGoroutine()
+}

golang/priority_channel/README.md

@@ -0,0 +1,2 @@
+# channel 优先级调度
+有a、b、c 3个channel，实现一个优先级调度，当a 先到达时优先使用a的，a没到达就使用b和c的，如何实现

golang/priority_channel/main.go

@@ -0,0 +1,77 @@
+package main
+
+import (
+	"fmt"
+	"time"
+)
+
+// 使用 select 语句来轮询 a、b 和 c。
+// 在 select 中，如果 a 有数据，就优先选择 a，否则检查 b 和 c。
+// 使用 time.After 来避免阻塞，避免死锁的情况
+
+func priorityChannel() {
+	a := make(chan int)
+	b := make(chan int)
+	c := make(chan int)
+
+	go func() {
+		time.Sleep(1 * time.Second)
+		a <- 1 // 模拟a有数据，延迟1秒
+	}()
+
+	go func() {
+		time.Sleep(2 * time.Second)
+		b <- 2 // 模拟b有数据，延迟2秒
+	}()
+
+	go func() {
+		time.Sleep(3 * time.Second)
+		c <- 3 // 模拟c有数据，延迟3秒
+	}()
+
+	for {
+		select {
+		case msgA := <-a:
+			fmt.Println("Received from a:", msgA)
+		case msgB := <-b:
+			fmt.Println("Received from b:", msgB)
+		case msgC := <-c:
+			fmt.Println("Received from c:", msgC)
+		}
+	}
+}
+func priorityChannel2() {
+	a := make(chan int)
+	b := make(chan int)
+	c := make(chan int)
+
+	go func() {
+		time.Sleep(1 * time.Second)
+		a <- 1 // 模拟a有数据，延迟1秒
+	}()
+
+	go func() {
+		time.Sleep(2 * time.Second)
+		b <- 2 // 模拟b有数据，延迟2秒
+	}()
+
+	go func() {
+		time.Sleep(3 * time.Second)
+		c <- 3 // 模拟c有数据，延迟3秒
+	}()
+
+	for {
+		select {
+		case msgA := <-a:
+			fmt.Println("Received from a:", msgA)
+		case msgB := <-b:
+			fmt.Println("Received from b:", msgB)
+		case msgC := <-c:
+			fmt.Println("Received from c:", msgC)
+		}
+	}
+}
+func main() {
+	priorityChannel()
+	priorityChannel2()
+}

solutions/add-two-numbers/add-two-numbers.go renamed to solutions/add-two-numbers.go

@@ -1,4 +1,4 @@
-package add_two_numbers
+package solutions
 
 /**
  * Definition for singly-linked list.
@@ -8,11 +8,6 @@ package add_two_numbers
  * }
  */
 
-type ListNode struct {
-	Val  int
-	Next *ListNode
-}
-
 func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
 	return nil
 }

solutions/best-time-to-buy-and-sell-stock/best-time-to-buy-and-sell-stock.go renamed to solutions/best-time-to-buy-and-sell-stock.go

@@ -1,4 +1,4 @@
-package best_time_to_buy_and_sell_stock
+package solutions
 
 // https://leetcode.cn/problems/best-time-to-buy-and-sell-stock/description/?envType=study-plan-v2&envId=top-100-liked
 // 给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。
@@ -27,7 +27,7 @@ func MaxProfit(prices []int) int {
 // 因此，我们只需要遍历价格数组一遍，记录历史最低点，然后在每一天考虑这么一个问题：如果我是在历史最低点买进的，那么我今天卖出能赚多少钱？
 // 当考虑完所有天数之时，我们就得到了最好的答案。
 func MaxProfit2(prices []int) int {
-	minPrice := 99999999999999999999
+	minPrice := 9999999
 	maxProfit := 0
 	for i := 0; i < len(prices); i++ {
 		maxProfit = max(maxProfit, prices[i]-minPrice)

solutions/best-time-to-buy-and-sell-stock/best-time-to-buy-and-sell-stock_test.go renamed to solutions/best-time-to-buy-and-sell-stock_test.go

@@ -1,4 +1,4 @@
-package best_time_to_buy_and_sell_stock
+package solutions
 
 import (
 	"fmt"

solutions/binary-tree-level-order-traversal.go

@@ -0,0 +1,43 @@
+package solutions
+
+// https://leetcode.cn/problems/binary-tree-level-order-traversal/description/
+// 给你二叉树的根节点 root ，返回其节点值的 层序遍历 。 （即逐层地，从左到右访问所有节点）。
+// 输入：root = [3,9,20,null,null,15,7]
+// 输出：[[3],[9,20],[15,7]]
+// 示例 2：
+//
+// 输入：root = [1]
+// 输出：[[1]]
+// 示例 3：
+//
+// 输入：root = []
+// 输出：[]
+//
+// 提示：
+//
+// 树中节点数目在范围 [0, 2000] 内
+// -1000 <= Node.val <= 1000
+func levelOrder(root *TreeNode) [][]int {
+	if root == nil {
+		return nil
+	}
+	var ans [][]int
+	var currentNodes []*TreeNode
+	currentNodes = append(currentNodes, root) // 根节点开始遍历每一层
+	for currentNodes != nil {
+		var currAns []int
+		var nextNodes []*TreeNode
+		for _, node := range currentNodes {
+			currAns = append(currAns, node.Val) //把这一层的数据加进去
+			if node.Left != nil {
+				nextNodes = append(nextNodes, node.Left) //把下一层要遍历的节点加进去
+			}
+			if node.Right != nil {
+				nextNodes = append(nextNodes, node.Right)
+			}
+		}
+		ans = append(ans, currAns)
+		currentNodes = nextNodes
+	}
+	return ans
+}