Leetcode刷题记录-20181017

38. Count and Say    

递归算法

class Solution:
    def handleN(self,l):    
        key = ''
        tag = 0
        result = ''
        
        key = l[0]
        for i in l:
            if i == key:
                tag +=1
            else:
                result +=str(tag)+key
                key = i
                tag = 1
        result +=str(tag)+key
        return result
    
    def countAndSay(self, n):
        """
        :type n: int
        :rtype: str
        """
        if n == 1:
            return '1'
        else:
            return self.handleN(self.countAndSay(n-1))

66. Plus One    

设定标记Tag，表明低位数字是否进1；

反向遍历digits，依次判断元素与1之和是否为10；如为10， 对元素进行置零处理，并标记Tag=1

最后判断Tag是否为1，为1表明digits[0]数字需要进1，更新数组输出。

代码如下：

class Solution:
    def judge(self,n,tag):
        if tag:
            n +=1
    def plusOne(self, digits):
        """
        :type digits: List[int]
        :rtype: List[int]
        """
        m = len(digits)
        tag = 1
        for i in range(m-1,-1,-1):
            digits[i] +=tag
            tag = 0
            if digits[i]==10:
                tag = 1
                digits[i] = 0
        if tag == 1:
            return [1] + digits            
        return digits

 67. Add Binary    

return str(bin(int(a,2)+int(b,2)))[2:]

69. Sqrt(x)    

牛顿迭代法

class Solution:
    def mySqrt(self, x):
        """
        :type x: int
        :rtype: int
        """
        y = 1
        while abs(y*y -x) > 0.000001:
            y = 0.5*(x/y+y)
        return int(y)

53. Maximum Subarray  

动态规划方法、Kadane Algorithm算法

class Solution:
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        sums = nums[0]
        local = sums 
        for i in nums[1:]:
            sums = sums + i
            local = max(sums,local)
            if sums < i:
                sums = i
            else:
                pass
            local = max(sums,local)
        return local

70.Climbing Stairs  

递归思想， O(n) = O(n-1)+O(n-2)

class Solution:
    def climbStairs(self, n):
        """
        :type n: int
        :rtype: int
        """
        a = 1
        b = 2
        if n ==1:
            return a
        if n == 2:
            return b
        else:
            for i in range(2,n):
                a,b = b,a+b
            return b

83. Remove Duplicates from Sorted List    

依次判断每个元素与前一个元素是否相等，相等则删除节点，不相等向后判断

# 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
        """
        
        l = ListNode(0)
        l = head
        m = l
        if head == None or head.next == None  :
            return head
        else:
            aft = head.next
            while aft != None:
                if aft.val == l.val:
                    l.next = aft.next
                    aft = l.next
                else:
                    l = aft
                    aft = aft.next
        return m

88.Merge Sorted Array    

双指针，从最后元素开始依次向前判断两个数组，大者插到nums1的末尾，指针向前

class Solution:
    def merge(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.
        """
        i = m 
        j = n
        while i!= 0 and j!=0:
            if nums1[i-1] > nums2[j-1]:
                nums1[i+j-1] = nums1[i-1]
                i -=1
            else:
                nums1[i+j-1] = nums2[j-1]
                j -=1
        while j!=0:
            nums1[i+j-1]=nums2[j-1]
            j -=1