十大排序代碼實現（python）

時間 2020-06-02

標籤十大排序代碼實現 python 欄目 Python 简体版

原文原文鏈接

寫在前面：

參考文章：十大經典排序算法本文的邏輯順序基於從第一篇參考博文上借鑑過來的圖，而且都是按照升序排序寫的程序，程序語言採用python。 html

[TOC]### 冒泡排序python

思路：算法

冒泡排序的基本思想就是讓小的數逐漸‘浮上來’。也就是說：數組

第一次冒泡：將最小的數調換到最前面；app
第二次冒泡：將第二小的數調換到最小的數的後面，也就是數組中的第二位；ui
第三次冒泡，將第三小的數調換到數組中的第三位；spa

... ....net

代碼以下：指針

# 冒泡排序
def bubble_sort(nums):
    # 每次冒泡，將最大的元素冒到最後面
    # 第一次是前n個元素，最大的元素冒到最後
    # 第二次是前n-1個元素，最大的元素冒到倒數第二個位置
    # ... ...
    n = len(nums)
    for i in range(n-1):
        for j in range(0,n-i-1):
            if nums[j]>nums[j+1]:
                nums[j], nums[j+1] = nums[j+1],nums[j]
                
    return nums

時間複雜度： O(n^2)，其實是n-1 + n-2 + n-3 + ...，因此是平方的量級。code

空間複雜度： O(l)，沒有藉助額外空間。

快速排序

參考：快速排序的四種寫法（python實現）

思路

快速排序的基本思路就是在一遍快排中，以基準值爲基礎，將比基準值小的數放到基準值的左邊，比基準值大的數放在基準值的右邊。而後在遞歸的快排基準值的左邊和右邊。至於基準值的取法，理論上來說是無所謂的。

先來一個比較簡單直接的吧。它的思路就是遍歷一遍數組，用兩個空的數組來存儲比基準值大和比基準值小的數，代碼以下：

def quick_sort1(nums):
    n = len(nums)
    if n ==1 or len(nums)==0:
        return nums  
    left = []
    right = []
    for i in range(1,n):
        if nums[i] <= nums[0]:
            left.append(nums[i])
        else:
            right.append(nums[i])         
    return quick_sort1(left)+[nums[0]]+quick_sort1(right)

上面的使用了額外的空間，空間複雜度比較高，下面是基於雙指針的想法的代碼，比較常見：

def quick_sort2(nums,left,right):
    l,r = left,right-1
    while  l < r:
        if nums[r] < nums[l]:
            nums[r], nums[l] = nums[l], nums[r]
            l += 1
            while l < r:
                if nums[l] > nums[r]:
                    nums[r],nums[l] = nums[l], nums[r]
                    r -= 1
                    break
                else:
                    l += 1
        else:
            r -= 1
    if l-left > 1:                
        quick_sort2(nums, left, l)
    if right - r > 1:
        quick_sort2(nums, l+1, right)
    return nums

在上面博客中看到的第三種方法，甚是巧妙，代碼以下：

def quick_sort3(nums, l, r):
    if l < r:
        q = partition(nums, l, r)
        quick_sort(nums, l, q - 1)
        quick_sort(nums, q + 1, r)
    return nums        
def partition(nums, l, r):
    x = nums[r]
    i = l - 1
    for j in range(l, r):
        if nums[j] <= x:
            i += 1
            nums[i], nums[j] = nums[j], nums[i]
    nums[i + 1], nums[r] = nums[r], nums[i+1]
    return i + 1

簡單插入排序

插入排序，意思是將某一個數字插入到已經排好序的數組當中。

代碼以下：

def insert_sort(nums):
    n = len(nums)
    for i in range(1,n):
        index = i
        for j in range(i-1,-1,-1):
            if nums[j] > nums[index]:
                nums[index],nums[j] = nums[j],nums[index]
                index -= 1
            else:
                break
    return nums

希爾排序

簡單選擇排序

簡單選擇排序，就是每一次選擇一個當前最小的元素放在已經排好序的數組的後面。

def selection_sort(nums):
    n = len(nums)
    for i in range(n):
        index = i
        for j in range(i+1,n):
            if nums[j]<nums[index]:
                index = j
        nums[i],nums[index] = nums[index],nums[i]

    return nums

堆排序

def head_sort(elems):
    def siftdown(elems,e,begin,end):
        i, j = begin, begin*2+1
        while j < end:
            if j+1 < end and elems[j+1] < elems[j]:
                j += 1
            if e < elems[j]:
                break
            elems[i] = elems[j]
            i, j = j, 2*j+1
        elems[i] = e

    end = len(elems)
    for i in range(end//2, -1, -1):
        siftdown(elems, elems[i], i, end)
    for i in range((end-1), 0, -1):
        e = elems[i]
        elems[i] = elems[0]
        siftdown(elems, e, 0, i)

    nums.reverse()
    return nums