數據結構與算法-Python語言案例實現

十大經典排序算法

一、引言

授人以魚不如授人以漁~

實踐是檢驗真理的唯一標準~

算法與數據結構實戰-LeetCode題解

1.問題需求

排序數組

給你一個整數數組 nums，請你將該數組升序排列。

或對一個無序數組，根據某個關鍵字排序。

示例 1：

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

示例 2：

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

Python語言實現

2.方法分類

排序算法劃分方法有：穩定性，內外排序，時空複雜度

按照穩定性劃分：穩定排序，如果a原本在b前面，而a=b，排序之後a仍然在b的前面；而不穩定可能出現在b之後
按照內外排序劃分：內排序，所有排序操作都在內存中完成；外排序：由於數據太大，因此把數據放在磁盤中，而排序通過磁盤和內存的數據傳輸才能進行
按照時空複雜度劃分：時間複雜度是指運行時間，空間複雜度運行完一個程序所需內存的大小

二、常見排序方法

1. 選擇排序（Selection Sort）

算法描述：

這應該最符合人類思維的排序方法，工作原理，首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然後，再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。以此類推，直到所有元素均排序完畢。

穩定性：穩定；內排序

def selection_sort(nums):
    n = len(nums)
    for i in range(n):
        for j in range(i, n):
            if nums[i] > nums[j]:
                nums[i], nums[j] = nums[j], nums[i]
    return nums

# leetcode形式
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        # selection sort 
        n = len(nums)
        for i in range(n):
            for j in range(i,n):
                if nums[i] > nums[j]:
                    nums[i],nums[j] = nums[j],nums[i]
                    #print(nums)
        return nums

算法分析：

2. 冒泡排序（Bubble Sort）

算法描述：

冒泡排序時針對相鄰元素之間的比較，可以將大的數慢慢“沉底”(數組尾部)

def bubble_sort(nums):
    n = len(nums)
    # 進行多次循環
    for c in range(n):
        for i in range(1, n - c):
            if nums[i - 1] > nums[i]:
                nums[i - 1], nums[i] = nums[i], nums[i - 1]
    return nums

算法分析：

穩定排序，內排序，時間複雜度：

3. 插入排序（Insertion Sort）

算法描述：

插入排序是前面已排序數組找到插入的位置

def insertion_sort(nums):
    n = len(nums)
    for i in range(1, n):
        while i > 0 and nums[i - 1] > nums[i]:
            nums[i - 1], nums[i] = nums[i], nums[i - 1]
            i -= 1
    return nums

# LeetCode形式
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        # insert sort 
        n = len(nums)
        for i in range(1,n):
            while i > 0 and nums[i-1] > nums[i]:
                nums[i-1],nums[i] = nums[i],nums[i-1]
                i -= 1
        return nums

算法分析：

穩定排序，內排序，時間複雜度：

4. 希爾排序（Shell Sort）

插入排序進階版

算法描述：

def shell_sort(nums):
    n = len(nums)
    gap = n // 2
    while gap:
        for i in range(gap, n):
            while i - gap >= 0 and nums[i - gap] > nums[i]:
                nums[i - gap], nums[i] = nums[i], nums[i - gap]
                i -= gap
        gap //= 2
    return nums

算法分析：

非穩定排序，內排序；

希爾排序的時間複雜度和增量序列是相關的。

5. 歸併排序（Merge Sort）

歸併排序，採用是分治法，先將數組分成子序列，讓子序列有序，再將子序列間有序，合併成有序數組。

算法描述：

def merge_sort(nums):
    if len(nums) <= 1:
        return nums
    mid = len(nums) // 2
    # 分
    left = merge_sort(nums[:mid])
    right = merge_sort(nums[mid:])
    # 合併
    return merge(left, right)


def merge(left, right):
    res = []
    i = 0
    j = 0
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            res.append(left[i])
            i += 1
        else:
            res.append(right[j])
            j += 1
    res += left[i:]
    res += right[j:]
    return res

