数据结构与算法_python

元类

 

• 基本算法：

基础

# 冒泡：  https://cuijiahua.com/blog/2017/12/algorithm_1.html
它重复地走访要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢“浮”到数列的顶端，故名冒泡排序。
​
def bubble_sort(alist):
    n = len(alist)
    if n ==0:
        return []
    for j in range(n-1):
        count = 0
        for i in range(n-1-j):
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
                count += 1
        if count == 0 :
            break
     return alist

插入： 其原理是通过构建一个初始的有序序列，然后从无需序列中抽取元素，插入到有序序列的相对排序位置，

def insert_sort(alist):
    n = len(alist)
    for j in range(1,n):
        for i in range(j,0,-1):
            if alist[i] < alist[i-1]
                alist[i],alist[i-1] = alist[i-1],alist[i]
            else:
                break

快排：

def quick_sort(alist,start,end):
    if start >= end:
        return
    mid = alist[start]
    low = start
    hight = end
    
    while low < hight:
        while low < hight and alist[hight] >= mid:
            hight -= 1
        alist[low] = alist[hight]
         while low < hight and alist[low] < mid:
            low += 1
        alist[hight] = alist[low]
    alist[low] = mid
    
    quick_sort(alist,first,low-1)
    quick_sort(alist,low+1,end)
    
        
    

选择：

def selection_sort(alist):
    """选择排序"""
    n = len(alist)
    for i in range(n-1):
        min_index = i   # [0,1,2,3,n-2] 遍历到倒数第二个元素
        for j in range(i+1,n):
            if alist[j] < alist[min_index]:
                min_index = j
​
        # 如果选择出的数据不在正确位置，进行交换
        if min_index != i:
            alist[i],alist[min_index] = alist[min_index],alist[i]
​
​
li = [23,44,32,34,34,23,52,12,34,11]
selection_sort(li)
print(li)
​
# n**2
# 不稳定