feat: add solutions

Author: minicloudsky

data-structure/binary_tree/symmetric-tree.go

@@ -0,0 +1,32 @@
+package binary_tree
+
+// https://leetcode.cn/problems/symmetric-tree/description/?envType=study-plan-v2&envId=top-100-liked
+// 给你一个二叉树的根节点 root ， 检查它是否轴对称。
+
+// 如果一个树的左子树与右子树镜像对称，那么这个树是对称的。
+//
+//因此，该问题可以转化为：两个树在什么情况下互为镜像？
+//
+//如果同时满足下面的条件，两个树互为镜像：
+//
+//它们的两个根结点具有相同的值
+//每个树的右子树都与另一个树的左子树镜像对称
+//
+//
+//我们可以实现这样一个递归函数，通过「同步移动」两个指针的方法来遍历这棵树，
+//p 指针和 q 指针一开始都指向这棵树的根，随后 p 右移时，q 左移，p 左移时，
+//q 右移。每次检查当前 p 和 q 节点的值是否相等，如果相等再判断左右子树是否对称。
+
+func isSymmetric(root *TreeNode) bool {
+	return check(root, root)
+}
+
+func check(p, q *TreeNode) bool {
+	if p == nil && q == nil {
+		return true
+	}
+	if p == nil || q == nil {
+		return false
+	}
+	return check(p.Left, q.Right) && check(p.Right, q.Left) && p.Val == q.Val
+}

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

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

solutions/calculator-lcci/calculator-lcci.go

@@ -0,0 +1,50 @@
+package calculator_lcci
+
+import "strings"
+
+// 给定一个包含正整数、加(+)、减(-)、乘(*)、除(/)的算数表达式(括号除外)，计算其结果。
+// 表达式仅包含非负整数，+， - ，*，/ 四种运算符和空格  。 整数除法仅保留整数部分。
+// 示例 1:
+// 输入: "3+2*2"
+// 输出: 7
+// 示例 2:
+// 输入: " 3/2 "
+// 输出: 1
+// 示例 3:
+// 输入: " 3+5 / 2 "
+// 输出: 5
+// 说明：
+// 你可以假设所给定的表达式都是有效的。
+// 请不要使用内置的库函数 eval。
+
+// Calculate 百度二面
+func Calculate(s string) int {
+	var stack []int
+	s = strings.Replace(s, " ", "", -1)
+	var operator = '+'
+	var num = 0
+	for i, c := range s {
+		if c >= '0' && c <= '9' {
+			num = num*10 + int(c-'0')
+		}
+		if c < '0' || c > '9' || i == len(s)-1 {
+			switch operator {
+			case '+':
+				stack = append(stack, num)
+			case '-':
+				stack = append(stack, -num)
+			case '*':
+				stack[len(stack)-1] *= num
+			case '/':
+				stack[len(stack)-1] /= num
+			}
+			num = 0
+			operator = c
+		}
+	}
+	result := 0
+	for _, v := range stack {
+		result += v
+	}
+	return result
+}

solutions/calculator-lcci/calculator-lcci_test.go

@@ -0,0 +1,24 @@
+package calculator_lcci
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestCalculate(t *testing.T) {
+	strings := []string{"1+ 2*3- 4/2"}
+	for _, s := range strings {
+		fmt.Println(Calculate(s))
+	}
+}
+
+func TestNum(t *testing.T) {
+	var s = "111"
+	var num int32
+	for _, c := range s {
+		if c >= '0' && c <= '9' {
+			num = num*10 + c - '0'
+		}
+	}
+	fmt.Println(num)
+}

solutions/climbing-stairs/climbing-stairs.go

