常見排序

時間 2019-12-13

標籤常見排序简体版

原文原文鏈接

冒泡排序

一、思路：首先，列表每兩個相鄰的數比較大小，若是前邊的比後邊的大，那麼這兩個數就互換位置。就像是冒泡同樣html

二、代碼關鍵點：算法

趟數：n-1趟
無序區

時間複雜度：O(n2)shell

def bubblr_sort(li):
    for i in range(len(li)-1):#排序的次數
        change = False
        for j in range(len(li)-i-1):  #表示無序區，無序區的範圍爲0,len(li)-i-1
            if li[j] > li[j+1]:
                li[j],li[j+1] = li[j+1],li[j]
                change = True
        if not change:
            return

li = list(range(5))
import random
random.shuffle(li)
print(li)
bubblr_sort(li)
print(li)

選擇排序

一、思路：一趟遍歷完記錄最小的數，放到第一個位置；在一趟遍歷記錄剩餘列表中的最小的數，繼續放置app

二、代碼關鍵點：dom

無序區
最小數的位置

三、問題：怎麼選出最小的數？ui

時間複雜度：O(n2)spa

import random
def select_sort(li):
    for i in range(len(li)-1):
        #i 表示躺數，也表示無序區開始的位置
        min_loc = i  #最小數的位置
        for j in range(i+1,len(li)):  #i  ,i+1，就是後一個位置的範圍
            # [9, 2, 1, 6, 5, 8, 3, 0, 7, 4]
            # [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
            if li[j] <li[min_loc]:  #兩個位置進行比較，若是後面的一個比最小的那個位置還小，說明就找到最小的了
                min_loc = j   #找到最小的位置
        if min_loc !=i:
            li[i],li[min_loc] = li[min_loc],li[i]  #吧找到的兩個值進行互換位置
li = list(range(10))
random.shuffle(li)
print(li)
select_sort(li)
print(li)

插入排序

一、思路：元素被分爲有序區和無序區兩部分。最初有序區只有一個元素。每次從無序區中選擇一個元素，插入到有序區的位置，直到無序區變空。3d

二、代碼關鍵點：code

摸到的牌
手裏的牌

三、圖示說明htm

時間複雜度O(n2)

插入後：

四、代碼示例

import random
def insert_sort(li):
    for i in range(1,len(li)):
        #i 表示無序區的第一個數
        tmp = li[i]  #摸到的牌
        j = i-1 #指向有序區最後一個位置
        while li[j] >tmp and j>=0:
            #循環終止條件 li[j]<=tmp  and j==-1
            li[j+1] = li[j]  #向後移動
            j-=1
        li[j+1] = tmp
        
li = list(range(10))
random.shuffle(li)
print(li)
insert_sort(li)
print(li)

快速排序

一、思路：一、取一個元素p(第一個元素)，是元素p歸位（去它該去的地方）；

　　　　　二、列表被p分紅兩部分，左邊的都比p小，右邊的都比p大；

　　　　　三、遞歸完成排序

二、算法關鍵點

歸位
遞歸

三、圖示說明

四、怎麼歸併呢？先把5取出來，這時候就會有一個空位，從右邊找比5小的數填充過來，如今右邊有一個空位了，從左邊找比5大的放到右邊的空位上。依次類推，

只要left和right碰在一塊兒，這樣就找打5的位置了

如圖示：

圖一圖二

圖三圖四

這樣在把找到的5的位置放進去去ok了

五、代碼示例

# 快速排序
def quickSort(li):
    if li:
        mark=li[0]
        little=[m for m in li if m<mark]
        big=[x for x in li if x>mark]
        return quickSort(little)+[mark]+quickSort(big)
    else:
        return []
if __name__=='__main__':
    li = [3,44,38,5,47,15,36,26,27,2,46,4,19,50,48]
    print(quickSort(li))

歸併排序

假設如今的列表分兩段有序，如何將其合成爲一個有序列表。這種操做稱爲一次歸併

一、思路：

二、歸併關鍵字

分解：將列表越分越小，直至分紅一個元素
終止條件：一個元素是有序的
合併：將兩個有序列表歸併，列表愈來愈大

三、圖實示例：https://www.cnblogs.com/chengxiao/p/6194356.html

四、代碼示例：

import random
def merge(li, low, mid, high):
    # 一次歸併
    '''
    :param li: 列表
    :param low: 起始位置
    :param mid: 按照那個位置分
    :param high: 最後位置
    :return:
    '''
    i = low
    j = mid + 1
    ltmp = []
    while i <= mid and j <= high:
        if li[i] < li[j]:
            ltmp.append(li[i])
            i += 1
        else:
            ltmp.append(li[j])
            j += 1
    while i <= mid:
        ltmp.append(li[i])
        i += 1
    while j <= high:
        ltmp.append(li[j])
        j += 1
    li[low:high+1] = ltmp


def _merge_sort(li, low, high):
    if low < high:  # 至少兩個元素
        mid = (low + high) // 2
        _merge_sort(li, low, mid)
        _merge_sort(li, mid+1, high)
        merge(li, low, mid, high)
        print(li[low:high+1])


def merge_sort(li):
    return _merge_sort(li, 0, len(li)-1)


li = list(range(16))
random.shuffle(li)
print(li)
merge_sort(li)

print(li)

歸併排序

歸併排序的時間複雜度：O(nlogn)，空間複雜度是：O(n)

希爾排序

希爾排序是一種分組插入排序算法。
首先取一個整數d1=n/2，將元素分爲d1個組，每組相鄰量元素之間距離爲d1，在各組內進行直接插入排序；
取第二個整數d2=d1/2，重複上述分組排序過程，直到di=1，即全部元素在同一組內進行直接插入排序。
希爾排序每趟並不使某些元素有序，而是使總體數據愈來愈接近有序；最後一趟排序使得全部數據有序

def shell_sort(alist):
    n = len(alist)
    # 初始步長
    gap = n // 2
    while gap > 0:
        # 按步長進行插入排序
        for i in range(gap,n): 
            j = i
            # 原地插入排序，以前的插入排序另闢空間存儲的
            while j>=gap and alist[j-gap] > alist[j]:
                alist[j-gap], alist[j] = alist[j], alist[j-gap]
                j -= gap
        # 獲得新的步長
        gap = gap //2

alist = [54,26,93,17,77,31,44,55,20]
shell_sort(alist)
print(alist)