Leetcode09-#88/89/104

---

1 #88-合并两个有序数组

• 题目：
  给你两个有序整数数组 nums1 和 nums2，请你将 nums2 合并到 nums1 中，使 nums1 成为一个有序数组。
  初始化 nums1 和 nums2 的元素数量分别为 m 和 n 。你可以假设 nums1 有足够的空间（空间大小等于 m + n）来保存 nums2 中的元素。
  示例：

  输入：nums1 = [1,2,3,0,0,0], m = 3, nums2 = [2,5,6], n = 3
  输出：[1,2,2,3,5,6]
  

• 分析：

  • 方法1：直接将数组2的元素都拷贝到数组1中，再整体排序。
    数组1中的元素有m个，所以数组2中的第一个元素拷贝到数组1中对应的下标就是m，第二个元素拷贝过来对应的下标是m+1，一直到m+n-1，拷贝完后，将数组1整体排序一遍。
    缺点：时间复杂度高，最快也要 O((n+m)log(n+m))时间
  • 方法2：反着比较。
    数组1和数组2都是有序的，所以从前往后看是有序，从后往前看也是有序。
    

  反着比较nums1[m-1]和nums2[n-1]，因为6更大所以将6拷贝过去。
  注意不用再新建一个数组，数组1后面都是空着的，也有足够空间可以容纳下数组2中的所有元素。
  将两个数组中最大的数放到数组1的最后一位(下标n+m-1处)，将倒数第二大的数放到数组1的倒数第二位(下标n+m-2处)。
  依次类推直到两个数组的元素全部比较完。
  最后数组1就是有序的，这种比较方式不需要再占用额外的空间。

• 答案：

  • 答案1：

  class Solution(object):
  def merge(self, nums1, m, nums2, n):
      j = 0
      for i in xrange(m,m+n):
          nums1[i] = nums2[j]
          j += 1
      nums1.sort()
  

  • 答案2：

  class Solution(object):
  def merge(self, nums1, m, nums2, n):
      i = m-1 # 数组1的最后一个数
      j = n-1 # 数组2的最后一位
      k = m+n-1 # 数组1的最后一位
      while i>=0 or j>=0:
          # 注意两个边界条件，i<0以及j<0，这表示一个数组已经拷贝完了
          if i<0: # 数组1拷贝完
              nums1[k] = nums2[j]
              j -= 1
          elif j<0: # 数组2拷贝完
              nums1[k] = nums1[i]
              i -= 1
          # 反向比较时，拷贝的是较大的那个元素 
          elif nums1[i]<=nums2[j]:
              nums1[k] = nums2[j]
              j -= 1
          else:
              nums1[k] = nums1[i]
              i -= 1
          k -= 1
  

---

2 #89-格雷编码

• 题目：
  格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。
  给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。即使有多个不同答案，你也只需要返回其中一种。
  格雷编码序列必须以 0 开头。
  • 示例1：

  	输入: 2
  输出: [0,1,3,2]
  解释:
  00 - 0
  01 - 1
  11 - 3
  10 - 2
  对于给定的 n，其格雷编码序列并不唯一。
  例如，[0,2,3,1] 也是一个有效的格雷编码序列。
  
  00 - 0
  10 - 2
  11 - 3
  01 - 1
  

  • 示例2：

  输入: 0
  输出: [0]
  解释: 我们定义格雷编码序列必须以 0 开头。
   给定编码总位数为 n 的格雷编码序列，其长度为 2n。当 n = 0 时，长度为 20 = 1。
   因此，当 n = 0 时，其格雷编码序列为 [0]。
  

• 分析：
  回溯和剪枝处理
• 答案：

  class Solution:
  def grayCode(self, n: int) -> List[int]:
      seen = set([0])
      def backtrack(path):
          if len(path) == 2 ** n: return path
          for i in range(n):
              nxt = 1 << i ^ path[-1]
              if nxt in seen: continue
              seen.add(nxt)
              path.append(nxt)
              if backtrack(path): return path
              path.pop()
              seen.remove(nxt)
      return backtrack([0])
  

参考

---

3 #104-二叉树的最大深度

• 题目：
  给定一个二叉树，找出其最大深度。
  二叉树的深度为根节点到最远叶子节点的最长路径上的节点数
  说明: 叶子节点是指没有子节点的节点。
  • 示例：
    给定二叉树 [3,9,20,null,null,15,7]

      3
     / \
    9  20
      /  \
     15   7
    # 返回它的最大深度 3 。
  

• 分析：
  True = 1，False = 0，None = 0。max(left_high,right_high) + 1：将当前节点的左右子树放入到max()里对比 ： 如果存在即为True=1，不存在即为None=0，不管最后存不存在都 + 1，这个 1 是当前节点的原本的高度。
• 答案：

  # Definition for a binary tree node.
  # class TreeNode(object):
  #     def __init__(self, x):
  #         self.val = x
  #         self.left = None
  #         self.right = None
  class Solution(object):
  def maxDepth(self, root):
      """
      :type root: TreeNode
      :rtype: int
      """
    
      if root == None:
          return 0
      
      left_high = self.maxDepth(root.left)
      right_high = self.maxDepth(root.right)
  
      return max(left_high,right_high) + 1。
  

参考

---