2. 程式人生 > >python_基礎演算法

python_基礎演算法

阿新 • • 發佈：2018-11-01

本篇主要實現九(八)大排序演算法，分別是氣泡排序，插入排序，選擇排序，希爾排序，歸併排序，快速排序，堆排序,計數排序。希望大家回顧知識的時候也能從我的這篇文章得到幫助。

原文：https://www.cnblogs.com/huang-yc/p/9774287.html

概述

十種常見排序演算法可以分為兩大類：

  1. 非線性時間比較類排序：通過比較來決定元素間的相對次序，由於其時間複雜度不能突破O(nlogn)，因此稱為非線性時間比較類排序。
  2. 線性時間非比較類排序：不通過比較來決定元素間的相對次序，它可以突破基於比較排序的時間下界，以線性時間執行，因此稱為線性時間非比較類排序。

基礎定義

  • 穩定：如果a原本在b前面，而a=b，排序之後a仍然在b的前面。
  • 不穩定：如果a原本在b的前面，而a=b，排序之後 a 可能會出現在 b 的後面。
  • 時間複雜度：對排序資料的總的操作次數。反映當n變化時，操作次數呈現什麼規律。
  • 空間複雜度：是指演算法在計算機內執行時所需儲存空間的度量，它也是資料規模n的函式。

圖示

 

為了防止誤導讀者，本文所有概念性內容均擷取自對應Wiki。

氣泡排序

原理

氣泡排序(Bubble Sort)是一種簡單的排序演算法。它重複地走訪過要排序的數列，一次比較兩個元素，如果他們的順序錯誤就把他們交換過來。走訪數列的工作是重複地進行直到沒有再需要交換，也就是說該數列已經排序完成。這個演算法的名字由來是因為越小的元素會經由交換慢慢“浮”到數列的頂端。

步驟

氣泡排序演算法的運作如下：

  1. 比較相鄰的元素。如果第一個比第二個大，就交換他們兩個。
  2. 對每一對相鄰元素作同樣的工作，從開始第一對到結尾的最後一對。這步做完後，最後的元素會是最大的數。
  3. 針對所有的元素重複以上的步驟，除了最後一個。
  4. 持續每次對越來越少的元素重複上面的步驟，直到沒有任何一對數字需要比較。

程式碼

def bubble_sort(list):
    length = len(list)
    # 第一級遍歷
    for index in range(length):
        # 第二級遍歷
        for
 
 j in range(1, length - index):
            if list[j - 1] > list[j]:
                # 交換兩者資料，這裡沒用temp是因為python 特性元組。
                list[j - 1], list[j] = list[j], list[j - 1]
    return list
View Code

這種排序其實還可以稍微優化一下，新增一個標記，在排序已完成時，停止排序。

def bubble_sort_flag(list):
    length = len(list)
    for index in range(length):
        # 標誌位
        flag = True
        for j in range(1, length - index):
            if list[j - 1] > list[j]:
                list[j - 1], list[j] = list[j], list[j - 1]
                flag = False
        if flag:
            # 沒有發生交換，直接返回list
            return list
    return list
View Code

選擇排序

原理

選擇排序（Selection sort）是一種簡單直觀的排序演算法。它的工作原理大致是將後面的元素最小元素一個個取出然後按順序放置。

步驟

  1. 在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，
  2. 再從剩餘未排序元素中繼續尋找最小（大）元素，然後放到已排序序列的末尾。
  3. 重複第二步，直到所有元素均排序完畢。

程式碼

def selection_sort(list):
    n=len(list)
    for i in range (0,n):
        min = i
        for j in range(i+1,n):
            if list[j]<list[min]:
                min=j
                list[min],list[i]=list[i],list[min]
    return list
View Code

插入排序

原理

插入排序（Insertion Sort）是一種簡單直觀的排序演算法。它的工作原理是通過構建有序序列，對於未排序資料，在已排序序列中從後向前掃描，找到相應位置並插入。

步驟

  1. 從第一個元素開始，該元素可以認為已經被排序
  2. 取出下一個元素，在已經排序的元素序列中從後向前掃描
  3. 如果該元素（已排序）大於新元素，將該元素移到下一位置
  4. 重複步驟3，直到找到已排序的元素小於或者等於新元素的位置
  5. 將新元素插入到該位置後
  6. 重複步驟2~5

程式碼

def insert_sort(list):
    n = len(list)
    for i in range(1, n):
        # 後一個元素和前一個元素比較
        # 如果比前一個小
        if list[i] < list[i - 1]:
            # 將這個數取出
            temp = list[i]
            # 儲存下標
            index = i
            # 從後往前依次比較每個元素
            for j in range(i - 1, -1, -1):
                # 和比取出元素大的元素交換
                if list[j] > temp:
                    list[j + 1] = list[j]
                    index = j
                else:
                    break
            # 插入元素
            list[index] = temp
    return list
