66. 加一

給定一個由整數組成的非空陣列所表示的非負整數，在該數的基礎上加一。

最高位數字存放在陣列的首位， 陣列中每個元素只儲存一個數字。

你可以假設除了整數 0 之外，這個整數不會以零開頭。

示例 1:

輸入: [1,2,3]
輸出: [1,2,4]
解釋: 輸入陣列表示數字 123。

示例 2:

輸入: [4,3,2,1]
輸出: [4,3,2,2]
解釋: 輸入陣列表示數字 4321。

程式碼：

class Solution:
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        digits[-1] = digits[-1] + 1
        return digits

if __name__ == '__main__':
    digits = [1,2,3]
    out = Solution()
    output = out.plusOne(digits)
    print(output)   
 

67. 二進位制求和

給定兩個二進位制字串，返回他們的和（用二進位制表示）。

輸入為非空字串且只包含數字 1 和 0。

示例 1:

輸入: a = "11", b = "1"
輸出: "100"

示例 2:

輸入: a = "1010", b = "1011"
輸出: "10101"

程式碼：

class Solution:
    def addBinary(self, a, b):
        """
        :type a: str
        :type b: str
        :rtype: str
        """
        intNum=int(a,2)+int(b,2)#2進位制轉換成10進位制，再求和
        return bin(intNum)[2:]#10進位制轉換成2進位制時前兩位為0b，需要去除

if __name__ == '__main__':
    a = "1010"
    b = "1011"
    out = Solution()
    output = out.addBinary(a, b)
    print(output)
 

69. x 的平方根

實現 int sqrt(int x) 函式。

計算並返回 x 的平方根，其中 x 是非負整數。

由於返回型別是整數，結果只保留整數的部分，小數部分將被捨去。

示例 1:

輸入: 4
輸出: 2

示例 2:

輸入: 8
輸出: 2
說明: 8 的平方根是 2.82842..., 
     由於返回型別是整數，小數部分將被捨去。

程式碼：

class Solution:
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        left = 0
        right = x
        while left < right:
            mid = int((left + right) / 2)
            if x < mid ** 2:
                right = mid
            else:
                left = mid + 1
        if left > 1:
            return left - 1
        else:
            return left

if __name__ == '__main__':
    x = 8
    out = Solution()
    output = out.mySqrt(x)
    print(output)
 

70. 爬樓梯

---

假設你正在爬樓梯。需要 n 階你才能到達樓頂。

每次你可以爬 1 或 2 個臺階。你有多少種不同的方法可以爬到樓頂呢？

注意：給定 n 是一個正整數。

示例 1：

輸入： 2
輸出： 2
解釋： 有兩種方法可以爬到樓頂。
1.  1 階 + 1 階
2.  2 階

示例 2：

輸入： 3
輸出： 3
解釋： 有三種方法可以爬到樓頂。
1.  1 階 + 1 階 + 1 階
2.  1 階 + 2 階
3.  2 階 + 1 階

程式碼：

class Solution:
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        # 從第三個開始，爬樓梯的方法是前面兩個的和（參考斐波那契數列）
        count = [1, 2]
        for i in range(2, n):
            # 利用列表儲存當前計算結果，避免重複計算
            count.append(count[i - 1] + count[i - 2])
        return count[n - 1]

if __name__ == '__main__':
    n = 3
    out = Solution()
    output = out.climbStairs(n)
    print(output) 

83. 刪除排序連結串列中的重複元素

給定一個排序連結串列，刪除所有重複的元素，使得每個元素只出現一次。

示例 1:

輸入: 1->1->2
輸出: 1->2

示例 2:

輸入: 1->1->2->3->3
輸出: 1->2->3

程式碼：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, x):
#         self.val = x
#         self.next = None

class Solution:
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        if head == None or head.next == None:
            return head
        p =head
        while p:
            while p.next and p.val == p.next.val:
                p.next = p.next.next
            p = p.next
        return head

88. 合併兩個有序陣列

給定兩個有序整數陣列 nums1 和 nums2，將 nums2 合併到 nums1 中，使得 num1 成為一個有序陣列。

說明:

• 初始化 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]

程式碼：

