冒泡算法,選擇排序算法,插入排序算法,快速排序算法,歸併排序算法,計數排序算法,鏈表算法(單例)

1.冒泡算法

# 冒泡算法
# 時間複雜度O(n^2),由於循環2次輸出
# 空間複雜度:O(1),在循環中沒有創做新的空間因此是O(1)
li = [5, 3, 8, 1, 2, 4, 9, 7, 6]

# 比較方式是第一位和第二位進行比較,若是第一位的數大於第二位數就進行交換,而後第二位和第三位進行比較.就這樣依次進行比較
# 而後最右邊的數就會變成最大的數
def bubble_sort(li):
    # 從第一個開始比大小,只要比長度-1次就能夠,好比如今li的長度是9,比8次就能夠比完 ,多比較一次沒意義因此是len(li)-1
    for i in range(len(li) - 1):
        # 這裏設置flag參數是爲了優化冒泡排序,若是下面的排序比較if li[j] > li[j + 1]:
        # 不經過的話說明給的列表裏面的數字是已經排序好的因此就不用進行比較直接return返回這個列表
        flag = False
        # 這裏len(li) - 1的意思和上面同樣,再減去i是由於所有比較完一次以後,
        # 最右側的確定是最大數,下一輪就不用比較最右側的數,能夠少比較一次
        # 因此每次比較完一輪以後要減去 i ,最後結果是len(li) - 1 - i
        for j in range(len(li) - 1 - i):
            # 從左到右進行依次比較,若是左邊的數大於右邊的數就進行位置交換
            if li[j] > li[j + 1]:
                # 右邊的數和左邊的數進行交換賦值
                li[j], li[j + 1] = li[j + 1], li[j]
                flag = True
        # 直接返回該列表
        if not flag:
            return


bubble_sort(li)
print(li)

 

2.選擇排序算法

# 選擇排序算法
# 時間複雜度: O(n^2) 空間複雜度: O(1)
# 比較的方式是最左邊(第一位)的數和第二位進行比較,若是第二位的數小於第一位的數就進行交換.而後最左邊(第一位)的數,就變成比較以後小的呢位數
# 而後最左邊(第一位)的數再和第三位進行比較,若是第三位數大就不進行交換,小的話就再進行交換
# 這樣一輪比較下來最後最左邊(第一位)的數就會變成列表最小的數
# 而後第二輪就用第二位的數進行比較,依次進行比較.最後就排序完成

li = [5, 3, 8, 1, 2, 4, 9, 7, 6]

def select_sort(li):
    # 從第一個開始比大小,只要比長度-1次就能夠,好比如今li的長度是9,比8次就能夠比完,多比較一次沒意義因此是len(li)-1
    for i in range(len(li) - 1):
        # 這個表明從索引0第一個開始比較
        minLoc = i
        # 從索引第二位開始進行匹配,到總共的長度的次數.(相等與總長度的次數-1次)
        for j in range(i + 1, len(li)):
            # 索引0位和索引1位進行比較若是大於進行交換,到最後最小的在索引0位
            # 而後下一輪再索引1位進行依次比較
            if li[minLoc] > li[j]:
                # 比較成功後進行位置交換
                li[minLoc], li[j] = li[j], li[minLoc]


select_sort(li)
print(li)

3.插入排序算法

