摘要：給定一個大小為的數(shù)組，找到其中的眾數(shù)。第五題合并兩個有序數(shù)組難度簡單給定兩個有序整數(shù)數(shù)組和，將合并到中，使得成為一個有序數(shù)組。說明初始化和的元素數(shù)量分別為和。第六題二叉樹的最大深度難度簡單給定一個二叉樹，找出其最大深度。

做做做題，慢慢上手了就覺得刷題速度變快了，果然還是有點笨~
希望最后一竅快點通吧~

第一題

169. 求眾數(shù)
難度：簡單
給定一個大小為 n 的數(shù)組，找到其中的眾數(shù)。眾數(shù)是指在數(shù)組中出現(xiàn)次數(shù)大于? n/2 ?的元素。
你可以假設數(shù)組是非空的，并且給定的數(shù)組總是存在眾數(shù)。給定一個大小為 n 的數(shù)組，找到其中的眾數(shù)。眾數(shù)是指在數(shù)組中出現(xiàn)次數(shù)大于? n/2 ?的元素。
你可以假設數(shù)組是非空的，并且給定的數(shù)組總是存在眾數(shù)。
我的題解：

class Solution(object):
    def majorityElement(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        value = nums[0]
        count = 0 
        for i in nums:
            if value == i:
                count = count + 1
            else:
                if count == 0:
                    value = i
                    count = 1
                    continue
                count =count - 1
        return value    

我的思路：
這題參考了評論的題解，做了兩次，明白了來龍去脈。
中心思想就是：按順序遍歷數(shù)字，存在不同的數(shù)字就抵消相應的count，存在相同數(shù)字則增加，最后總能獲取到唯一一個不會被抵消全部的數(shù)字，就是眾數(shù)了。

第二題

136. 只出現(xiàn)一次的數(shù)字
難度：簡單
給定一個非空整數(shù)數(shù)組，除了某個元素只出現(xiàn)一次以外，其余每個元素均出現(xiàn)兩次。找出那個只出現(xiàn)了一次的元素。

說明：
你的算法應該具有線性時間復雜度。 你可以不使用額外空間來實現(xiàn)嗎？

我的題解：

class Solution(object):
    def singleNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        a = 0 
        for num in nums:
            a = a ^ num
        return a

我的思路：
異或，兩個相同的數(shù)字的計算結(jié)果為0，最后剩余的則為唯一值

第三題

83. 刪除排序鏈表中的重復元素
難度：簡單
給定一個排序鏈表，刪除所有重復的元素，使得每個元素只出現(xiàn)一次。
我的題解：

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

class Solution(object):
    def deleteDuplicates(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        a = head
        if not a:
            return a
        while head.next:
            if head.next.val == head.val and head.next.next == None:
                head.next = None
            elif head.next.val == head.val and head.next.next:
                head.next = head.next.next
            else:
                head = head.next
        return a

我的思路：
當存在前后節(jié)點一致的時候，則前一個節(jié)點的next指向后一個節(jié)點的next，跳過即可。
其他：
因為鏈表的結(jié)構(gòu)指向的是內(nèi)存，遍歷完之后指向最后的節(jié)點，所以需要一個a指向頭結(jié)點。

第四題

100. 相同的樹
難度：簡單
給定兩個二叉樹，編寫一個函數(shù)來檢驗它們是否相同。
如果兩個樹在結(jié)構(gòu)上相同，并且節(jié)點具有相同的值，則認為它們是相同的。
我的題解：

# 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 isSameTree(self, p, q):
        """
        :type p: TreeNode
        :type q: TreeNode
        :rtype: bool
        """
        if not p and not q:
            return True
        if p and q:
            if p.val == q.val:
                return self.isSameTree(p.left,q.left) and self.isSameTree(p.right,q.right)
            else:
                return False
        else:
            return False

我的思路：
遞歸，主要是判斷兩個節(jié)點的值是否一致，一致的前提下，判斷向下的左右節(jié)點及更向下是否一致。

第五題

88. 合并兩個有序數(shù)組
難度：簡單
給定兩個有序整數(shù)數(shù)組 nums1 和 nums2，將 nums2 合并到 nums1 中，使得 num1 成為一個有序數(shù)組。

說明:

初始化 nums1 和 nums2 的元素數(shù)量分別為 m 和 n。
你可以假設 nums1 有足夠的空間（空間大小大于或等于 m + n）來保存 nums2 中的元素。

我的題解：

class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None 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]
                n -= 1
        if n >0 :
            nums1[:n] = nums2[:n]class Solution(object):
    def merge(self, nums1, m, nums2, n):
        """
        :type nums1: List[int]
        :type m: int
        :type nums2: List[int]
        :type n: int
        :rtype: None 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]
                n -= 1
        if n >0 :
            nums1[:n] = nums2[:n]

我的思路：
因為nums1[m+n]為空的部分，所以我們可以從后向前寫，判斷兩個數(shù)組的值，更大的數(shù)字不斷向后挪，挪到一定程度的時候，剩余部分則為更長的數(shù)組的剩余未判斷部分。

第六題

104. 二叉樹的最大深度
難度：簡單
給定一個二叉樹，找出其最大深度。
二叉樹的深度為根節(jié)點到最遠葉子節(jié)點的最長路徑上的節(jié)點數(shù)。

說明: 葉子節(jié)點是指沒有子節(jié)點的節(jié)點。

我的題解：

# 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 not root:
            return 0
        if root.right is None and root.left is None:
            return 1
        return max(self.maxDepth(root.right),self.maxDepth(root.left))+1
            

我的思路：

遞歸圖上為調(diào)用棧的情況，不斷向下尋找更遠的根節(jié)點。

基線判斷為：節(jié)點是否為空

遞歸判斷為：節(jié)點不為空且左節(jié)點或右節(jié)點還有值

最近在看《算法圖解》，感覺對遞歸理解更深一點，但學習之后重要的是實踐，還是要多做題。