@@ -1,7 +1,7 @@
 package climbing_stairs
 
 /***
-假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
+假设你正在爬楼梯。需要 n阶你才能到达楼顶。
 
 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
 

solutions/container-with-most-water/container-with-most-water.go

@@ -0,0 +1,40 @@
+package container_with_most_water
+
+// 盛最多水的容器
+// https://leetcode.cn/problems/container-with-most-water/description/?envType=study-plan-v2&envId=top-100-liked
+// 给定一个长度为 n 的整数数组 height 。有 n 条垂线，第 i 条线的两个端点是 (i, 0) 和 (i, height[i]) 。
+// 找出其中的两条线，使得它们与 x 轴共同构成的容器可以容纳最多的水。
+// 返回容器可以储存的最大水量。
+// 说明：你不能倾斜容器。
+// 输入：[1,8,6,2,5,4,8,3,7]
+// 输出：49
+// 解释：图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为 49。
+// 示例 2：
+// 输入：height = [1,1]
+// 输出：1
+// 提示
+// n == height.length
+// 2 <= n <= 105
+// 0 <= height[i] <= 104
+func maxArea(height []int) int {
+	left, right := 0, len(height)-1
+	maxArea := 0
+	for left < right {
+		width := right - left
+		h := 0
+		// 在最大容器问题中，移动较低一侧指针的核心原因在于：当前容器的面积受限于较矮的边， 而移动较高的边无法突破这一限制。
+		// 通过移动较矮侧的指针，我们试图寻找更高的边，以抵消宽度减少的影响，从而可能获得更大的面积
+		// 面积公式与短板效应：面积由 宽度（两指针间距） × 高度（两指针中较矮的值）
+		if height[left] < height[right] {
+			h = height[left]
+			left++
+		} else {
+			h = height[right]
+			right--
+		}
+		if area := width * h; area > maxArea {
+			maxArea = area
+		}
+	}
+	return maxArea
+}

solutions/container-with-most-water/container_with_most_water_test.go

@@ -0,0 +1,11 @@
+package container_with_most_water
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestMaxArea(t *testing.T) {
+	arrs := []int{1, 8, 6, 2, 5, 4, 8, 3, 7}
+	fmt.Println(maxArea(arrs))
+}

solutions/group-anagrams/group-anagrams.go

@@ -0,0 +1,44 @@
+package group_anagrams
+
+import "sort"
+
+// GroupAnagrams https://leetcode.cn/problems/group-anagrams/description/?envType=study-plan-v2&envId=top-100-liked
+// 字母异位词分组
+// 给你一个字符串数组，请你将 字母异位词 组合在一起。可以按任意顺序返回结果列表。
+//
+// 字母异位词 是由重新排列源单词的所有字母得到的一个新单词。
+//
+// 示例 1:
+//
+// 输入: strs = ["eat", "tea", "tan", "ate", "nat", "bat"]
+// 输出: [["bat"],["nat","tan"],["ate","eat","tea"]]
+// 示例 2:
+//
+// 输入: strs = [""]
+// 输出: [[""]]
+// 示例 3:
+//
+// 输入: strs = ["a"]
+// 输出: [["a"]]
+//
+// 提示：
+//
+// 1 <= strs.length <= 104
+// 0 <= strs[i].length <= 100
+// strs[i] 仅包含小写字母
+// 相同字母排列得到的单词，放到一个数组中，通过排序实现
+func GroupAnagrams(strs []string) [][]string {
+	wordMap := make(map[string][]string)
+	for _, s := range strs {
+		charArr := []byte(s)
+		sort.Slice(charArr, func(i, j int) bool {
+			return charArr[i] < charArr[j]
+		})
+		wordMap[string(charArr)] = append(wordMap[string(charArr)], s)
+	}
+	res := make([][]string, 0)
+	for _, w := range wordMap {
+		res = append(res, w)
+	}
+	return res
+}

solutions/group-anagrams/group-anagrams_test.go

@@ -0,0 +1,12 @@
+package group_anagrams
+
+import (
+	"fmt"
+	"testing"
+)
+
+func TestGroupAnagrams(t *testing.T) {
+	strs := []string{"eat", "tea", "tan", "ate", "nat", "bat"}
+	res := GroupAnagrams(strs)
+	fmt.Println(res)
+}

solutions/longest-consecutive-sequence/longest-consecutive-sequence.go

@@ -0,0 +1,40 @@
+package longest_consecutive_sequence
+
+// https://leetcode.cn/problems/longest-consecutive-sequence/description/?envType=study-plan-v2&envId=top-100-liked
+// 给定一个未排序的整数数组 nums ，找出数字连续的最长序列（不要求序列元素在原数组中连续）的长度。
+//
+//请你设计并实现时间复杂度为 O(n) 的算法解决此问题。
+//
+//示例 1：
+//
+//输入：nums = [100,4,200,1,3,2]
+//输出：4
+//解释：最长数字连续序列是 [1, 2, 3, 4]。它的长度为 4。
+//示例 2：
+//
+//输入：nums = [0,3,7,2,5,8,4,6,0,1]
+//输出：9
+
+// LongestConsecutive map记录数字是否存在，存在就一直用map往后判断，记录最大长度
+func LongestConsecutive(nums []int) int {
+	numMap := make(map[int]bool)
+	longestLength := 0
+	for _, num := range nums {
+		numMap[num] = true
+	}
+
+	for num := range numMap {
+		if !numMap[num-1] {
+			currentNum := num
+			currentLength := 1
+			for numMap[currentNum+1] {
+				currentNum++
+				currentLength++
+			}
+			if currentLength > longestLength {
+				longestLength = currentLength
+			}
+		}
+	}
+	return longestLength
+}