class Solution:
    def merge1(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        nums1[m:m + n] = nums2[:n]
        nums1.sort()
        return nums1

    def merge2(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: void Do not return anything, modify nums1 in-place instead.
        """
        while m > 0 and n > 0:
            if nums1[m-1] > nums2[n-1]:
                nums1[m+n-1] = nums1[m-1]
                m -= 1
            else:
                nums1[m+n-1] = nums2[n-1]
        if n > 0 :
            nums1[:n] = nums2[:n]
        return nums1

if __name__ == '__main__':
    nums1 = [1, 2, 3, 0, 0, 0]
    m = 3
    nums2 = [2, 5, 6]
    n = 3
    out = Solution()
    output = out.merge1( nums1, m, nums2, n)
    print(output)

100. 相同的樹

給定兩個二叉樹，編寫一個函式來檢驗它們是否相同。

如果兩個樹在結構上相同，並且節點具有相同的值，則認為它們是相同的。

示例 1:

輸入:       1         1
          / \       / \
         2   3     2   3

        [1,2,3],   [1,2,3]

輸出: true

示例 2:

輸入:      1          1
          /           \
         2             2

        [1,2],     [1,null,2]

輸出: false

示例 3:

輸入:       1         1
          / \       / \
         2   1     1   2

        [1,2,1],   [1,1,2]

輸出: false

程式碼：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isSameTree(self, p, q):
        """
        :type p: TreeNode
        :type q: TreeNode
        :rtype: bool
        """
        if not p and not q:#兩二叉樹皆為空，遞迴邊界，兩者皆為空返回真
            return True
        if p and q and p.val==q.val:
            l=self.isSameTree(p.left,q.left)#遞迴，每次重新從函式入口處進行，每次進行遞迴邊界判斷
            r=self.isSameTree(p.right,q.right)
            return l and r#and操作，需要l與r皆為true時，才返回真。只用最後一次遞迴邊界return值
        else:
            return False

101. 對稱二叉樹

給定一個二叉樹，檢查它是否是映象對稱的。

例如，二叉樹 [1,2,2,3,4,4,3] 是對稱的。

    1
   / \
  2   2
 / \ / \
3  4 4  3

但是下面這個 [1,2,2,null,3,null,3] 則不是映象對稱的:

    1
   / \
  2   2
   \   \
   3    3

說明:

如果你可以運用遞迴和迭代兩種方法解決這個問題，會很加分。

程式碼：

class Solution:
    def isSymmetrical(self, pRoot):
        if not pRoot:
            return True
        return self.recursiveTree(pRoot.left, pRoot.right)

    def recursiveTree(self, left, right):
        if not left and not right:
            return True
        if not left or not right:
            return False
        if left.val != right.val:
            return False
        return self.recursiveTree(left.left, right.right) and self.recursiveTree(left.right, right.left)
        

104. 二叉樹的最大深度

給定一個二叉樹，找出其最大深度。

二叉樹的深度為根節點到最遠葉子節點的最長路徑上的節點數。

說明: 葉子節點是指沒有子節點的節點。

示例：
給定二叉樹 [3,9,20,null,null,15,7]，

    3
   / \
  9  20
    /  \
   15   7

返回它的最大深度 3 。

程式碼：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def maxDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        leftDepth = self.maxDepth(root.left) + 1
        rightDepth = self.maxDepth(root.right) + 1
        return max(leftDepth, rightDepth)

107. 二叉樹的層次遍歷 II

給定一個二叉樹，返回其節點值自底向上的層次遍歷。 （即按從葉子節點所在層到根節點所在的層，逐層從左向右遍歷）

例如：
給定二叉樹 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回其自底向上的層次遍歷為：

[
  [15,7],
  [9,20],
  [3]
]

程式碼：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def levelOrderBottom(self, root):
        """
        :type root: TreeNode
        :rtype: List[List[int]]
        """

        #bfs廣度優先搜尋，不熟悉可以網上參考bfs程式碼
        if not root:
            return []#為空則返回空列表
        queue = [root]#使用列表實現佇列的功能，首先儲存root
        res = []
        while queue:#當queue不為空時
            nodes = []#存節點，每次迴圈前置空，每次只裝一部分
            node_values = []#存節點的值
            for node in queue:
                if node.left:
                    nodes.append(node.left)#將左子樹裝入佇列中
                if node.right:
                    nodes.append(node.right)
                node_values += [node.val]#因為每次迴圈node_values都會置空，所以最終結果儲存在res裡，node_values只是一小部分結果
            res = [node_values] + res#實現從底到頂，node_values放前面.
            queue = nodes#將新新增的節點重新賦值給queue

        return res

108. 將有序陣列轉換為二叉搜尋樹

將一個按照升序排列的有序陣列，轉換為一棵高度平衡二叉搜尋樹。

本題中，一個高度平衡二叉樹是指一個二叉樹每個節點 的左右兩個子樹的高度差的絕對值不超過 1。

示例:

給定有序陣列: [-10,-3,0,5,9],

一個可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面這個高度平衡二叉搜尋樹：

      0
     / \
   -3   9
   /   /
 -10  5

程式碼：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def sortedArrayToBST(self, nums):
        """
        :type nums: List[int]
        :rtype: TreeNode
        """
        if not nums:
            return None
        mid = len(nums)//2  #//	取整除 - 返回商的整數部分（向下取整）
        root = TreeNode(nums[mid])
        root.left = self.sortedArrayToBST(nums[:mid])
        root.right = self.sortedArrayToBST(nums[mid+1:])
        return root

110. 平衡二叉樹

給定一個二叉樹，判斷它是否是高度平衡的二叉樹。

本題中，一棵高度平衡二叉樹定義為：

一個二叉樹每個節點 的左右兩個子樹的高度差的絕對值不超過1。

示例 1:

給定二叉樹 [3,9,20,null,null,15,7]

    3
   / \
  9  20
    /  \
   15   7

返回 true 。

示例 2:

給定二叉樹 [1,2,2,3,3,null,null,4,4]

       1
      / \
     2   2
    / \
   3   3
  / \
 4   4

返回 false 。

思路：按照求樹的最大深度去做，只是中間加一個判斷，判斷左子樹的最大深度和右子樹的最大深度之差是否大於1

程式碼：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def isBalanced(self, root):
        """
        :type root: TreeNode
        :rtype: bool
        """
        if not root:
            return True
        left = self.TreeDepth(root.left)
        right = self.TreeDepth(root.right)
        if abs(left - right) > 1:
            return False
        return self.isBalanced(root.left) and self.isBalanced(root.right)
        
        
    def TreeDepth(self, root):
        if not root:
            return 0
        left = self.TreeDepth(root.left)
        right = self.TreeDepth(root.right)
        return max(left, right) + 1

111. 二叉樹的最小深度

給定一個二叉樹，找出其最小深度。

最小深度是從根節點到最近葉子節點的最短路徑上的節點數量。

說明: 葉子節點是指沒有子節點的節點。

示例:

給定二叉樹 [3,9,20,null,null,15,7],

    3
   / \
  9  20
    /  \
   15   7

返回它的最小深度  2.

程式碼：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def minDepth(self, root):
        """
        :type root: TreeNode
        :rtype: int
        """
        if not root:
            return 0
        leftDepth = self.minDepth(root.left)
        rightDepth = self.minDepth(root.right)
        if not root.left or not root.right:
            return max(leftDepth, rightDepth) + 1
        return min(leftDepth, rightDepth) + 1

112. 路徑總和

給定一個二叉樹和一個目標和，判斷該樹中是否存在根節點到葉子節點的路徑，這條路徑上所有節點值相加等於目標和。

說明: 葉子節點是指沒有子節點的節點。

示例: 
給定如下二叉樹，以及目標和 sum = 22，

              5
             / \
            4   8
           /   / \
          11  13  4
         /  \      \
        7    2      1

返回 true, 因為存在目標和為 22 的根節點到葉子節點的路徑 5->4->11->2。

程式碼：

# Definition for a binary tree node.
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def hasPathSum(self, root, sum):
        """
        :type root: TreeNode
        :type sum: int
        :rtype: bool
        """
        if not root :
            return False
        sum -= root.val #總和減去根節點值
        if sum == 0 and not root.left and not root.right:
            return True
        return self.hasPathSum(root.left, sum) or self.hasPathSum(root.right, sum)