【golang】leetcode中级-相交链表&二叉树的中序遍历

第一题 相交链表

题目

解题思路

哈希查找

func getIntersectionNode(headA, headB *ListNode) *ListNode {
    vis := map[*ListNode]bool{}
    //将链表A的节点存入哈希表中
    for tmp := headA; tmp != nil; tmp = tmp.Next {
        vis[tmp] = true
    }
    //在哈希表中搜索链表B的第一个相同节点
    for tmp := headB; tmp != nil; tmp = tmp.Next {
        if vis[tmp] {
            return tmp
        }
    }
    return nil
}

复杂度分析

时间复杂度：O(m+n)，其中 m 和 n 是分别是链表 headA 和 headB 的长度。需要遍历两个链表各一次。

空间复杂度：O(m)，其中 m 是链表 headA 的长度。需要使用哈希集合存储链表 headA 中的全部节点。

双指针

func getIntersectionNode(headA, headB *ListNode) *ListNode {
    if headA == nil || headB == nil {
        return nil
    }
    pa, pb := headA, headB
    for pa != pb {//退出循环的条件为找到相同的节点或完成第二遍遍历，两者皆为空
        if pa == nil {
            pa = headB
        } else {
            pa = pa.Next
        }
        if pb == nil {
            pb = headA
        } else {
            pb = pb.Next
        }
    }
    return pa
}

复杂度分析

时间复杂度：O(m+n)，其中 m 和 n 是分别是链表 headA 和 headB 的长度。两个指针同时遍历两个链表，每个指针遍历两个链表各一次。

空间复杂度：O(1)。

另一种思路

func getIntersectionNode(headA, headB *ListNode) *ListNode {
    // 判断谁更长，长多少
    la, lb := length(headA), length(headB)
    first, last, diff := headA, headB, la-lb
    if la < lb {
        first, last, diff = last, first, lb-la
    }

    // 长的先走
    for i := 0; i < diff; i++ {
        first = first.Next
    }

    // 一起往前走
    for first != nil {
        if first == last {
            return first
        }

        first = first.Next
        last = last.Next
    }

    return nil
}

func length(head *ListNode) (i int) {
    for head != nil {
        i++
        head = head.Next
    }
    return
}


作者：arranger-core
链接：https://leetcode-cn.com/problems/intersection-of-two-linked-lists/solution/go-chang-gui-si-lu-dui-qi-qi-dian-by-huweicai/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

时间复杂度：O(m+n+l)，其中 m 和 n 是分别是链表 headA 和 headB 的长度。获取链表长度需要对链表进行遍历。l 为较长链表到相同节点的长度，最坏情况即无相同节点时也需遍历整个链表。

空间复杂度：O(1)。

第二题 二叉树的中序遍历

题目

解题思路

递归

对于深搜 递归调用函数对子树进行操作自然是最简单的解法


用函数值使代码更为简洁易懂

func inorderTraversal(root *TreeNode) (res []int) {
    //将变量 inorder 声明为 func() 类型，此时 inorder 就被俗称为“回调函数”，此时 inorder 的值为 nil。
    var inorder func(node *TreeNode)
    //函数值
    inorder = func(node *TreeNode) {
        if node == nil {
            return
        }
        左根右中序遍历
        inorder(node.Left)
        res = append(res, node.Val)
        inorder(node.Right)
    }
    
    //对根节点进行操作
    inorder(root)
    return
}

迭代

func inorderTraversal(root *TreeNode) (res []int) {
    stack := []*TreeNode{}
    for root != nil || len(stack) > 0 {
        for root != nil {
            stack = append(stack, root)
            root = root.Left
        }
        root = stack[len(stack)-1]
        stack = stack[:len(stack)-1]
        res = append(res, root.Val)
        root = root.Right
    }
    return
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/er-cha-shu-de-zhong-xu-bian-li-by-leetcode-solutio/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

详细过程见官解视频，

复杂度分析

时间复杂度：O(n)，其中 n 为二叉树节点的个数。二叉树的遍历中每个节点会被访问一次且只会被访问一次。

空间复杂度：O(n)。空间复杂度取决于递归的栈深度，而栈深度在二叉树为一条链的情况下会达到 O(n) 的级别。

Morris 中序遍历

将左子树的最后一个节点连接到根节点上成为他的前缀，这样便可在遍历的时候一口气完成对树的遍历而不需要维护栈，降低了空间复杂度

func inorderTraversal(root *TreeNode) (res []int) {
    for root != nil {
        if root.Left != nil {
            // predecessor 节点表示当前 root 节点向左走一步，然后一直向右走至无法走为止的节点
            predecessor := root.Left
            for predecessor.Right != nil && predecessor.Right != root {
                // 有右子树且没有设置过指向 root，则继续向右走
                predecessor = predecessor.Right
            }
            if predecessor.Right == nil {
                // 将 predecessor 的右指针指向 root，这样后面遍历完左子树 root.Left 后，就能通过这个指向回到 root
                predecessor.Right = root
                // 遍历左子树
                root = root.Left
            } else { // predecessor 的右指针已经指向了 root，则表示左子树 root.Left 已经访问完了
                res = append(res, root.Val)
                // 恢复原样
                predecessor.Right = nil
                // 遍历右子树
                root = root.Right
            }
        } else { // 没有左子树
            res = append(res, root.Val)
            // 若有右子树，则遍历右子树
            // 若没有右子树，则整颗左子树已遍历完，root 会通过之前设置的指向回到这颗子树的父节点
            root = root.Right
        }
    }
    return
}

作者：LeetCode-Solution
链接：https://leetcode-cn.com/problems/binary-tree-inorder-traversal/solution/er-cha-shu-de-zhong-xu-bian-li-by-leetcode-solutio/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度分析

时间复杂度：O(n)，其中 n 为二叉搜索树的节点个数。Morris 遍历中每个节点会被访问两次，因此总时间复杂度为 O(2n)=O(n)。

空间复杂度：O(1)