# LeetCode
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        res = []
        mid = len(nums) //2
        left, right = nums[:mid],nums[mid:]
        if len(left) > 1: left = self.sortArray(left)
        if len(right) > 1: right = self.sortArray(right)

        while left and right:
            if left[-1] >= right[-1]:
                res.append(left.pop())
            else:
                res.append(right.pop())
        res.reverse()
        return (left or right) + res  # 將剩餘left或right中的數和res合併

算法分析：

穩定排序，外排序（佔用額外內存），時間複雜度：O(nlogn)。

6. 快速排序（Quick Sort）

快速排序是選取一個“哨兵”(pivot)，將小於pivot放在左邊，把大於pivot放在右邊，分割成兩部分，並且可以固定pivot在數組的位置，在對左右兩部分繼續進行排序。

快速排序使用分治法來把一個串（list）分爲兩個子串（sub-lists）。具體算法描述如下：

步驟1：從數列中挑出一個元素，稱爲 “基準”（pivot ）；
步驟2：重新排序數列，所有元素比基準值小的擺放在基準前面，所有元素比基準值大的擺在基準的後面（相同的數可以到任一邊）。在這個分區退出之後，該基準就處於數列的中間位置。這個稱爲分區（partition）操作；
步驟3：遞歸地（recursive）把小於基準值元素的子數列和大於基準值元素的子數列排序。

def quick_sort(nums):
    n = len(nums)

    def quick(left, right):
        if left >= right:
            return nums
        pivot = left
        i = left
        j = right
        while i < j:
            while i < j and nums[j] > nums[pivot]:
                j -= 1
            while i < j and nums[i] <= nums[pivot]:
                i += 1
            nums[i], nums[j] = nums[j], nums[i]
        nums[pivot], nums[j] = nums[j], nums[pivot]
        quick(left, j - 1)
        quick(j + 1, right)
        return nums

    return quick(0, n - 1)

# LeetCode
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        n = len(nums)
        first = 0
        last = n - 1
        self.quickSorthepler(nums,first,last)
        return nums

    def partition(self, alist, first, last):
        left = first
        right = last
        pivot = alist[first]
        while left < right:
            while left < right and alist[right] >= pivot:
                right -= 1
            alist[left] = alist[right]
            while left < right and alist[left] <= pivot:
                left += 1
            alist[right] = alist[left]
        alist[left] = pivot
        return left
    
    def quickSorthepler(self, alist, first,last):
        if first < last:
            pointmark = self.partition(alist,first,last)
            self.quickSorthepler(alist,first,pointmark-1)
            self.quickSorthepler(alist, pointmark + 1, last)

算法分析：

不穩定排序，內排序，時間複雜度度O(nlogn)O(nlogn)。

7. 堆排序（Heap Sort）

堆排序是利用堆這個數據結構設計的排序算法。

算法描述：

建堆，從底向上調整堆，使得父親節點比孩子節點值大，構成大頂堆；
交換堆頂和最後一個元素，重新調整堆。

調整堆方法寫了遞歸和迭代，都很好理解！

