数据结构与算法 排序

Posted 2022-07-20 xlhit

冒泡排序

• 1.将原始列表中的最大值找出且放置在列表最右侧(将元素两两比较，将数值大的数逐步向后移动)
• 2.重复执行步骤1

第一步

#将原始列表中的最大值找出且放置在列表最右侧(将元素两两比较，将数值大的数逐步向后移动)
def sort(alist):
    for i in range(len(alist)-1):
        if alist[i] > alist[i+1]:
            alist[i],alist[i+1] = alist[i+1],alist[i]
    return alist

#判断 循环次数

def sort(alist):
    for j in range(len(alist)-1):
　　　　　#不断把最大的移动到最后
        for i in range(len(alist)-1-j):
            if alist[i]>alist[i+1]:
                alist[i] ,alist[i + 1]=alist[i + 1],alist[i]
    return alist
alist=[1,2,5,3,2,8,6,0]
print(sort(alist))

选择排序

选择排序

• 1.将列表中的最大值一次找出，放置在列表最右侧

#将列表中的最大值的下标找到
def sort(alist):
    max_index = 0 #最大值的下标
    for i in range(1,len(alist)):
        if alist[max_index] < alist[i]:
            max_index = i
    print(max_index)

#将列表中的最大值一次找出，放置在列表最右侧
def sort(alist):
    max_index = 0 #最大值的下标
    for i in range(1,len(alist)):
        if alist[max_index] < alist[i]:
            max_index = i
    alist[max_index],alist[len(alist)-1] = alist[len(alist)-1],alist[max_index]
    
    return alist

正式代码

def sort(alist):
　　#依次缩小列表范围
    for j in range(len(alist),1,-1):
        max_index = 0 #最大值的下标
        for i in range(1,j):  #len(alist)  == > j
            if alist[max_index] < alist[i]:
                max_index = i
        alist[max_index],alist[j-1] = alist[j-1],alist[max_index]
    
    return alist


alist=[1,2,5,3,2,8,6,0]
print(sort(alist))

插入排序

• 将乱序列表分成两部分，一部分是有序部分，一部分是乱序部分，将乱序部分的每一个元素插入到有序部分的合适位置 [5, 3,9,4,1] #[3,5, 9,4,1] [3,5, 9,4,1] #[3,5,9, 4,1] [3,5,9, 4,1] #[3,4,5,9, 1]

一步一步。。。。。。

#执行第一次插入操作
def sort(alist):
    i = 1
    # alist[i-1]:第一次插入时的有序列表
    # alist[i]:乱序列表中的第一个列表元素
    if alist[i] < alist[i-1]:
        alist[i],alist[i-1] = alist[i-1],alist[i]  

def sort(alist):
    i = 2
    # alist[i-1]:第一次插入时的有序列表
    # alist[i]:乱序列表中的第一个列表元素
    if alist[i] < alist[i-1]:
        alist[i],alist[i-1] = alist[i-1],alist[i]      

def sort(alist):
    i = 3
    # alist[i-1]:第一次插入时的有序列表
    # alist[i]:乱序列表中的第一个列表元素
    while i > 0:
        if alist[i] < alist[i-1]:
            alist[i],alist[i-1] = alist[i-1],alist[i] 
            i -= 1
        else:
            break

走起

def sort(alist):
    for i in range(1,len(alist)):
        # alist[i-1]:第一次插入时的有序列表
        # alist[i]:乱序列表中的第一个列表元素
        while i > 0:
            if alist[i] < alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i] 
                i -= 1
            else:
                break
    return alist

alist=[1,4,6,2,3,2,8,6,0]
print(sort(alist))

 

希尔排序

• 增量为1的希尔排序就是插入排序

#增量为1的希尔排序（插入排序的核心）
def sort(alist):
    #增量
    gap = len(alist) // 2
    
    for i in range(1,len(alist)):
        # alist[i-1]:第一次插入时的有序列表
        # alist[i]:乱序列表中的第一个列表元素
        while i > 0:
            if alist[i] < alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i] 
                i -= 1
            else:
                break
    return alist

#增量为gap的希尔排序
def sort(alist):
    #增量
    gap = len(alist) // 2
    for i in range(gap,len(alist)):
        # alist[i-1]:第一次插入时的有序列表
        # alist[i]:乱序列表中的第一个列表元素
        while i > 0:
            if alist[i] < alist[i-gap]:
                alist[i],alist[i-gap] = alist[i-gap],alist[i] 
                i -= gap
            else:
                break
    return alist

#继续缩小增量（gap）
def sort(alist):
    #增量
    gap = len(alist) // 2
    
    while gap >= 1 :
        for i in range(gap,len(alist)):
            # alist[i-1]:第一次插入时的有序列表
            # alist[i]:乱序列表中的第一个列表元素
            while i > 0:
                
                if alist[i] < alist[i-gap] and i-gap>0:
                    alist[i],alist[i-gap] = alist[i-gap],alist[i] 
                    i -= gap
                else:
                    break
        gap //= 2
    return alist

 

快速排序

• 将列表中第一个元素设定为基准数字，赋值给mid变量，然后将整个列表中比基准小的数值放在基准的左侧，比基准到的数字放在基准右侧。然后将基准数字左右两侧的序列在根据此方法进行排放。
• 定义两个指针，low指向最左侧，high指向最右侧
• 然后对最右侧指针进行向左移动，移动法则是，如果指针指向的数值比基准小，则将指针指向的数字移动到基准数字原始的位置，否则继续移动指针。
• 如果最右侧指针指向的数值移动到基准位置时，开始移动最左侧指针，将其向右移动，如果该指针指向的数值大于基准则将该数值移动到最右侧指针指向的位置，然后停止移动。
• 如果左右侧指针重复则，将基准放入左右指针重复的位置，则基准左侧为比其小的数值，右侧为比其大的数值。

def sort(alist,start,end):
    low = start
    high = end
  
    #结束递归的条件
    if low > high:
        return
    mid = alist[low]
  
    
    while low < high:
        while low < high:
            if alist[high] > mid:
                high -= 1
            else:
                alist[low] = alist[high]
                break
        while low < high:
            if alist[low] < mid:
                low += 1
            else:
                alist[high] = alist[low]
                break      
    alist[low] = mid
    
    sort(alist,start,high-1)
    sort(alist,low+1,end) #将基准右侧的子列表进行递归操作

    
    return alist

alist = [2,4,5,1,3]
print(sort(alist,0,len(alist)-1))