lintcode刷題筆記（一）

Description

給出一個字符串（假設長度最長爲1000），求出它的最長迴文子串，你能夠假定只有一個知足條件的最長迴文串。express

樣例 1:數組

輸入:"abcdzdcab"
輸出:"cdzdc"

樣例 2:markdown

輸入:"aba"
輸出:"aba"

#coding:utf-8

class Solution:
  
    def longestPalindrome(self, s):
        # write your code here
        length = len(s)
        sub="" if length>1 else s
        m = 0
        for i in range(length-1):
            len1,sub1 = expandAroundCenter(s,m,i,i)
            len2,sub2 = expandAroundCenter(s,m,i,i+1)
            if len1>m:
                m = len1
                sub = sub1
            if len2>m:
                m = len2
                sub = sub2
        return sub
                
def expandAroundCenter(s,m,i,j):
    sub=""
    while i>=0 and j<=len(s)-1:
        if s[i]==s[j]:
            if j-i+1>m:
                m = j-i+1
                sub = s[i:j+1]
            i=i-1
            j=j+1        
        else:
            break        
    return m,sub
        
if __name__=="__main__":
    s = Solution()
    print(s.longestPalindrome("abcdzdcab"))
    print(s.longestPalindrome("aba"))
    print(s.longestPalindrome("a"))
    print(s.longestPalindrome("ccc"))
    print(s.longestPalindrome("cc"))
    print(s.longestPalindrome("cccc"))

View Code

（二）. 二分搜索法和log(n)算法（Binary Search & Log(n) Algorithm）數據結構

458. Last Position of Target

　　給一個升序數組，找到 target 最後一次出現的位置，若是沒出現過返回 -1

　　樣例：

　　輸入：nums = [1,2,2,4,5,5], target = 2
　　輸出：2

　　輸入：nums = [1,2,2,4,5,5], target = 6
　　輸出：-1

#coding:utf-8

class Solution:
    #獲取最右邊的
    def lastPosition(self, nums, target):
        start = 0
        end = len(nums)-1
        index = -1
        while start<=end:
            mid = (start+end)//2
            if nums[mid]<=target:
                start = mid+1
            elif nums[mid]>target:
                end = mid-1
            
        if start>0 and nums[start-1]==target:
            index = start-1
        return index
    #獲取最左邊的    
    def firstPosition(self, nums, target):
        start = 0
        end = len(nums)-1
        index = -1
        while start<=end:
            mid = (start+end)//2
            if nums[mid]<target:
                start = mid+1
            elif nums[mid]>=target:
                end = mid-1
            
        if end<len(nums)-1 and nums[end+1]==target:
            index = end+1
        return index
        
if __name__=="__main__":
    s = Solution()
    print(s.lastPosition(nums = [], target = 10))
    print(s.lastPosition(nums = [1,2,2,4,5,5], target = 2))
    print(s.lastPosition(nums = [1,2,2,4,5,5], target = 6))
    print(s.lastPosition(nums = [1,2,2,2,2,2], target = 2))
    
    
    print(s.firstPosition(nums = [1,2,2,4,5,5], target = 2))
    print(s.firstPosition(nums = [1,2,2,4,5,5], target = 6))
    print(s.firstPosition(nums = [1,2,2,2,2,2], target = 2))

458

585. Maximum Number in Mountain Sequence

　　給 n 個整數的山脈數組，即先增後減的序列，找到山頂（最大值）

Example

例1:

輸入: nums = [1, 2, 4, 8, 6, 3] 
輸出: 8

例2:

輸入: nums = [10, 9, 8, 7], 
輸出: 10

#coding:utf-8

class Solution:

    def mountainSequence(self, nums):
        # write your code here
        if len(nums)==1:
            return nums[0]
        for i in range(len(nums)-1):
            if nums[i+1]<nums[i]:
                return nums[i]

585

460. Find K Closest Elements

Description

　　給一個目標數 target, 一個非負整數 k, 一個按照升序排列的數組 A。在A中找與target最接近的k個整數。返回這k個數並按照與target的接近程度從小到大排序，若是接近程度至關，那麼小的數排在前面。

k是一個非負整數，而且老是小於已排序數組的長度。
給定數組的長度是正整數, 不會超過 $10^44$
數組中元素的絕對值不會超過 $10^44$

Example

樣例 1:

輸入: A = [1, 2, 3], target = 2, k = 3
輸出: [2, 1, 3]

樣例 2:

