11. 二叉树的层序遍历

题目链接：102. 二叉树的层序遍历

题目描述

代码与解题思路

/*** Definition for a binary tree node.* type TreeNode struct {*     Val int*     Left *TreeNode*     Right *TreeNode* }*/
func levelOrder(root *TreeNode) (ans [][]int) {if root == nil {return}curQueue := []*TreeNode{root}for len(curQueue) > 0 {nextQueue := curQueuecurQueue = niltmp := []int{}for _, v := range nextQueue {tmp = append(tmp, v.Val)if v.Left != nil {curQueue = append(curQueue, v.Left)}if v.Right != nil {curQueue = append(curQueue, v.Right)}}ans = append(ans, tmp)}return ans
}

多练习就行，把层序遍历的模板背下来

12. 搜索旋转排序数组

题目链接：33. 搜索旋转排序数组

题目描述

代码与解题思路

func search(nums []int, target int) int {left, right := 0, len(nums)-1for left <= right {mid := left+(right-left)/2if nums[mid] == target {return mid}if nums[mid] >= nums[left] { // mid 在左区间if target >= nums[left] && target < nums[mid] { // target 在 mid 左边right = mid-1 } else { // target 在 mid 右边left = mid+1}} else { // mid 在右区间if target <= nums[right] && target > nums[mid] { // target 在 mid 右边left = mid+1} else { // target 在 mid 左边right = mid-1}}}return -1
}

二分还是得靠多练多思考，这里的情况很多，如果再遇到类似的情况，冷静分析，一点点的用 if else 就行，不用畏手畏脚的。

13. 买卖股票的最佳时机

题目链接：121. 买卖股票的最佳时机

题目描述

代码和解题思路

func maxProfit(prices []int) int {minPrice, profit := 10000, 0for _, v := range prices {minPrice = min(minPrice, v)profit = max(profit, v-minPrice)}return profit
}

核心思路：minPrice 记录历史最低价格，profit 记录往后的每次最高价格卖出赚到的钱，这样遍历完一次就能得到最大的利润了。

14. 岛屿数量

题目链接：200. 岛屿数量

题目描述

代码与解题思路

func numIslands(grid [][]byte) (cnt int) {for i := 0; i < len(grid); i++ {for j := 0; j < len(grid[0]); j++ {if grid[i][j] == '1' {dfs(grid, i, j)cnt++}}}return cnt
}func dfs(grid [][]byte, i, j int) {if i < 0 || j < 0 || i >= len(grid) || j >= len(grid[0]) || grid[i][j] == '0' {return}grid[i][j] = '0'dfs(grid, i+1, j)dfs(grid, i-1, j)dfs(grid, i, j+1)dfs(grid, i, j-1)
}

这是一道基础的 dfs 题目，代码的核心点有三个部分：

1. 遍历整个二维数组进行 dfs
2. 只搜索：上下左右
3. 将搜索过的位置置为 ‘0’

其实就是基础的 dfs 需要注意的点，然后注意一下边界条件就行。

15. 环形链表

题目链接：141. 环形链表

题目描述

代码与解题思路

/*** Definition for singly-linked list.* type ListNode struct {*     Val int*     Next *ListNode* }*/
func hasCycle(head *ListNode) bool {if head == nil || head.Next == nil {return false}pre, cur := head, headfor cur.Next != nil && cur.Next.Next != nil {pre = pre.Nextcur = cur.Next.Nextif pre == cur {return true}}return false
}

这道题目实际上是可以用哈希来做的，我们遍历放进哈希表，当遇到相同节点的时候就证明链表有环了，如果没遇到就证明没有，就用 head != nil 来做结束条件，有尾就结束了，有环就会再进一次哈希。

不过我这段代码用的是更优的方法，用的是追击算法，慢指针一次一步，快指针一次两步，最后一定能够追上。面试的时候可以把上面的思路讲一讲，然后实现下面这种解法。

16. 有效的括号

题目链接：20. 有效的括号

题目描述

代码与解题思路

func isValid(s string) bool {hash := map[byte]byte{')':'(', '}':'{', ']':'['}stack := []byte{}for i := 0; i < len(s); i++ {if s[i] == '(' || s[i] == '[' || s[i] == '{' {stack = append(stack, s[i])} else if len(stack) > 0 && stack[len(stack)-1] == hash[s[i]] {stack = stack[:len(stack)-1]} else {return false}}return len(stack) == 0
}

这道题目最重要的就是分析好可能出现的情况：

第一种情况：已经遍历完了字符串，但是栈不为空，说明有相应的左括号没有右括号来匹配，所以 return false；

第二种情况：遍历字符串匹配的过程中，发现栈里没有要匹配的字符，所以return false；

第三种情况：遍历字符串匹配的过程中，栈已经为空了，没有匹配的字符了，说明右括号没有找到对应的左括号 return false；

字符串遍历完之后，栈是空的，就说明全都匹配了。

分析完之后，直接根据需求写代码就行了。

小技巧：通过 map 映射少写几个 if else 语句。

17. 合并两个有序数组

题目链接：88. 合并两个有序数组

题目描述

代码与解题思路

func merge(nums1 []int, m int, nums2 []int, n int)  {tmp := []int{}i, j := 0, 0for m > 0 && n > 0 {if nums1[i] < nums2[j] {tmp = append(tmp, nums1[i])i++m--} else {tmp = append(tmp, nums2[j])j++n--}}for m > 0 {tmp = append(tmp, nums1[i])i++m--}for n > 0 {tmp = append(tmp, nums2[j])j++n--}for i := 0; i < len(nums1); i++ {nums1[i] = tmp[i]}
}

首先是我的朴素解法，开一个 tmp 数组合并好了，然后再赋值给 nums1 数组，这样空间复杂度是 O(N)，但也是最容易想的一种方法

如果想要原地进行合并的话，就需要用到题目给我们准备的 nums[] 数组给出的后面补的 0 的空间，然后从后往前合并（主要得记住从后往前遍历而不会造成覆盖的思想）

func merge(nums1 []int, m int, nums2 []int, n int)  {p1, p2, p := m-1, n-1, m+n-1for p2 >= 0 { // 从后往前遍历if p1 >= 0 && nums1[p1] > nums2[p2] {nums1[p] = nums1[p1]p1--} else {nums1[p] = nums2[p2]p2--}p--}
}

18. 全排列

题目链接：46. 全排列

题目描述

代码与解题思路

func permute(nums []int) (ans [][]int) {n := len(nums)path := make([]int, n)onPath := make([]bool, n)var dfs func(i int)dfs = func(i int) {if i == n {// 这个方式创建了一个新的切片，保证了 path 切片和新切片不共享内存ans = append(ans, append([]int(nil), path...))return}for j, on := range onPath { // 每次进入都会枚举所有数，所有情况都会走一遍if on == false {path[i] = nums[j]onPath[j] = truedfs(i+1)onPath[j] = false}}}dfs(0)return ans
}

注释很明了了，注意 go 的二维数组追加切片的方式就行，dfs 的模板算法，忘了就多练，多练几次就记住了。

19. 二叉树的最近公共祖先

题目链接：236. 二叉树的最近公共祖先

题目描述

代码与解题思路

/*** Definition for a binary tree node.* type TreeNode struct {*     Val int*     Left *TreeNode*     Right *TreeNode* }*/
func lowestCommonAncestor(root, p, q *TreeNode) *TreeNode {// 走到空节点或者找到了, 就返回if root == nil || root == p || root == q {return root}// 左右找 p 和 qleft := lowestCommonAncestor(root.Left, p, q)right := lowestCommonAncestor(root.Right, p, q)// 如果左右都找不到 p 和 q, 就就返回空if left == nil && right == nil {return nil}// 左子树找不到, 就返回右子树找的结果 if left == nil {return right}// 右子树找不到, 就返回左子树找的结果if right == nil {return left}// 左右子树都找到了 p 或 q, 那 root 就是他们最近的公共祖先return root
}

这道题不好想，多刷几遍，把这个思路背下来，然后一直用这一个思路来做题就行，这个思路还是非常的清晰的，刷熟了应该没有问题，注释非常的详细。需要注意的是：前三行代码已经把整个树搜索过一遍了，能走到后面的代码证明 left 和 right 的值已经出来了。

20. 二叉树的锯齿形层序遍历

题目链接：103. 二叉树的锯齿形层序遍历

题目描述

代码与解题思路

/*** Definition for a binary tree node.* type TreeNode struct {*     Val int*     Left *TreeNode*     Right *TreeNode* }*/
func zigzagLevelOrder(root *TreeNode) (ans [][]int) {if root == nil {return}q := []*TreeNode{root}n := 0for len(q) > 0 {nextq := []*TreeNode{}tmp := make([]int, len(q))for i, v := range q {if n%2 == 0 {tmp[i] = v.Val} else {tmp[len(q)-1-i] = v.Val}if v.Left != nil {nextq = append(nextq, v.Left)}if v.Right != nil {nextq = append(nextq, v.Right)}}n++q = nextqans = append(ans, tmp)}return ans
}

依旧是熟悉的配方，熟悉的层序遍历，还是得多刷几遍层序遍历的模板，不然总是记不住，主要就是添加了 n 这个变量来判断要不要反着插入数据，其他的地方就是层序遍历（需要注意的地方：通过创建一个足够大小的数组，然后根据下标来完成正序和倒序的插入，学习一下这个思路）