小李飛刀：刷題第十三彈！

寫在前面

今天的小李的目標是排序算法，果真仍是要下手寫纔會更有體會，也更記得住。

認真作題的分割線

第一題

215. 數組中的第K個最大元素
難度：中等
在未排序的數組中找到第k個最大的元素。請注意，你須要找的是數組排序後的第k個最大的元素，而不是第k個不一樣的元素。
示例 1:

輸入: [3,2,1,5,6,4] 和 k = 2
輸出: 5

示例 2:

輸入: [3,2,3,1,2,4,5,5,6] 和 k = 4
輸出: 4

說明:
你能夠假設 k 老是有效的，且 1 ≤ k ≤ 數組的長度。

---

個人題解:

def findKthLargest(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        num = quicksort(nums,0,len(nums)-1)
        return num[len(nums)-k]
    
def quicksort(v,start,end):
    if start < end:
        i,j = start,end
        base  = v[i]
        while i < j:
            while i < j and v[j] >= base:
                j -= 1
            v[i] = v[j]
            while i < j and v[i] < base:
                i +=1
            v[j] = v[i]
        v[i] = base
        quicksort(v,start,i-1)
        quicksort(v,j+1,end)
    return v

個人思路:
經過快速排序算法,對數據進行排序後,找到對應的值.
排序算法:
快排的主體思路是,找到對應的標杆值,而後對標杆值兩側進行劃分,而後分而治之,對兩側再進行遞歸的切分標杆值.
因此常見的是遞歸的思路.
以前看《算法圖解》的代碼，今晚嘗試了下：

def quicksort(array):
    if len(array) < 2:
        return array
    temp = array[0]
    less = [ i for i in array[1:] if i <= temp]
    greater = [i for i in array[1:] if i > temp]
    return quicksort(less) + temp + quicksort(greater)

比較可以明顯的顯示快排的思路，可是這個效率並不高，由於每次遞歸都須要對兩側的數組進行一次硬性排序。
且return 不支持不一樣類型（list和int）一塊兒。
優化後，咱們採用的方式是加入了start和end的參數，依然是對標杆值兩側進行劃分，可是會減小排序重複量，下降了複雜度。

第二題

215. 數組中的第K個最大元素
難度：中等
給定一個非空的整數數組，返回其中出現頻率前k高的元素。

示例 1:

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

示例 2:

輸入: nums = [1], k = 1
輸出: [1]

說明：
你能夠假設給定的k老是合理的，且 1 ≤ k ≤ 數組中不相同的元素的個數。
你的算法的時間複雜度必須優於O(n log n), n 是數組的大小。

---

個人題解:

class Solution(object):
    def topKFrequent(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: List[int]
        """
        l = dict()
        res = []
        for i in nums:
            if i in l:
                l[i] += 1
            else:
                l[i] = 1
        items = list(l.items())
        items.sort(key = lambda x:x[1],reverse = True)
        for i in range(k):
            res.append(items[i][0])
        return res

個人思路:
這題按正常題解，應該使用桶排序。
我用的方案是用hash表記錄對應的值，而後將hash錶轉成二維list，並對二級域進行排序。
而後輸出對應值。
其餘:
這題要再嘗試下桶排序的方式，主要是對sort()函數參數有了新的認識。

sorted(iterable[, cmp[, key[, reverse]]])

• iterable指定要排序的list或者iterable
• cmp爲函數，指定排序時進行比較的函數，能夠指定一個函數或者lambda函數
• key爲函數，指定取待排序元素的哪一項進行排序，用於指定哪個域

第三題

215. 數組中的第K個最大元素
難度：中等
給定一組非負整數，從新排列它們的順序使之組成一個最大的整數。

示例 1:

輸入: [10,2]
輸出: 210

示例 2:

輸入: [3,30,34,5,9]
輸出: 9534330

說明: 輸出結果可能很是大，因此你須要返回一個字符串而不是整數。

---

個人題解:

class Solution(object):
    def largestNumber(self, nums):
        """
        :type nums: List[int]
        :rtype: str
        """
        l = len(nums)
        i = l
        #比較a+b 和 b+a
        while i > 0:
            for j in range(i-1):
                a = nums[j]
                b = nums[j+1]
                ab = int(str(a)+str(b))
                ba = int(str(b)+str(a))
                if ab < ba:
                    nums[j],nums[j+1] = nums[j+1],nums[j]
            i -=1
        res= ""
        for n in nums:
            if res == "" and n == 0:
                continue
            res += str(n)
        if res == "":
            return "0"
        return res

個人思路:
這題參考了小佳揚的寫法，主要是使用了冒泡排序。
但屬於自定義的冒泡排序，每次都比對字符串先後排序不一樣時得出的結果哪一個更大，會得到的更大值須要放在更前，相反則放後。

排序算法:
冒泡排序主要是比對相鄰兩個數之間的大小關係，不斷將較大值交換至最後。

總結

明天要繼續攻略排序算法。紙上得來終覺淺，絕知此事要躬行。