輸入: A = [1, 4, 6, 8], target = 3, k = 3
輸出: [4, 1, 6]

class Solution:
    """
    @param A: an integer array
    @param target: An integer
    @param k: An integer
    @return: an integer array
    """
    def kClosestNumbers(self, A, target, k):
        # write your code here
        sub=100000
        nearest=-1
        start = 0
        end = len(A)-1
        while start<=end:
            mid = (start+end)//2
            temp = abs(A[mid]-target)
            if temp<sub:
                sub = temp
                nearest = mid
            if A[mid]>target:
                end = mid-1
            elif A[mid]<target:
                start = mid+1
            elif A[mid]==target:
                break
        out=[]
        if nearest!=-1 and k>0:
            out.append(A[nearest])
            i=1
            left,right=nearest-1,nearest+1
            while left>=0 and right<=len(A)-1 and i<k:
                if abs(A[left]-target)<=abs(A[right]-target):
                    out.append(A[left])
                    left = left-1
                else:
                    out.append(A[right])
                    right = right+1
                i = i+1
                
            if i<k and left<0:
                out.extend(A[right:right+k-i])
            if i<k and right>len(A)-1:
                out.extend(A[left:left-(k-i):-1])
        return out
if __name__=="__main__":
    s = Solution()
    print(s.kClosestNumbers( A = [1, 2, 3], target = 2, k = 3))
    print(s.kClosestNumbers(A = [1, 4, 6, 8], target = 3, k = 3))
    print(s.kClosestNumbers(A = [1,4,6,10,20], target = 21, k = 4))
    print(s.kClosestNumbers(A = [1,2,4,5,6,7,8,10], target = 5, k = 0))
    print(s.kClosestNumbers(A = [1,4,8,12,16,28,38], target = 12, k = 4))
    print(s.kClosestNumbers(A = [1,4,6,8], target = 3, k = 3))

460

428. Pow(x,n)

　　實現 pow(x, n). (n是一個整數,不用擔憂精度，當答案和標準輸出差絕對值小於1e-3時都算正確)

Example

樣例 1:

輸入: x = 9.88023, n = 3
輸出: 964.498

樣例 2:

輸入: x = 2.1, n = 3
輸出: 9.261

樣例 3:

輸入: x = 1, n = 0
輸出: 1

#coding:utf-8


class Solution:

    def myPow(self,x,n):
        if n==0:
            return 1
        elif n<0:
            x = 1/x
            n = -n
        return recursive_pow(x,n)
            
