从零开始的力扣刷题记录-第四天

剑指 Offer 25. 合并两个排序的链表-简单

题目描述：
输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。

题解：
建一个头节点，用两个指针遍历链表，从小到大插在头节点后面就可以了

代码（Go）：

func mergeTwoLists(l1 *ListNode, l2 *ListNode) *ListNode {
    var re = &ListNode{}
    temp := re
    for l1 != nil && l2 != nil{
        if l1.Val <= l2.Val{
            temp.Next = l1
            temp = l1
            l1 = l1.Next
        }else{
            temp.Next = l2
            temp = l2
            l2 = l2.Next
        }
    }
    if l1 == nil{
        temp.Next = l2
    }else{
        temp.Next = l1
    }
    return re.Next
}

94.二叉树的中序遍历-简单

题目描述：
给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。

题解：
经典题，之前没用go做过，做的时候才发现需要用闭包，踩了个坑，闭包如果用到递归的话需要先声明，不能直接用：=，不然会报错说找不到函数。官方题解有个Morris遍历算法可以把空间复杂度降到O(1)，推荐看一下

代码（Go）：

func inorderTraversal(root *TreeNode) []int {
    var sce = []int{}
    var re = func(root *TreeNode){}
    re = func(root *TreeNode) {
        if root == nil{
            return
        }
        re(root.Left)
        sce = append(sce,root.Val)
        re(root.Right)
    }
    re(root)
    return sce
}

412.Fizz Buzz-简单

题目描述：
给你一个整数 n ，找出从 1 到 n 各个整数的 Fizz Buzz 表示，并用字符串数组 answer（下标从 1 开始）返回结果，其中：
answer[i] == “FizzBuzz” 如果 i 同时是 3 和 5 的倍数。
answer[i] == “Fizz” 如果 i 是 3 的倍数。
answer[i] == “Buzz” 如果 i 是 5 的倍数。
answer[i] == i （以字符串形式）如果上述条件全不满足。

题解：
这个题感觉有点意义不明，难道就是为了考个字符串拼接和格式转换？直接if else做完了

代码（Go）：

func fizzBuzz(n int) []string {
    var sce = []string{}
    for i := 1;i <= n;i++{
        if i%3 == 0 && i%5 == 0{
            sce = append(sce,"FizzBuzz")
        }else if i%3 == 0{
            sce = append(sce,"Fizz")
        }else if i%5 == 0{
            sce = append(sce,"Buzz")
        }else{
            sce = append(sce,strconv.FormatInt(int64(i), 10))
        }
    }
    return sce
}

剑指 Offer 29. 顺时针打印矩阵-简单

题目描述：
输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

题解：
一个小时才做出来，感觉这难度不像简单题啊，看底下主站有个一样的题目，难度是中等，我就说这不像一般的简单题。
整体思路就是外面一层循环用k计数，每打印一圈就+1，里面就用常规的矩阵遍历方法，只不过长宽都要受到k的限制，每打印完一个横排或者竖排就要判断一下，如果打印出的元素个数等于矩阵元素个数，说明已经打印出全部元素，不需要再遍历了。没有用到额外空间，空间复杂度O(1)

代码（Go）：

func spiralOrder(matrix [][]int) []int {
    var sce = []int{}
    i,j,k := 0,0,0
    row := len(matrix)
    if row == 0{
        return sce
    }
    col := len(matrix[0])
    for len(sce) < row * col{
        if i == k && j == k{        //起点在左上
            for i < col - k{        //每打印一圈，横排向右遍历时就要少遍历一个元素
                sce = append(sce,matrix[j][i])
                i++
            }
            i--              
            j++                    //打印完一个横排后要调整指针指向正确的位置，防止越界或者重复打印
            for j < row - k{       //每打印一圈，竖排向下遍历时就要少遍历一个元素
                sce = append(sce,matrix[j][i])
                j++
            }
        }
        j--
        if len(sce) == row * col{
            break
        }
        if i == col - k - 1 && j == row - k - 1{      //起点在右下
            for i >= k + 1{        //起点在右下时先减再赋值，所以k要+1
                i--
                sce = append(sce,matrix[j][i])
            }
            for j >= k + 2{  //向上遍历时左上角元素已经被打印，所以要少遍历一个元素，k在之前的基础上再+1
                j --
                sce = append(sce,matrix[j][i])
            }
        }
        k++
        i = k
        j = k
    }
    return sce
}

总结

现在就是做题太慢，尤其第四题，其实一开始思路就确定了，敲代码debug用了一个小时，希望熟能生巧吧