# 插入排序算法
# 時間複雜度: O(n^2) 空間複雜度: O(1)
# 比較方法是第一次是索引第二位(數字3也是tmp)和索引第一位(數字5)進行比較,若是索引的第一位比第二位大,第二位的值(數字3)會變成第一位(數字5).
# 而後 j 索引-1(若是索引的值成爲負數說明左邊已經沒有數須要進行比較.這樣就會退出while循環
# 而後 j + 1就變成索引0,而後第一位的數再賦值成tmp(數字3).(就是比較下來小的數).
# 接下來一輪索引2(數字8也是tmp),和(j=i-1)索引1(數字5)進行比較.索引2(數字8)比索引1(數字5)大while條件不成立,而後(j+1)索引2仍是8(tmp),數字不變進行下一輪比較
# 再接下來索引3(數字1也是tmp)和索引2(數字8)進行比較,索引3(數字1)比索引2(數字8)小,索引3(數字1)變成數字8,而後索引1(數字5)的值和tmp(數字1)進行比較
# 結果索引1(數字5大)而後索引2(數字8)變成索引1(數字5).
# 而後索引0(數字3)再和tmp(數字1)進行比較,結果索引0(數字3)數字大而後索引1(數字5)變成索引0(數字3)
# 再而後 j 索引-1(若是索引的值成爲負數說明左邊已經沒有數須要進行比較.這樣就會退出while循環,
# 而後 j + 1就變成索引0,而後第一位的數再賦值成tmp(數字1).(最後索引0就是最小的數這樣開始排序).就這樣依次進行對比
li = [5, 3, 8, 1, 2, 4, 9, 7, 6]
def insert_sort(li):
    # 插入排序須要每一次和左邊的數進行比較,因此索引範圍是從1到範圍長度
    for i in range(1,len(li)):
        tmp = li[i]
        # 索引減一是爲了和左邊的數進行比較
        j = i - 1
        # 索引沒有爲-1說明還有值能夠進行比較 而且 左邊的值要大於 tmp
        while j >=0 and li[j] > tmp:
            # 條件成立當前的索引的值被左邊的值覆蓋
            li[j+1] = li[j]
            # 而後再和再左邊的索引值進行比較
            j = j -1
        # 到這裏說明j = -1 沒有值再須要進行比較索引0直接變成tmp(比較下來最小的值)
        li[j+1] = tmp
insert_sort(li)
print(li)

4.快速排序

# 快速排序
# 時間複雜度: O(nlogn)
def partition(li,left,right):
    temp = li[left]
    while left < right:
        while left < right and li[right] >= temp:
            right = right - 1
        li[left] = li[right]
        while left < right and li[left] <= temp:
            left = left + 1
        li[right] = li[left]

    li[left] = temp
    return left


def quick_sort(li,left,right):
    if left < right:
        mid = partition(li,left,right)
        quick_sort(li,left,mid-1)
        quick_sort(li,mid+1,right)


li = [5, 3, 8, 1, 2, 4, 9, 7, 6]
quick_sort(li, 0, len(li)-1)
print(li)

5.歸併排序

# 歸併排序
# 時間複雜度: O(nlogn)
# 空間複雜度: O(n)
def merge(li, low, mid, high ):
    i = low
    j = mid + 1
    ltmp = []

    while i <= mid and j <= high:
        if li[i] < li[j]:
            ltmp.append(li[i])
            i = i + 1
        else:
            ltmp.append(li[j])
            j = j + 1

    while i <= mid:
        ltmp.append(li[i])
        i = i + 1

    while j <= high:
        ltmp.append(li[j])
        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)
        print("歸併前: ",li[low:high+1])
        merge(li, low, mid, high)
        print("歸併後: ",li[low:high + 1])

li = [10, 4, 6, 3, 8, 2, 5, 2, 1, 7, 0]
# 索引範圍0~10
merge_sort(li, 0, 10)
print(li)

6.計數排序

計數排序
def countsort(li):

    count = [0 for i in range(11)]

    for i in li:
        # print(i)
        count[i] += 1
    li.clear()
    for n, num in enumerate(count):
        print(n, num)
        for i in range(num):
            li.append(n)


li = [10,4,6,3,8,2,5,2,1,7,0]
countsort(li)
print(li)

7.鏈表算法(單例)

# 鏈表算法(單例)
class Hero(object):
    def __init__(self, no=None, name=None, nickname=None, Next=None):
        self.no = no
        self.name = name
        self.nickname = nickname
        self.Next = Next

def addHero(head, hero):
    cur = head
    # 第一種 添加到鏈表後面
    # while cur.Next != None:
    #     cur = cur.Next
    # cur.Next = hero
    ###第二種 指定添加
    # print(cur.Next,"1")
    while cur.Next != None:
        ### 找到了指定的位置, 直接跳出while循環
        if cur.Next.no > hero.no :
            break
        ### 沒有找到的話, 繼續找
        cur = cur.Next

    hero.Next = cur.Next
    cur.Next = hero

def getAll(head):
    cur = head
    while cur.Next != None:
        cur = cur.Next
        print('編號是:%s, 姓名是:%s, 外號是%s' % (cur.no, cur.name, cur.nickname) )

head = Hero()

hero1 = Hero(1, '宋江', '及時雨')
# print(hero1)
addHero(head, hero1)

hero2 = Hero(2, '盧俊義', '玉麒麟')
addHero(head, hero2)

hero4 = Hero(4, '武松', '打老虎')
addHero(head, hero4)

hero3 = Hero(3, '金蓮', '武大郎')
addHero(head, hero3)


getAll(head)