def heap_sort(nums):
    # 調整堆
    # 迭代寫法
    def adjust_heap(nums, startpos, endpos):
        newitem = nums[startpos]
        pos = startpos
        childpos = pos * 2 + 1
        while childpos < endpos:
            rightpos = childpos + 1
            if rightpos < endpos and nums[rightpos] >= nums[childpos]:
                childpos = rightpos
            if newitem < nums[childpos]:
                nums[pos] = nums[childpos]
                pos = childpos
                childpos = pos * 2 + 1
            else:
                break
        nums[pos] = newitem
    
    # 遞歸寫法
    def adjust_heap(nums, startpos, endpos):
        pos = startpos
        chilidpos = pos * 2 + 1
        if chilidpos < endpos:
            rightpos = chilidpos + 1
            if rightpos < endpos and nums[rightpos] > nums[chilidpos]:
                chilidpos = rightpos
            if nums[chilidpos] > nums[pos]:
                nums[pos], nums[chilidpos] = nums[chilidpos], nums[pos]
                adjust_heap(nums, pos, endpos)

    n = len(nums)
    # 建堆
    for i in reversed(range(n // 2)):
        adjust_heap(nums, i, n)
    # 調整堆
    for i in range(n - 1, -1, -1):
        nums[0], nums[i] = nums[i], nums[0]
        adjust_heap(nums, 0, i)
    return nums

#  LeetCode
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:

        n = len(nums)
        def build_heap(nums, start, end):  # 建堆的同時調整堆
            newitem = nums[start]
            cur = start
            leftpos = 2 * cur + 1
            while leftpos < end:
                rightpos = leftpos + 1
                if rightpos < end and nums[rightpos] >= nums[leftpos]:
                    leftpos = rightpos
                if newitem < nums[leftpos]:
                    nums[cur] = nums[leftpos]
                    cur = leftpos
                    leftpos = 2 * cur + 1
                else:
                    break
            nums[cur] = newitem
        for i in reversed(range(n//2)):  # 建堆+調整
            build_heap(nums, i, n)
        for i in range(n-1,-1,-1):
            nums[0],nums[i] = nums[i],nums[0]  #排序
            build_heap(nums,0,i)  #調整
        return nums

# LeetCode
# 堆排序 遞歸寫法
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        n = len(nums)
        self.build_heap(nums,n)
        print(nums)
        
        for i in range(n-1,-1,-1):
            nums[0],nums[i] = nums[i],nums[0]  #排序
            self.heapify(nums,0,i)  #調整
        return nums
    # 遞歸寫法
    def heapify(self, nums, startpos, endpos):
        if startpos >= endpos: return 
        c1 = startpos * 2 + 1
        c2 = startpos * 2 + 2
        max_index = startpos
        if c1 < endpos and nums[c1] > nums[max_index]:
            max_index = c1
        if c2 < endpos and nums[c2] > nums[max_index]:
            max_index = c2
        if max_index != startpos:
            nums[startpos], nums[max_index] = nums[max_index], nums[startpos]
            self.heapify(nums, max_index, endpos)
    def build_heap(self, nums, n):
        last_node = n-1
        parent = (last_node-1) // 2
        for i in range(parent, -1,-1):
            self.heapify(nums,i,n)

算法分析：

不穩定排序，內排序，時間複雜度爲O(nlogn)O(nlogn)。

8. 計數排序（Counting Sort）

計數排序是典型的空間換時間算法，開闢額外數據空間存儲用索引號記錄數組的值和數組值個數

算法描述：

找出待排序的數組的最大值和最小值
統計數組值的個數
反向填充目標數組

def counting_sort(nums):
    if not nums: return []
    n = len(nums)
    _min = min(nums)
    _max = max(nums)
    tmp_arr = [0] * (_max - _min + 1)
    for num in nums:
        tmp_arr[num - _min] += 1
    j = 0
    for i in range(n):
        while tmp_arr[j] == 0:
            j += 1
        nums[i] = j + _min
        tmp_arr[j] -= 1
    return nums

# LeetCode
class Solution:
    def sortArray(self, nums: List[int]) -> List[int]:
        from collections import defaultdict

        def counter_sort(nums,key=lambda x:x):
            B,C = [], defaultdict(list)
            for x in nums:
                C[key(x)].append(x)  #  {1:1,2:2,......}
            for k in range(min(C), max(C) + 1):
                B.extend(C[k])
            return B
        res = counter_sort(nums)
        return res

算法分析：

穩定排序，外排序，時間複雜度O(n + k)，但是對於數據範圍很大的數組，需要大量時間和內存。

9. 桶排序（Bucket Sort）

桶排序是計數排序的升級版，原理是：輸入數據服從均勻分佈的，將數據分到有限數量的桶裏，每個桶再分別排序（有可能再使用別的算法或是以遞歸方式繼續使用桶排序，此文編碼採用遞歸方式）

算法描述：

人爲設置一個桶的BucketSize，作爲每個桶放置多少個不同數值（意思就是BucketSize = 5，可以放5個不同數字比如[1, 2, 3,4,5]也可以放 100000個3，只是表示該桶能存幾個不同的數值）
遍歷待排序數據，並且把數據一個一個放到對應的桶裏去
對每個不是桶進行排序，可以使用其他排序方法，也遞歸排序
不是空的桶裏數據拼接起來

def bucket_sort(nums, bucketSize):
    if len(nums) < 2:
        return nums
    _min = min(nums)
    _max = max(nums)
    # 需要桶個數
    bucketNum = (_max - _min) // bucketSize + 1
    buckets = [[] for _ in range(bucketNum)]
    for num in nums:
        # 放入相應的桶中
        buckets[(num - _min) // bucketSize].append(num)
    res = []

    for bucket in buckets:
        if not bucket: continue
        if bucketSize == 1:
            res.extend(bucket)
        else:
            # 當都裝在一個桶裏,說明桶容量大了
            if bucketNum == 1:
                bucketSize -= 1
            res.extend(bucket_sort(bucket, bucketSize))
    return res

算法分析：

穩定排序，外排序，時間複雜度O(n + k)，k爲桶的個數。

10. 基數排序（Radix Sort）

基數排序是對數字每一位進行排序，從最低位開始排序

算法描述：

找到數組最大值，得最大位數；
從最低位開始取每個位組成radix數組；
對radix進行計數排序（計數排序適用於小範圍的特點）。

def Radix_sort(nums):
    if not nums: return []
    _max = max(nums)
    # 最大位數
    maxDigit = len(str(_max))
    bucketList = [[] for _ in range(10)]
    # 從低位開始排序
    div, mod = 1, 10
    for i in range(maxDigit):
        for num in nums:
            bucketList[num % mod // div].append(num)
        div *= 10
        mod *= 10
        idx = 0
        for j in range(10):
            for item in bucketList[j]:
                nums[idx] = item
                idx += 1
            bucketList[j] = []
    return nums

算法分析：

穩定排序，外排序，時間複雜度 posCount * (n + n)，其中 posCount 爲數組中最大元素的最高位數；簡化下得：O( k *n ) ；其中k爲常數，n爲元素個數。

三、算法總結

圖片名詞解釋：

n: 數據規模
k: “桶”的個數
In-place: 佔用常數內存，不佔用額外內存
Out-place: 佔用額外內存

碼字不易，看過的同學麻煩點個贊~

關注或留言，看客官心情咯~

歡迎交流，共同進步~

您的支持，是我不斷創作的最大動力~

歡迎點贊，關注，留言交流~

深度學習，樂此不疲~

個人微信公衆號，歡迎關注~

Python 實現十大經典排序算法-LeetCode案例版

數據結構與算法-Python語言案例實現

十大經典排序算法

一、引言

1.問題需求

2.方法分類

二、常見排序方法

1. 選擇排序（Selection Sort）

2. 冒泡排序（Bubble Sort）

3. 插入排序（Insertion Sort）

4. 希爾排序（Shell Sort）

5. 歸併排序（Merge Sort）

6. 快速排序（Quick Sort）

7. 堆排序（Heap Sort）

8. 計數排序（Counting Sort）

9. 桶排序（Bucket Sort）

10. 基數排序（Radix Sort）

三、算法總結

DAPPER 事務 TRANSACTION

深度學習—數據處理常用代碼Python合集

數據處理-Python批量修改文件夾下含多個文件夾中的所有圖片名稱

目標檢測—視頻檢測測試代碼

深度學習數據處理—Python處理文件夾下相同和不同的圖像數據（xml-jpg互找）

LeetCode筆記-機器人的運動範圍（ Python圖解）

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

Python 實現十大經典排序算法-LeetCode案例版

數據結構與算法-Python語言案例實現

十大經典排序算法

一、 引言

1.問題需求

2.方法分類

二、常見排序方法

1. 選擇排序（Selection Sort）

2. 冒泡排序（Bubble Sort）

3. 插入排序（Insertion Sort）

4. 希爾排序（Shell Sort）

5. 歸併排序（Merge Sort）

6. 快速排序（Quick Sort）

7. 堆排序（Heap Sort）

8. 計數排序（Counting Sort）

9. 桶排序（Bucket Sort）

10. 基數排序（Radix Sort）

三、算法總結

一、引言