Python

五种排序算法

• 冒泡◾选择◾插入◾希尔◾快排

1.冒泡排序

•<>冒泡排序<>
	◾将乱序列表中的最大值逐步找出，将最大值最终移动到最后的位置

def sort(alist):
    for i in range(0,len(alist)-1):#循环n-1次,n就是列表元素的个数
        if alist[i] > alist[i+1]:
            alist[i],alist[i+1] = alist[i+1],alist[i]
    print(alist)
    
alist = [3,8,5,7,6]
sort(alist)

[3, 5, 7, 6, 8]

• |将上述操作在逐步的作用（n-1次）

def sort(alist):
    for j in range(0,len(alist)-1):
        for i in range(0,len(alist)-1-j):#循环n-1次,n就是列表元素的个数
            if alist[i] > alist[i+1]:
                alist[i],alist[i+1] = alist[i+1],alist[i]
    return alist
    
alist = [3,8,5,7,6]
print(sort(alist))

[3, 5, 6, 7, 8]

2.选择排序

选择排序改进了冒泡排序，每次遍历列表只做一次交换。为了做到这一点，一个选择排序在他遍历时寻找最大的值，并在完成遍历后，将其放置在正确的位置。

•<>选择排序<>
	◾1.直接将列表中的最大值找出，直接放置到列表最后的位置

def sort(alist):
    max_index = 0 #最大值的下标，一开始假设第0个元素为最大值
    for i in range(0,len(alist)-1):#为了找出最大值的下标
        if alist[max_index] < alist[i+1]:
            max_index = i+1
    alist[max_index],alist[len(alist)-1] = alist[len(alist)-1],alist[max_index]
    return alist
    
 
alist = [3,8,5,7,6]
print(sort(alist))    

[3, 6, 5, 7, 8]

• 将上述操作在逐步的作用（n-1次）

  def sort(alist):
      for j in range(0, len(alist) - 1):
          max_index = 0  # 最大值的下标，一开始假设第0个元素为最大值
          for i in range(0, len(alist) - 1 - j):  # 为了找出最大值的下标
              if alist[max_index] < alist[i + 1]:
                  max_index = i + 1
  
              alist[max_index],alist[len(alist)-1-j] = alist[len(alist)-1-j],alist[max_index]
      return alist
      
      
  alist = [3,8,5,7,6]
  print(sort(alist))
  
  [3, 5, 6, 7, 8]
  
  

3.插入排序

•插入排序：将列表假设分成两部分，第一部分为列表的第一个元素（有序序列），剩下的元素（无序序列），以此将无序序列中的元素逐一插入到有序序列的合适位置
	◾变量i表示列表下标，还表示有序序列中元素的个数

#有序序列只有一个元素，无序序列元素个数为n-1
i = 1 
#alist[i-1]:有序序列的最后一个元素
#alist[i]:无序序列的第一个元素
if alist[i]  <  alist[i-1]:
    alist[i],alist[i-1] = alist[i-1],alist[i]

i = 2 #有序序列有两个元素
#alist[i]:无序序列的第一个元素
#alist[i-1]:有序序列的最后一个元素
while i >= 1:
    if alist[i] < alist[i-1]:
        alist[i],alist[i-1] = alist[i-1],alist[i]
        i -= 1
    else:
        break

#完整代码：自动处理i（1：len-1）
def sort(alist):
    for i in range(1,len(alist)):
        while i >= 1:
            if alist[i] < alist[i-1]:
                alist[i],alist[i-1] = alist[i-1],alist[i]
                i -= 1
            else:
                break
    return alist
    
alist = [49,38,65,97,76,13,27]
print(sort(alist))

[13, 27, 38, 49, 65, 76, 97]

4.希尔排序

- 希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本,该方法的基本思想是：先将整个待排元素序列分割成若干个子序列（由相隔某个“增量（gap）”的元素组成的）分别进行直接插入排序，然后依次缩减增量再进行排序，待整个序列中的元素基本有序（增量足够小）时，再对全体元素进行一次直接插入排序。因为直接插入排序在元素基本有序的情况下（接近最好情况），效率是很高的，因此希尔排序在时间效率比直接插入排序有较大提高。
•希尔排序
	◾插入排序就是增量为1的希尔排序
		◾gap：初始值元素个数整除2
			◦gap分组的组数

def sort(alist):
    gap = len(alist)//2
    #将下属所有的1换成gap
    for i in range(gap,len(alist)):
        while i >= gap:
            if alist[i] < alist[i-gap]:
                alist[i],alist[i-gap] = alist[i-gap],alist[i]
                i -= gap
            else:
                break
    return alist

#缩减增量
def sort(alist):
    gap = len(alist)//2
    
    while gap >= 1:
        #将下属所有的1换成gap
        for i in range(gap,len(alist)):
            while i >= gap:
                if alist[i] < alist[i-gap]:
                    alist[i],alist[i-gap] = alist[i-gap],alist[i]
                    i -= gap
                else:
                    break
        gap //= 2 #缩减增量
    return alist
    
alist = [49,38,65,97,76,13,27]
print(sort(alist))
[13, 27, 38, 49, 65, 76, 97]

5.快速排序

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

• 第一次排序：将将比基准小的排列在基准左侧，比基准大的排列在基准右侧

•快排：6 1 2 7 9 3 4 5 10 8
	◾基数：初始值就是列表中的第一个元素◦操作：将整个列表元素中比基数小的值全部放置到基数的左侧，将比基数大的值全部放置到基数的右侧

#将基数放置到合适的位置：基数左侧为比基数小的数值，基数右侧为比基数大的数值
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#high向左偏移
            else:
                alist[low] = alist[high]
                break
        while low < high:
            if alist[low] < mid:
                low += 1
            else:
                alist[high] = alist[low]
                break
    if low == high:
        alist[low] = mid
        
    #递归
    sort(alist,start,high-1)#处理基数左部分的乱序序列
    sort(alist,low+1,end)#处理基数右部分的乱序序列
    return alist
    
alist = [49,38,65,97,76,13,27]
print(sort(alist,0,len(alist)-1))
[13, 27, 38, 49, 65, 76, 97]