View Code

希爾排序

原理

希爾排序，也稱遞減增量排序演算法，是插入排序的一種更高效的改進版本。希爾排序是非穩定排序演算法。
希爾排序是基於插入排序的以下兩點性質而提出改進方法的：
插入排序在對幾乎已經排好序的資料操作時，效率高，即可以達到線性排序的效率
但插入排序一般來說是低效的，因為插入排序每次只能將資料移動一位。

步驟

每次以一定步長(就是跳過等距的數)進行排序，直至步長為1.

程式碼

def shell_sort(list):
    n = len(list)
    # 初始步長
    gap = n // 2
    while gap > 0:
        for i in range(gap, n):
            # 每個步長進行插入排序
            temp = list[i]
            j = i
            # 插入排序
            while j >= gap and list[j - gap] > temp:
                list[j] = list[j - gap]
                j -= gap
            list[j] = temp
        # 得到新的步長
        gap = gap // 2
    return list
View Code 
步長使用的是Donald Shell的建議，另外步長還可以使用Sedgewick提出的(1, 5, 19, 41, 109,…)。
也可以使用斐波那契數列除去0和1將剩餘的數以黃金分割槽比的兩倍的冪進行運算得到的數列

 歸併排序

原理

歸併操作(歸併演算法)，指的是將兩個已經排序的序列合併成一個序列的操作。歸併排序演算法依賴歸併操作。

步驟

1.迭代法

  1. 申請空間，使其大小為兩個已經排序序列之和，該空間用來存放合併後的序列
  2. 設定兩個指標，最初位置分別為兩個已經排序序列的起始位置
    3.比較兩個指標所指向的元素，選擇相對小的元素放入到合併空間，並移動指標到下一位置
  3. 重複步驟3直到某一指標到達序列尾
  4. 將另一序列剩下的所有元素直接複製到合併序列尾

遞迴法

假設序列共有n個元素：

  1. 將序列每相鄰兩個數字進行歸併操作，形成 {\displaystyle floor(n/2)} floor(n/2)個序列，排序後每個序列包含兩個元素
  2. 將上述序列再次歸併，形成 {\displaystyle floor(n/4)} floor(n/4)個序列，每個序列包含四個元素
  3. 重複步驟2，直到所有元素排序完畢

程式碼

# 遞迴法
def merge_sort(list):
    # 認為長度不大於1的數列是有序的
    if len(list) <= 1:
        return list
    # 二分列表
    middle = len(list) // 2
    left = merge_sort(list[:middle])
    right = merge_sort(list[middle:])
    # 最後一次合併
    return merge(left, right)
# 合併
def merge(left, right):
    l,r=0,0
    result=[]
    while l<len(left) and r<len(right):
        if left[l] <right[r]:
            result.append(left[l])
            l+=1
        else:
            result.append(right[r])
            r +=1
        reslut +=left[l:]
        result+=right[r:]                
    return result
View Code

鄙人不才，不知歸併排序的迭代法如何用Python實現，望指教。

快速排序

原理

快速排序使用分治法（Divide and conquer）策略來把一個序列（list）分為兩個子序列（sub-lists）。

步驟

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

程式碼

普通版

def quick_sort(list):
    less = []
    pivotList = []
    more = []
    # 遞迴出口
    if len(list) <= 1:
        return list
    else:
        # 將第一個值做為基準
        pivot = list[0]
        for i in list:
            # 將比急轉小的值放到less數列
            if i < pivot:
                less.append(i)
            # 將比基準打的值放到more數列
            elif i > pivot:
                more.append(i)
            # 將和基準相同的值儲存在基準數列
            else:
                pivotList.append(i)
        # 對less數列和more數列繼續進行排序
        less = quick_sort(less)
        more = quick_sort(more)
        return less + pivotList + more
View Code

咳咳，下面這段程式碼出自《Python cookbook 第二版》傳說中的三行實現python快速排序。

def qsort(arr):
    if len(arr) <= 1:
        return arr
    else:
        pivot = arr[0]
        less = [x for x in arr[1:] if x < pivot]
        greater = [x for x in arr[1:] if x >= pivot]
        return qsort(less) + [pivot] + qsort(greater)
View Code

當然還有一行語法糖版本:

qs = lambda xs : ( (len(xs) <= 1 and [xs]) or [ qs( [x for x in xs[1:] if x < xs[0]] ) + [xs[0]] + qs( [x for x in xs[1:] if x >= xs[0]] ) ] )[0]

 

