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

257.二叉树的所有路径-简单

题目描述：
给你一个二叉树的根节点 root ，按 任意顺序 ，返回所有从根节点到叶子节点的路径。
叶子节点 是指没有子节点的节点。

题解：
一看就是递归，但是难点在于字符串数组怎么传递，一开始试图用闭包，但是没写明白，最后弄了个全局变量

代码（Go）：

 var sces []string

func binaryTreePaths(root *TreeNode) []string {
    sces = []string{}
    var s string
    Paths(root,s)
    return sces
}

func Paths(root *TreeNode,s string){
    s += strconv.Itoa(root.Val)
    if root.Left == nil && root.Right == nil{
        sces = append(sces,s)
    }else{
        if root.Left != nil{
            Paths(root.Left, s + "->")
        }
        if root.Right != nil{
            Paths(root.Right, s + "->")
        }
    }
}

剑指 Offer 32 - II. 从上到下打印二叉树 II-简单

题目描述：
从上到下按层打印二叉树，同一层的节点按从左到右的顺序打印，每一层打印到一行。

题解：
层序遍历用队列，每一层打印到一行简单点想的话就是在队列中存入节点的同时将层数也保存进去，但是这样代码写起来太麻烦了。最后是通过再建一个队列保存每一行的初始状态即本行所有节点解决的问题

代码（Go）：

func levelOrder(root *TreeNode) [][]int {
    q := []*TreeNode{}
    scei := [][]int{}
    if root == nil{
        return scei
    }else{
        q = append(q,root)
    }
    for len(q) > 0{
        qh := q
        sce := []int{}
        for len(qh) > 0{
            if q[0].Left != nil{
                q = append(q,q[0].Left)
            }
            if q[0].Right != nil{
                q = append(q,q[0].Right)
            }
            sce = append(sce,qh[0].Val)
            qh = qh[1:]
            q = q[1:]
        }
        scei = append(scei,sce)
    }
    return scei
}

1122.数组的相对排序-简单

题目描述：
给你两个数组，arr1 和 arr2，arr2 中的元素各不相同，arr2 中的每个元素都出现在 arr1 中。
对 arr1 中的元素进行排序，使 arr1 中项的相对顺序和 arr2 中的相对顺序相同。未在 arr2 中出现过的元素需要按照升序放在 arr1 的末尾。

题解：
因为数组中都是数字且比较小，所以采用桶排序的方法，遍历数组1把每个数字的出现次数存储在数组中，然后遍历数组2依次输出对应数量的数字，最后遍历桶数组将剩下的数字按顺序输出

代码（Go）：

func relativeSortArray(arr1 []int, arr2 []int) []int {
    max := 0
    for _, v := range arr1 {
        if v > max {
            max = v
        }
    }
    barrel := make([]int, max+1)
    for _, v := range arr1 {
        barrel[v]++
    }
    re := make([]int, 0, len(arr1))
    for _, v := range arr2 {
        for barrel[v] > 0{
            re = append(re, v)
            barrel[v]--
        }
    }
    for i, v := range barrel {
        for v > 0{
            re = append(re, i)
            v--
        }
    }
    return re
}

2.两数相加-中等

题目描述：
给你两个 非空 的链表，表示两个非负的整数。它们每位数字都是按照 逆序 的方式存储的，并且每个节点只能存储 一位 数字。
请你将两个数相加，并以相同形式返回一个表示和的链表。
你可以假设除了数字 0 之外，这两个数都不会以 0 开头。

题解：
常规的遍历两链表相加，难点是边界条件，最后各种ifelse写了五十多行代码，看官方代码长度只有我的一半。

代码（Go）：

func addTwoNumbers(l1 *ListNode, l2 *ListNode) *ListNode {
    flag := 0
    head := l1
    tempnum := 0
    for l1.Next != nil && l2.Next != nil{
        tempnum = (l2.Val + l1.Val + flag)%10
        flag = (l2.Val + l1.Val + flag)/10
        l1.Val = tempnum
        l1 = l1.Next
        l2 = l2.Next
    }
    tempnum = (l2.Val + l1.Val + flag)%10
    flag = (l2.Val + l1.Val + flag)/10
    l1.Val = tempnum
    if flag == 1 && l1.Next == nil && l2.Next == nil{
        var temp = &ListNode{}
        l1.Next = temp
        temp.Next = nil
        temp.Val = 1
    }else if l1.Next == nil{
        l1.Next = l2.Next
        for flag == 1 && l2.Next != nil{
            l2 = l2.Next
            if l2.Val != 9{
                l2.Val++
                flag = 0
            }else{
                l2.Val = 0
            }
        }
        if flag == 1{
            l2.Val = 0
            var temp = &ListNode{}
            l2.Next = temp
            temp.Val = 1
            temp.Next = nil
        }
    }else if l2.Next == nil{
        for flag == 1 && l1.Next != nil{
            l1 = l1.Next
            if l1.Val != 9{
                l1.Val++
                flag = 0
            }else{
                l1.Val = 0
            }
        }
        if flag == 1{
            var temp = &ListNode{}
            l1.Next = temp
            temp.Val = 1
            temp.Next = nil
        }
    }
    return head
}

总结

第一道中等题顺利解出，开了个好头，问题还是代码写的太复杂，涉及到比较边界条件的判断时尤其严重