def recursive_pow(x,n):            
    if n==1:
        return x
    else:
        half = recursive_pow(x,n//2)
        if n%2==1:
            return half*half*x
        else:
            return half*half
            
if __name__=="__main__":
    s = Solution()
    print(s.myPow(x = 9.88023, n = 3))
    print(s.myPow(x = 2.1, n = 3))
    print(s.myPow( x = 1, n = 0))
    print(s.myPow( x = 2.00000, n = -2147483648))

428

159.Find Minimum Rotated Sorted Array

　　假設一個排好序的數組在其某一未知點發生了旋轉（好比0 1 2 4 5 6 7 可能變成4 5 6 7 0 1 2）。你須要找到其中最小的元素

Example

Example 1:

輸入：[4, 5, 6, 7, 0, 1, 2]
輸出：0
解釋：
數組中的最小值爲0

Example 2:

輸入：[2,1]
輸出：1
解釋：
數組中的最小值爲1

#coding:utf-8
class Solution:
   
    def findMin(self, nums):
        
        length = len(nums)
        if length==1:
            return nums[0]
        elif length>1:
            if nums[0]<nums[-1]:
                return nums[0]
            else:
                left,right = 0,length-1
                while left<right:
                    mid = (left+right)//2
                    if nums[mid]>nums[left]:
                        left = mid
                    elif nums[mid]<nums[left]:
                        right = mid
                    else:              #mid和left相等時
                        break
            return nums[right]
if __name__=="__main__":
    s = Solution()
    print(s.findMin([4, 5, 6, 7, 0, 1, 2]))
    print(s.findMin([2,1]))

159

140. Fast Power

　　計算an % b，其中a，b和n都是32位的非負整數。

Example

例如 231 % 3 = 2

例如 1001000 % 1000 = 0

Challenge

O(logn)

#coding:utf-8

#原理： (A*B)%p = ((A%p)*(B%p))%p

"""
@param a: A 32bit integer
@param b: A 32bit integer
@param n: A 32bit integer
@return: An integer
 """
class Solution:
  
    def fastPower(self, a, b, n):
        if n==0:
            return 1%b
        elif n==1:
            return a%b
        else:
            half_remainder = self.fastPower(a,b,n//2)
            if n%2==1:
                return (half_remainder*half_remainder*a)%b
            else:
                return (half_remainder*half_remainder)%b
if __name__=="__main__":
    s = Solution()
    print(s.fastPower(2,3,31))
    print(s.fastPower(3,1,0))
    print(s.fastPower(100,1000,1000))

140

75. Find Peak Elements

　　你給出一個整數數組(size爲n)，其具備如下特色：

相鄰位置的數字是不一樣的
A[0] < A[1] 而且 A[n - 2] > A[n - 1]

假定P是峯值的位置則知足A[P] > A[P-1]且A[P] > A[P+1]，返回數組中任意一個峯值的位置。

數組保證至少存在一個峯
若是數組存在多個峯，返回其中任意一個就行
數組至少包含 3 個

Example

樣例 1:
	輸入:  [1, 2, 1, 3, 4, 5, 7, 6]
	輸出:  1 or 6
	
	解釋:
	返回峯頂元素的下標


樣例 2:
	輸入: [1,2,3,4,1]
	輸出:  3

#coding:utf-8

#參考題解：https://leetcode-cn.com/problems/find-peak-element/solution/hua-jie-suan-fa-162-xun-zhao-feng-zhi-by-guanpengc/
#注意峯值的方向，先上升後降低

"""
@param A: An integers array.
@return: return any of peek positions.
"""
class Solution:

    def findPeak(self, A):
        # write your code here
        length = len(A)
        if length==1:
            return 0
        elif length>2:
            left,right = 0, length-2
            while left<right:
                mid = (left+right)//2
                if A[mid]>A[mid+1]:  #降低趨勢
                    right = mid
                elif A[mid]<A[mid+1]: #上升趨勢
                    left = mid+1
            return left
if __name__=="__main__":
    s = Solution()
    print(s.findPeak([1, 2, 1, 3, 4, 5, 7, 6]))
    print(s.findPeak([1,2,3,4,1]))

74. First Bad Version

　　代碼庫的版本號是從 1 到 n 的整數。某一天，有人提交了錯誤版本的代碼，所以形成自身及以後版本的代碼在單元測試中均出錯。請找出第一個錯誤的版本號。

你能夠經過 isBadVersion 的接口來判斷版本號 version 是否在單元測試中出錯，具體接口詳情和調用方法請見代碼的註釋部分。

Example

n = 5: isBadVersion(3) -> false isBadVersion(5) -> true isBadVersion(4) -> true 所以能夠肯定第四個版本是第一個錯誤版本。

Challenge

調用 isBadVersion 的次數越少越好

Example

n = 5:

    isBadVersion(3) -> false
    isBadVersion(5) -> true
    isBadVersion(4) -> true

所以能夠肯定第四個版本是第一個錯誤版本。

Challenge

調用 isBadVersion 的次數越少越好

62. Search in Rotated Sorted Array

　　假設有一個排序的按未知的旋轉軸旋轉的數組(好比，0 1 2 4 5 6 7 可能成爲4 5 6 7 0 1 2)。給定一個目標值進行搜索，若是在數組中找到目標值返回數組中的索引位置，不然返回-1。你能夠假設數組中不存在重複的元素。

Example

例1:

輸入: [4, 5, 1, 2, 3] and target=1, 
輸出: 2.

例2:

輸入: [4, 5, 1, 2, 3] and target=0, 
輸出: -1.

Challenge

O(logN) 時間限制

class Solution:
    """
    @param A: an integer rotated sorted array
    @param target: an integer to be searched
    @return: an integer
    """
    def search(self, A, target):
        # write your code here
        length = len(A)
        if length>0:
            left,right=0,length-1
            if A[0]==target:
                return 0
            elif A[0]>target:
                while left<=right:
                    mid=(left+right)//2
                    if A[0]<=A[mid]:
                        left = mid+1
                    else:
                        if A[mid]>target:
                            right = mid-1
                        elif A[mid]<target:
                            left = mid+1
                        else:
                            return mid
            else:
                while left<=right:
                    mid=(left+right)//2
                    if A[0]>=A[mid]:
                        right=mid-1
                    else:
                        if A[mid]>target:
                            right = mid-1
                        elif A[mid]<target:
                            left = mid+1
                        else:
                            return mid
        return -1
if __name__=="__main__":
    s = Solution()
    print(s.search([4, 5, 1, 2, 3],1))
    print(s.search([4, 5, 1, 2, 3],0))
    print(s.search([4, 3],3))

（三）. 雙指針問題（Two Pointers）

228. Middle of Linked List

　　找鏈表的中點。

Example

樣例 1:

輸入:  1->2->3
輸出: 2	
樣例解釋: 返回中間節點的值

樣例 2:

輸入:  1->2
輸出: 1	
樣例解釋: 若是長度是偶數，則返回中間偏左的節點的值。

Challenge

若是鏈表是一個數據流，你能夠不從新遍歷鏈表的狀況下獲得中點麼？

#coding:utf-8


#Definition of ListNode
class ListNode(object):
    def __init__(self, val, next=None):
        self.val = val
        self.next = next

"""
@param head: the head of linked list.
@return: a middle node of the linked list
"""
class Solution:
    
    def middleNode(self, head):
        # write your code here
        slow = fast = head
        if head:
            while fast.next!=None and fast.next.next!=None:
                slow = slow.next
                fast = fast.next.next
        return slow
if __name__=="__main__":
    s = Solution()
    list1 = ListNode(1,ListNode(2,ListNode(3)))
    list2 = ListNode(1,ListNode(2))
    print(s.middleNode(list1).val)
    print(s.middleNode(list2).val)

228

607 Two Sum III -Data structure design

　　設計b並實現一個 TwoSum 類。他須要支持如下操做:add 和 find。
　　　　add -把這個數添加到內部的數據結構。
　　　　find -是否存在任意一對數字之和等於這個值

Example

樣例 1:

add(1);add(3);add(5);
find(4)//返回true
find(7)//返回false

#coding:utf-8

#思路：遍歷字典，求sum和遍歷元素的差， 判斷差是否也在字典中
class TwoSum:
    """
    @param number: An integer
    @return: nothing
    """
    def __init__(self):
        self.numbers=dict()
        
    def add(self, number):
        # write your code here
        if number not in self.numbers:
            self.numbers[number]=1
        else:
            self.numbers[number]+=1

    """
    @param value: An integer
    @return: Find if there exists any pair of numbers which sum is equal to the value.
    """
    def find(self, value):
        # write your code here
        for key in self.numbers:
            target = value-key
            if target in self.numbers:
                if target!=key or self.numbers[target]>1:
                    return True
        return False


#按順序插入列表，find時先後指針遍歷
# class TwoSum:
    # """
    # @param number: An integer
    # @return: nothing
    # """
    # def __init__(self):
        # self.numbers=[]
        
    # def add(self, number):
        # # write your code here
        # length = len(self.numbers)
        # if length==0:
            # self.numbers.append(number)
        # for i in range(length):
            # if self.numbers[i]>number:
                # self.numbers.insert(i,number)
                # break
        # if len(self.numbers)==length:
            # self.numbers.append(number)

    # """
    # @param value: An integer
    # @return: Find if there exists any pair of numbers which sum is equal to the value.
    # """
    # def find(self, value):
        # # write your code here
        # i,j=0,len(self.numbers)-1
        # while i<j:
            # if self.numbers[i]+self.numbers[j]==value:
                # return True
            # elif self.numbers[i]+self.numbers[j]>value:
                # j = j-1
            # else:
                # i = i+1
        # return False
if __name__=="__main__":
    s = TwoSum()
    # s.add(1)
    # s.add(3)
    # s.add(5)
    # print(s.find(4))
    # print(s.find(7))
    
    # s.add(2)
    # s.add(3)
    # print(s.find(4))
    # print(s.find(5))
    # print(s.find(6))
    # s.add(3)
    # print(s.find(6))
    
    s.add(2)
    s.add(2)
    s.add(2)
    print(s.find(6))
    s.add(2)
    print(s.find(4))
    print(s.find(5))
    s.add(1)
    print(s.find(2))
    print(s.find(3))

607

539. Move Zeros

　　給一個數組 nums 寫一個函數將 0 移動到數組的最後面，非零元素保持原數組的順序

　　　　1.必須在原數組上操做
　　　　2.最小化操做數

Example

例1:

輸入: nums = [0, 1, 0, 3, 12],
輸出: [1, 3, 12, 0, 0].

例2:

輸入: nums = [0, 0, 0, 3, 1],
輸出: [3, 1, 0, 0, 0].

#coding:utf-8


"""
思路：
快慢指針：假設咱們有一個新數組，有 2 根指針分別從老數組和新數組從前日後走，稱老數組上的指針爲「讀指針」，新數組上的指針爲「寫指針」；只有當讀指針所指向的數值非0時，纔將讀指針所指的數值寫入到寫指針所指的空間上，而後兩根指針再繼續向前走；當老數組遍歷完時，只要將新數組繼續填 0 直到新老數組長度一致便可。題目要求「就地操做」，那麼實際上就不須要開這個新數組，只要讓兩根指針都在原數組上往前走就行：這是由於，讀指針因爲會跳過非 0 空間，其掃描速度遠快於寫指針，全部被讀指針掃描過的非零值都會經過寫指針寫入「新的空間」中，所以全部被寫指針覆蓋掉的非零值，以前一定已經保存過了。該方法時間複雜度 O(n)，空間複雜度 O(1)
"""

"""
@param nums: an integer array
@return: nothing
"""
class Solution:
    
    def moveZeroes(self, nums):
        # write your code here
        i=j=0
        while i<len(nums):
            if nums[i]!=0:
                nums[j]=nums[i]
                j = j+1
            i = i+1
        while j<i:
            nums[j]=0
            j = j+1
        return nums
if __name__=="__main__":
    s = Solution()
    print(s.moveZeroes([0, 1, 0, 3, 12]))
    print(s.moveZeroes([0, 0, 0, 3, 1]))

539

521 Remove Duplicate Numbers in Array

　　給一個整數數組，去除重複的元素。

　　你應該作這些事

　　　　1.在原數組上操做
　　　　2.將去除重複以後的元素放在數組的開頭
　　　　3.返回去除重複元素以後的元素個數

Example

例1:

輸入:
nums = [1,3,1,4,4,2]
輸出:
（nums變爲[1,3,4,2,?,?]）
4

解釋:
1. 將重複的整數移動到 nums 的尾部 => nums = [1,3,4,2,?,?].
2. 返回 nums 中惟一整數的數量  => 4.
事實上咱們並不關心你把什麼放在了 ? 處, 只關心沒有重複整數的部分.

例2:

輸入:
nums = [1,2,3]
輸出: 
(nums變爲[1,2,3])
3
[1,2,3]

#coding:utf-8


"""
@param nums: an array of integers
@return: the number of unique integers
"""

#時間複雜度O(n),空間複雜度O(n)
class Solution:
    
    def deduplication(self, nums):
        # write your code here
        nums_set=set()
        i=0
        for num in nums:
            if num not in nums_set:
                nums_set.add(num)
                nums[i]=num
                i = i+1
                
        return i 
        
        
        

#排序後使用雙指針，時間複雜度O(nlogn)，空間複雜度O(1)
# class Solution:
    
    # def deduplication(self, nums):
        # # write your code here
        # length = len(nums)
        # if length<=1:
            # return length
        # quicksort(nums,0,length-1)
        # i=j = 1
        # while i<length:
            # if nums[i]!=nums[i-1]:
                # nums[j]=nums[i]
                # j = j+1
            # i = i+1
        # return j
        
        
# def quicksort(nums,start,end):
    # if start<end:
        # pivot = start
        # left,right=start+1,end
        # while left<=right:
            # while left<=right and nums[left]<=nums[pivot]:
                # left = left+1
            # while left<=right and nums[right]>nums[pivot]:
                # right= right-1
            # if left<=right:
                # nums[left],nums[right]=nums[right],nums[left]
        # nums[right],nums[pivot]=nums[pivot],nums[right]
        # quicksort(nums,start,right-1)
        # quicksort(nums,right+1,end)
        
if __name__=="__main__":
    
    s = Solution()
    print(s.deduplication([1,3,1,4,4,2]))
    print(s.deduplication(nums = [1,2,3]))

521

464 Sort Integers II

　　給一組整數，請將其在原地按照升序排序。使用歸併排序，快速排序，堆排序或者任何其餘 O(n log n) 的排序算法。

Description

中文

English

給一組整數，請將其在原地按照升序排序。使用歸併排序，快速排序，堆排序或者任何其餘 O(n log n) 的排序算法。

Have you met this question in a real interview?

Example

例1：

輸入：[3,2,1,4,5]，
輸出：[1,2,3,4,5]。

例2：

輸入：[2,3,1]，
輸出：[1,2,3]。

"""
@param A: an integer array
@return: nothing
"""
class Solution:
    
    def sortIntegers2(self, A):
        # write your code here
        quicksort(A,0,len(A)-1)
        return A

def quicksort(alist,start,end):
    if start<end:
        pivot=alist[start]
        left,right = start,end
        while left<right:
            while left<right and alist[right]>=pivot:
                right-=1
            alist[left],alist[right]=alist[right],alist[left]
            while left<right and alist[left]<=pivot:
                left+=1
            alist[right],alist[left]=alist[left],alist[right]
        quicksort(alist,start,left-1)
        quicksort(alist,left+1,end)
if __name__=="__main__":
    s = Solution()
    print(s.sortIntegers2([3, 2, 1, 4, 5]))
    print(s.sortIntegers2([2, 3, 1]))

464

608. Two Sum II- Input array is sorted

　　給定一個已經 按升序排列 的數組，找到兩個數使他們加起來的和等於特定數。
　　函數應該返回這兩個數的下標，index1必須小於index2。注意返回的值不是 0-based

Example

例1:

輸入: nums = [2, 7, 11, 15], target = 9 
輸出: [1, 2]

例2:

輸入: nums = [2,3], target = 5
輸出: [1, 2]

class Solution:
    """
    @param nums: an array of Integer
    @param target: target = nums[index1] + nums[index2]
    @return: [index1 + 1, index2 + 1] (index1 < index2)
    """
    def twoSum(self, nums, target):
        # write your code here
        length = len(nums)
        if length>1:
            i,j=0,length-1
            while i<j:
                if nums[i]+nums[j]==target:
                    return i+1,j+1
                elif nums[i]+nums[j]<target:
                    i+=1
                else:
                    j-=1
if __name__=="__main__":
    s = Solution()
    print(s.twoSum(nums = [2, 7, 11, 15], target = 9 ))
    print(s.twoSum(nums = [2,3], target = 5 ))

608

143 Sort Colors II

　　給定一個有n個對象（包括k種不一樣的顏色，並按照1到k進行編號）的數組，將對象進行分類使相同顏色的對象相鄰，並按照1,2，...k的順序進行排序。

不能使用代碼庫中的排序函數來解決這個問題
k <= n

Example

樣例1

輸入: 
[3,2,2,1,4] 
4
輸出: 
[1,2,2,3,4]

樣例2

輸入: 
[2,1,1,2,2] 
2
輸出: 
[1,1,2,2,2]

Challenge

一個至關直接的解決方案是使用計數排序掃描2遍的算法。這樣你會花費O(k)的額外空間。你否能在不使用額外空間的狀況下完成？

#coding:utf-8

#思路參考：https://www.cnblogs.com/libaoquan/p/7226211.html （計數排序/桶排序改進）
#輸入[3,2,2,1,4],進行一次遍歷後變化過程以下：
# [3, 2, 2, 1, 4]
# [2, 2, -1, 1, 4]
# [2, -1, -1, 1, 4]
# [0, -2, -1, 1, 4]
# [-1, -2, -1, 0, 4]
# [-1, -2, -1, -1, 0]


"""
@param colors: A list of integer
@param k: An integer
@return: nothing
"""
class Solution:
    
    def sortColors2(self, colors, k):
        length = len(colors)
        if length<=1:
            return colors
        #統計計數
        for i in range(length):
            while colors[i]>0:
                index = colors[i]
                if colors[index-1]>0:
                    colors[i]=colors[index-1]
                    colors[index-1]=-1         #表示index出現一次
                elif colors[index-1]<=0:
                    colors[i]=0
                    colors[index-1]-=1         #表示index再次出現
        
        #輸出排序結果
        j=length-1
        for i in range(k-1,-1,-1):
            temp = colors[i]
            while temp<0:
                colors[j]=i+1
                temp+=1
                j-=1
        return colors
if __name__=="__main__":
    s = Solution()
    print(s.sortColors2([3,2,2,1,4],4))
    print(s.sortColors2([2,1,1,2,2],2))

143

57. Three Sum

Description:
   Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
   Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)
   The solution set must not contain duplicate triplets.

Example 1:
   Input:[2,7,11,15]
   Output:[]

Example 2:
   Input:[-1,0,1,2,-1,-4]
   Output:   [[-1, 0, 1],[-1, -1, 2]]

#coding:utf-8

"""
題目：57 Three Sum
Description:
    Given an array S of n integers, are there elements a, b, c in S such that a + b + c = 0? Find all unique triplets in the array which gives the sum of zero.
    Elements in a triplet (a,b,c) must be in non-descending order. (ie, a ≤ b ≤ c)
    The solution set must not contain duplicate triplets.

Example 1:
    Input:[2,7,11,15]
    Output:[]
    
Example 2:
    Input:[-1,0,1,2,-1,-4]
    Output:    [[-1, 0, 1],[-1, -1, 2]]
"""


"""
思路：
因爲設置了三個變量，故時間複雜度最少是O(n^2)
在開頭固定一個變量，而後一前一後 移動指針
和大於零 後指針前移
和小於零 前指針後移
和等於零 放入結果中，再讓先後指針移動
"""

"""
@param numbers: Give an array numbers of n integer
@return: Find all unique triplets in the array which gives the sum of zero.
"""
class Solution:
    
    def threeSum(self, numbers):
        # write your code here
        length = len(numbers)
        ret=[]
        if length<3:
            return ret
        quicksort(numbers,0,length-1)
        print(numbers)
        for k in range(length-2):
            if k==0 or numbers[k]!=numbers[k-1]:  #防止重複
                twoSum(numbers,-numbers[k],start=k+1,end=length-1,ret=ret)
        return ret

def quicksort(numbers,start,end):
    if start<end:
        left,right=start,end
        pivot = numbers[start]
        while left<right:
            while left<right and numbers[right]>=pivot:
                right-=1
            numbers[right],numbers[left]=numbers[left],numbers[right]
            while left<right and numbers[left]<pivot:
                left+=1
            numbers[right],numbers[left]=numbers[left],numbers[right]
        quicksort(numbers,start,right-1)
        quicksort(numbers,right+1,end)
        
def twoSum(numbers,target,start,end,ret):
    i,j = start,end
    while i<j:
        if numbers[i]+numbers[j]<target:
            i+=1
        elif numbers[i]+numbers[j]>target:
            j-=1
        else:
            if (-target)<numbers[i]:
                temp=[-target,numbers[i],numbers[j]]
            elif (-target)>numbers[j]:
                temp=[numbers[i],numbers[j],-target]
            else:
                temp=[numbers[i],-target,numbers[j]]
            if temp not in ret: #防止重複
                ret.append(temp)
            i+=1
            j-=1

if __name__=="__main__":
    s = Solution()
    # print(s.threeSum([2,7,11,15]))
    # print(s.threeSum([-1,0,1,2,-1,-4]))
    # print(s.threeSum([1,0,-1,-1,-1,-1,0,1,1,1]))
    print(s.threeSum([-2,-3,-4,-5,-100,99,1,4,4,4,5,1,0,-1,2,3,4,5]))

31.Partition Array

Description
   Given an array nums of integers and an int k, partition the array (i.e move the elements in "nums") such that:

       All elements < k are moved to the left
       All elements >= k are moved to the right

   Return the partitioning index, i.e the first index i nums[i] >= k.
   You should do really partition in array nums instead of just counting the numbers of integers smaller than k.
   If all elements in nums are smaller than k, then return nums.length

Example 1:
   Input:
   [],9
   Output:
   0

Example 2:
   Input:
   [3,2,2,1],2
   Output:1
   Explanation:
   the real array is[1,2,2,3].So return 1

Challenge
   Can you partition the array in-place and in O(n)?

#coding:utf-8

"""
Description
    Given an array nums of integers and an int k, partition the array (i.e move the elements in "nums") such that:

        All elements < k are moved to the left
        All elements >= k are moved to the right

    Return the partitioning index, i.e the first index i nums[i] >= k.
    You should do really partition in array nums instead of just counting the numbers of integers smaller than k.
    If all elements in nums are smaller than k, then return nums.length

Example 1:
    Input:
    [],9
    Output:
    0

Example 2:
    Input:
    [3,2,2,1],2
    Output:1
    Explanation:
    the real array is[1,2,2,3].So return 1

Challenge
    Can you partition the array in-place and in O(n)?
"""

"""
思路：相似於快速排序的左右指針
"""

class Solution:
    """
    @param nums: The integer array you should partition
    @param k: An integer
    @return: The index after partition
    """
    def partitionArray(self, nums, k):
        # write your code here
        length=len(nums)
        if length==0:
            return 0
        i,j=0,length-1
        while i<=j:
            while i<=j and nums[i]<k:
                i+=1
            while i<=j and nums[j]>=k:
                j-=1
            if i<j:
                nums[i],nums[j]=nums[j],nums[i]
        return i
if __name__=="__main__":
    s = Solution()
    print(s.partitionArray([],9))
    print(s.partitionArray([3,2,2,1],2))

5. Kth Largest Element
Description

   Find K-th largest element in an array.
   You can swap elements in the array

Example 1:
   Input:
   n = 1, nums = [1,3,4,2]
   Output:
   4

Example 2:
   Input:
   n = 3, nums = [9,3,2,4,8]
   Output:
   4

Challenge
   O(n) time, O(1) extra memory.

#coding:utf-8

"""
題目：5. Kth Largest Element
Description

    Find K-th largest element in an array.
    You can swap elements in the array

Example 1:
    Input:
    n = 1, nums = [1,3,4,2]
    Output:
    4

Example 2:
    Input:
    n = 3, nums = [9,3,2,4,8]
    Output:
    4

Challenge
    O(n) time, O(1) extra memory.
"""
"""
思路：
    快速選擇算法 的平均時間複雜度爲 O(N){O}(N)O(N)。就像快速排序那樣，本算法也是 Tony Hoare 發明的，所以也被稱爲 Hoare選擇算法。

本方法大體上與快速排序相同。簡便起見，注意到第 k 個最大元素也就是第 N - k 個最小元素，所以能夠用第 k 小算法來解決本問題。

首先，咱們選擇一個樞軸，並在線性時間內定義其在排序數組中的位置。這能夠經過 劃分算法 的幫助來完成。

    爲了實現劃分，沿着數組移動，將每一個元素與樞軸進行比較，並將小於樞軸的全部元素移動到樞軸的左側。

這樣，在輸出的數組中，樞軸達到其合適位置。全部小於樞軸的元素都在其左側，全部大於或等於的元素都在其右側。

這樣，數組就被分紅了兩部分。若是是快速排序算法，會在這裏遞歸地對兩部分進行快速排序，時間複雜度爲 O(Nlog⁡N)。

而在這裏，因爲知道要找的第 N - k 小的元素在哪部分中，咱們不須要對兩部分都作處理，這樣就將平均時間複雜度降低到 O(N)。

"""
class Solution:
    """
    @param n: An integer
    @param nums: An array
    @return: the Kth largest element
    """
    def kthLargestElement(self, n, nums):
        # write your code here
        length = len(nums)
        if n>length or n==0:
            return None
        return half_quicksort(nums,n,0,length-1)
        
    
    #方法二，利用二叉堆
    def kthLargestElement2(self, n, nums):
        import heapq
        length = len(nums)
        if n>length or n==0:
            return None
        return heapq.nlargest(n,nums)[n-1]
        
def half_quicksort(nums,k,start,end):
    if k==1 and start==end:
        return nums[start]
    if start<end:
        left,right=start,end
        pivot = nums[start]
        while left<right:
            while left<right and nums[right]>=pivot:
                right-=1
            nums[left],nums[right]=nums[right],nums[left]
            while left<right and nums[left]<pivot:
                left+=1
            nums[left],nums[right]=nums[right],nums[left]
        
        if end-right>k-1:
            return half_quicksort(nums,k,right+1,end)
        elif end-right<k-1:
            return half_quicksort(nums,k-(end-right+1),start,right-1)
        else:
            return nums[right]
            
if __name__=="__main__":
    s = Solution()
    print(s.kthLargestElement(n = 1, nums = [1,3,4,2]))
    print(s.kthLargestElement(n = 3, nums = [9,3,2,4,8]))
    
    print(s.kthLargestElement2(n = 1, nums = [1,3,4,2]))
    print(s.kthLargestElement2(n = 3, nums = [9,3,2,4,8]))

（四）. 寬度優先搜索和拓撲排序（BFS and Topplogical Sort）

433. Number of Islands

Description

　　Given a boolean 2D matrix, 0 is represented as the sea, 1 is represented as the island. If two 1 is adjacent, we consider them in the same island. We only consider up/down/left/right adjacent.
      Find the number of islands.

Example 1:
   Input:
   [
      [1,1,0,0,0],
      [0,1,0,0,1],
      [0,0,0,1,1],
      [0,0,0,0,0],
      [0,0,0,0,1]
   ]
   Output:3

Example 2:

   Input:
   [
      [1,1]
   ]
   Output:1