6-4 链表拼接 (20分)_LeetCode热题100道python解法：链表与二叉树

206. 反转链表

反转一个单链表。

思路：两个指针，一前一后遍历过去。

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        pre = None
        cur = head
        while cur:
            tmp = cur.next
            cur.next = pre
            pre, cur = cur, tmp
        return pre

21. 合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4
class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if not l1: return l2  # 终止条件，一个为空返回另一个
        if not l2: return l1
        if l1.val < l2.val: 
            l1.next = self.mergeTwoLists(l1.next,l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1,l2.next)
            return l2

104. 二叉树的最大深度

根节点为第一层，经典必会。

class Solution:
    def maxDepth(self, root: TreeNode) -> int:
        if not root:
            return 0
        return 1 + max([self.maxDepth(root.left), self.maxDepth(root.right)])

94. 二叉树的中序遍历

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

示例 1：

  1
    
     2
    / 
   3   
 输出：[1,3,2]

思路：经典递归，必回。

class Solution:
    def inorderTraversal(self, root: TreeNode) -> List[int]:
        if not root:
            return []
        return self.inorderTraversal(root.left) + [root.val] + self.inorderTraversal(root.right)

617. 合并二叉树

给定两个二叉树，想象当你将它们中的一个覆盖到另一个上时，两个二叉树的一些节点便会重叠。

你需要将他们合并为一个新的二叉树。合并的规则是如果两个节点重叠，那么将他们的值相加作为节点合并后的新值，否则不为 NULL 的节点将直接作为新二叉树的节点。

示例 1:

输入: 
    Tree 1                     Tree 2                  
          1                         2                             
         /                        /                             
        3   2                     1   3                        
       /                                                    
      5                             4   7                  
输出: 
合并后的树:
         3
        / 
       4   5
      /     
     5   4   7
注意: 合并必须从两个树的根节点开始。

思路：经典左右递归

class Solution:
    def mergeTrees(self, t1: TreeNode, t2: TreeNode) -> TreeNode:
        if not t2:
            return t1
        elif not t1:
            return t2
        else:
            t3 = TreeNode()
            t3.val = t1.val + t2.val
            t3.left = self.mergeTrees(t1.left,t2.left)
            t3.right = self.mergeTrees(t1.right,t2.right)
            return t3

226. 翻转二叉树

左右翻转一棵二叉树。

思路：经典左右递归

class Solution:
    def invertTree(self, root: TreeNode) -> TreeNode:
        if not root:
            return
        root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)
        return root

114. 二叉树展开为链表

给定一个二叉树，原地将它展开为一个单链表。

    1
   / 
  2   5
 /    
3   4   6

将其展开为：

1
 
  2
   
    3
     
      4
       
        5
         
          6

思路：前序遍历。

class Solution:
    def flatten(self, root: TreeNode) -> None:
        if not root:
            return
        # 先把左右两个子树处理成链表
        self.flatten(root.left)
        self.flatten(root.right)
        # 接下来把右边链表剥离，把左边链表挂在root.right
        tmp_right = root.right
        root.right = root.left
        root.left = None
        # 然后把右边链表挂在原左边链表的最后
        while root.right!=None:
            root = root.right # 找到原左链表的末尾，用于接右链表
        root.right = tmp_right

96. 不同的二叉搜索树

给定一个整数n，求以 1 ... n 为节点组成的二叉搜索树有多少种？

思路：注意题目要求的是二叉搜索树，即对任意节点，其左子树所有节点均小于此节点，其右子树上所有节点均大于此节点。考虑到根节点的左右子树也均为二叉搜索树，因此可以用递归：k为节点时，左子树为1...(k-1)，右子树为(k+1)...n。

class Solution:
    def numTrees(self, n: int) -> int:
        dp = [0] * (n+1)
        dp[0] = 1
        dp[1] = 1
        for i in range(1,n+1):
            cnt = 0
            for k in range(1,i+1):
                cnt += dp[k-1]*dp[i-k]
            dp[i] = cnt
        return dp[n]

105. 从前序与中序遍历序列构造二叉树

根据一棵树的前序遍历与中序遍历构造二叉树, 树中没有重复的元素。

例如：

前序遍历 preorder = [3,9,20,15,7]
中序遍历 inorder = [9,3,15,20,7]
返回：
    3
   / 
  9  20
    /  
   15   7

思路：前序遍历[根节点，左子树，右子树]，中序遍历[左子树，根节点，右子树]，显然前序遍历第一个为根节点，根据根节点在中序遍历中定位左右子树的中序遍历，同时可知左右子树的元素数量，由此在前序遍历中找到左右子树的前序遍历。由此递归。

class Solution:
    def buildTree(self, preorder: List[int], inorder: List[int]) -> TreeNode:
        if not preorder:
            return
        root = TreeNode()
        root.val = preorder[0]
        index = inorder.index(root.val)
        root.left = self.buildTree(preorder[1:index+1],inorder[:index])
        root.right = self.buildTree(preorder[index+1:],inorder[index+1:])
        return root

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

给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

所有节点的值都是唯一的。
p、q 为不同节点且均存在于给定的二叉树中。

思路：某节点是公共祖先有两种情况：

1. 该节点为指定节点中的一个，且子树中存在另一个节点。
2. 该节点不是指定节点，但其左右子树均存在指定节点。

class Solution:
    def lowestCommonAncestor(self, root: 'TreeNode', p: 'TreeNode', q: 'TreeNode') -> 'TreeNode':
        if not root:
            return
        if root==q or root==p:
            return root # 可能为情况1，也可能是情况1中的子树
        left = self.lowestCommonAncestor(root.left,p,q)
        right = self.lowestCommonAncestor(root.right,p,q)
        if left and right:
            return root # 情况2
        if not left:
            return right
        if not right:
            return left

538. 把二叉搜索树转换为累加树

给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。

示例：

思路：上图的中序遍历是[0,1,2,3,4,5,6,7,8], 实际上就是把中序遍历从后到前逆序累加，然后再转为二叉树。那么就按照逆中序遍历遍历二叉树，不断将遇到的节点值累加起来即可。

class Solution:
    def __init__(self):
        self.accum = 0
​
    def convertBST(self, root: TreeNode) -> TreeNode:
        if not root:
            return 
        # 接下来逆中序遍历root
        self.convertBST(root.right) # 1. 遍历右子树
        root.val += self.accum # 2. 遍历当前结点
        self.accum = root.val 
        self.convertBST(root.left) # 3. 遍历左子树
        return root