是不是感受到了Python的魅力？

堆排序

原理

堆排序（Heapsort）是指利用堆這種資料結構所設計的一種排序演算法。堆積是一個近似完全二叉樹的結構，並同時滿足堆積的性質：即子結點的鍵值或索引總是小於（或者大於）它的父節點。

步驟

  1. 建立最大堆:將堆所有資料重新排序，使其成為最大堆
  2. 最大堆調整:作用是保持最大堆的性質，是建立最大堆的核心子程式
  3. 堆排序:移除位在第一個資料的根節點，並做最大堆調整的遞迴運算

程式碼

def heap_sort(list):
    # 建立最大堆
    for start in range((len(list) - 2) // 2, -1, -1):
        sift_down(list, start, len(list) - 1)

    # 堆排序
    for end in range(len(list) - 1, 0, -1):
        list[0], list[end] = list[end], list[0]
        sift_down(list, 0, end - 1)
    return list

# 最大堆調整
def sift_down(lst, start, end):
    root = start
    while True:
        child = 2 * root + 1
        if child > end:
            break
        if child + 1 <= end and lst[child] < lst[child + 1]:
            child += 1
        if lst[root] < lst[child]:
            lst[root], lst[child] = lst[child], lst[root]
            root = child
        else:
            break
View Code

計數排序

原理

當輸入的元素是n個0到k之間的整數時，它的執行時間是Θ(n + k)。計數排序不是比較排序，排序的速度快於任何比較排序演算法。

由於用來計數的陣列C的長度取決於待排序陣列中資料的範圍（等於待排序陣列的最大值與最小值的差加上1），這使得計數排序對於資料範圍很大的陣列，需要大量時間和記憶體。例如：計數排序是用來排序0到100之間的數字的最好的演算法，但是它不適合按字母順序排序人名。但是，計數排序可以用在基數排序演算法中，能夠更有效的排序資料範圍很大的陣列。

步驟

  1. 找出待排序的陣列中最大和最小的元素
  2. 統計陣列中每個值為i的元素出現的次數，存入陣列 C 的第 i 項
  3. 對所有的計數累加（從C中的第一個元素開始，每一項和前一項相加）
  4. 反向填充目標陣列：將每個元素i放在新陣列的第C(i)項，每放一個元素就將C(i)減去1

程式碼

def count_sort(list):
    min = 2147483647
    max = 0
    # 取得最大值和最小值
    for x in list:
        if x < min:
            min = x
        if x > max:
            max = x
    # 建立陣列C
    count = [0] * (max - min +1)
    for index in list:
        count[index - min] += 1
    index = 0
    # 填值
    for a in range(max - min+1):
        for c in range(count[a]):
            list[index] = a + min
            index += 1
    return list
View Code

第九種排序

None？
當然不會
自然就是系統自帶的

list.sort()

 

相關推薦

python_基礎演算法

本篇主要實現九(八)大排序演算法，分別是氣泡排序，插入排序，選擇排序，希爾排序，歸併排序，快速排序，堆排序,計數排序。希望大家回顧知識的時候也能從我的這篇文章得到幫助。 原文：https://www.cnblogs.com/huang-yc/p/9774287.html 概述 十種常見排序演算法可以分為

python_基礎類型

字符 pen 轉換方法 bit alex 空白 反轉 刪除 sdl 【python的基本數據類型及進制掃盲】 一、進制 1.進制簡介 　　進制就是進位制，是人們規定的一種進位方法。計算機底層的數據運算和存儲都是二進制數據。計算機語言就是二進制，計算機能直接識別二進制數據，

python_基礎語法1

開始與結束 類的構造函數 pri 源文件 int 構造 多行文本 方法 基礎 1.執行程序 2.0版本輸入 print”hello,world” 3.0版本已經把print作為內置函數，print（“hello，world”） 2.中文編碼 # -*- c

Python_基礎_Day_1

Coding 不可 數量 lis 類型 浮點型 寬度 self 截取 一、變量 　　由字母、數字和下劃線組成且不能以數字開頭 二、標準數據類型 　　五種類型：數字（Numbers）、字符串（String）、列表（List）、元組（Tuple）、字典（Dictionary）

Python_基礎_Day_2

strong 字節 mod b+ als 字節數 with code 語句 流程控制 一、條件語句 　　1、if 　　2、if...elif...else 　　3、if...else 二、循環語句 　　1、for...in 　　2、for...in...else 　　3、w

Python_基礎個人理解_閉包

就會 返回值 技術 程序 執行 控制 可見 情況 alt 閉包 　　　　　　　　　　　　　　　　　　　　　　　———— 個人理解簡述 閉包在某種含義上其本身其實也是一個函數。 定義的格式簡單來說為在一個函數內部再創建一個函數， 也就是一個外函數包裹了一個內函數， 在內函

【內功】基礎演算法——字串

[1] Manacher  求一個字串中的最長迴文子串。 講解直接放ppt，複習能回憶起來就行。         1 #include <iostream> 2 #include <

NOIP複賽複習（十一）基礎演算法鞏固與提高

一、倍增演算法：   定義：用f[i][j]表示從i位置出發的2j個位置的資訊綜合（狀態） 一個小小的問題：為什麼是2j而不是3j,5j,…？因為，假設為kj，整個演算法的時間複雜度為(k-1)logk，當k=2時，時間複雜度最小。 這個演算法的三個應用：

演算法模板(五)樹基礎演算法

最小生成樹 #include<bits/stdc++.h> #define maxn 5000 #define maxm 10000 using namespace std; inline char get(){ static char buf[30],*p1=buf,*p2=buf;

JAVA演算法習題集合—第一階段3：基礎演算法練習之水仙花數判斷

知識點：資料型別轉換、while迴圈語句、for迴圈、陣列的使用。 1.整數位數判斷 輸入一個整數，輸出這個整數是幾位數。 執行結果： 輸入：56424 輸出：5 Scanner input=new Scanner(System.in); System.out.p

JAVA演算法習題集合—第一階段2：基礎演算法練習之for迴圈的練習

  知識點：for迴圈、for迴圈和if語句的巢狀使用 8、輸出1到100 描述：輸出從1到100 執行結果: 1 2 3 4...100 for(int i=1;i<=100;i++){ Syste

JAVA演算法習題集合—第一階段1：基礎演算法練習

知識點：算術運算子、if語句、if-else語句、三元運算子的使用 1、兩個整數的和  描述:輸入整數a和b，輸出它們的和。  執行結果： 輸入a:100 輸入b:200 a+b=300 public static

基礎演算法：遞迴

遞迴用處很廣，可以將複雜問題簡單化。 很多問題都可以使用遞迴演算法或結合遞迴演算法得到解決。   那麼，設計遞迴演算法的關鍵是什麼？  其關鍵之處在於，正確分析出2種類型的節點：出口節點和入口節點   一    演算法關

基礎演算法--排序：之快速排序

與簡單排序不同，快序排序所需的比較次數較少，是內部排序中速度較快的一種排序方法。    演算法思想： 分-------------- 將待排序集合劃分為2部分 （一部分小於準則值，一部分大於等於準則值）      &n

基礎演算法--排序： 之插入排序

氣泡排序兩兩比較指的是： 未排序的相鄰元素之間的兩兩比較，對於已排好的元素，它不再訪問。          而插入排序中的比較則是： 在未排序的元素中，取出一個，將它與已排好的元素進行比較，從而確定其位置。&nb

基礎演算法--排序： 之氣泡排序

 氣泡排序，是所有排序中用的最多和最易想起的一種排序演算法。      其排序思想： 對未排序的相鄰元素進行兩兩比較，找出未排序元素中的最值，並將其置入應有位置。     演算法特點：   &n

php四種基礎演算法：冒泡，選擇，插入和快速排序法 程式碼練習

function maopao($arr,$len) { for($i=1;$i<$len;$i++) { for($j=0;$j<$len-$i;$j++) { if($arr[$j]>$arr[$j+1])

基礎演算法：與、或、異或運算 與、或、異或運算

與、或、異或運算   1.與運算（&） 參加運算的兩個資料，按二進位制位進行“與”運算。 運算規則：0&0=0;   0&1=0;    1&0=0; 

python 基礎演算法題集錦（1）

#(1)尋找序列中的最大值和最小值，不能用內建函式max和min #(2)查詢序列值的出現次數 #(3)逆置序列 #(4)實現序列中元素之和 #(5)實現1+1/2+1/3+1/4+……1/n #(6)實現1+1/2+2/3+3/4+4/5+……（n-1)/n （1）#給定序列li

淚奔！學了1年java的程式設計師面試，掛在了這道基礎演算法題！

  這都是java的演算法題，應該來講都是些比較簡單的演算法題，但是我敢說很多基礎的學習的，或者想去面試的人都會不能完整的寫出來，現在java學習，大多數人都不是非常紮實，對於基礎也不是很重視的，所以就發出來給大家參考鞏固下基礎！ 這篇文章分享之前我還是要推薦下我自己