排序算法 - 6种 - 超炫的动画演示 - Python实现

1.冒泡排序

思路：遍历列表，每一轮每次比较相邻两项，将无序的两项交换，下一轮遍历比前一轮比较次数减1。

   
   

     
     

      
      

     
     
     
     

      
      

       
       def bubble_sort(a_list):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
    
       
       for passnum 
       
       in range(len(a_list)
       
       -1, 
       
       0, 
       
       -1):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       for i 
       
       in range(passnum):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
            
       
       if a_list[i] > a_list[i+
       
       1]:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                        a_list[i], a_list[i+
       
       1] = a_list[i+
       
       1], a_list[i]
      
      
     
     
   
   

改进：遍历期间没有交换，则认为已排序，可以停止。

   
   

     
     

      
      

     
     
     
     

      
      

       
       def short_bubble_sort(a_list):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           exchanges = 
       
       True
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           passnum = len(a_list) - 
       
       1
      
      
     
     

     
     

      
      

     
     
     
     

      
      
    
       
       while passnum > 
       
       0 
       
       and exchanges:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               exchanges = 
       
       False
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       for i 
       
       in range(passnum):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
            
       
       if a_list[i] > a_list[i+
       
       1]:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                       exchanges = 
       
       True
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                       a_list[i], a_list[i+
       
       1] = a_list[i+
       
       1], a_list[i]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               passnum = passnum - 
       
       1
      
      
     
     
   
   

动画演示：

2.选择排序

思路：遍历列表，每次遍历选出最大的放在合适的位置。

   
   

     
     

      
      

     
     
     
     

      
      

       
       def selection_sort(a_list):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
    
       
       for fillslot 
       
       in range(len(a_list)
       
       -1, 
       
       0, 
       
       -1):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               position_max=
       
       0
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       for location 
       
       in range(
       
       1, fillslot+
       
       1):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
            
       
       if a_list[location] > a_list[position_max]:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                       position_max = location
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               a_list[fillslot], a_list[position_max] = a_list[position_max], a_list[fillslot]
      
      
     
     
   
   

动画演示：

3.插入排序

思路：每一步都将待插入的数据按大小插入到已排序的数据中的合适位置。

   
   

     
     

      
      

     
     
     
     

      
      

       
       def insertion_sort(a_list):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
    
       
       for index 
       
       in range(
       
       1, len(a_list)):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               cur_value = a_list[index]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               pos = index
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       while pos > 
       
       0 
       
       and a_list[pos
       
       -1] > cur_value:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   a_list[pos] = a_list[pos
       
       -1]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   pos = pos - 
       
       1
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               a_list[pos] = cur_value
      
      
     
     
   
   

动画演示：

4.希尔排序

思路：分解为多个子列表进行插入排序，不是连续分，而是通过增量。

   
   

     
     

      
      

     
     
     
     

      
      

       
       def shell_sort(a_list):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           sublist_count = len(a_list)
      
      
     
     

     
     

      
      

     
     
     
     

      
      
    
       
       while sublist_count > 
       
       0:
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       for start_position 
       
       in range(sublist_count):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   gap_insertion_sort(a_list, start_position, sublist_count)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               sublistcount = sublistcount // 
       
       2
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       def gap_insertion_sort(a_list, start, gap):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
    
       
       for i 
       
       in range(start+gap, len(a_list), gap):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               current_value = a_list[i]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               position = i
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       while position >= gap 
       
       and a_list[position-gap] > current_value:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   a_list[position] = a_list[position-gap]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   position = position - gap
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               a_list[position] = current_value
      
      
     
     
   
   

5.归并排序

思路：分而治之，不断拆分为一半，直至项数为0或1，然后排序合并。需要额外空间。

   
   

     
     

      
      

     
     
     
     

      
      

       
       def merge_sort(a_list):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
    
       
       if len(a_list) > 
       
       1:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               mid = len(a_list) // 
       
       2
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               lefthalf = a_list[:mid]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               righthalf = a_list[mid:]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               merge_sort(lefthalf)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               merge_sort(righthalf)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               i=
       
       0
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               j=
       
       0
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               k=
       
       0
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       while i < len(lefthalf) 
       
       and j < len(righthalf):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
            
       
       if lefthalf[i] < righthalf[j]:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                       a_list[k] = lefthalf[i]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                       i = i + 
       
       1
      
      
     
     

     
     

      
      

     
     
     
     

      
      
            
       
       else:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                       a_list[k] = righthalf[j]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                       j = j + 
       
       1
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   k=k+
       
       1
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       while i < len(lefthalf):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   a_list[k] = lefthalf[i]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   i = i + 
       
       1
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   k = k + 
       
       1
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       while j < len(righthalf):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   a_list[k] = righthalf[j]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   j = j + 
       
       1
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   k = k + 
       
       1
      
      
     
     
   
   

动画演示：

6.快速排序

思路：与归并一样使用分而治之，不使用额外内存，特点是枢轴值。

   
   

     
     

      
      

     
     
     
     

      
      

       
       def quick_sort(a_list):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           quick_sort_helper(a_list, 
       
       0, len(a_list)
       
       -1)
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       def quick_sort_helper(a_list, first, last):
      
      
     
     

     
     

      
      

     
     
     
     

      
      
    
       
       if first < last:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               splitpoint = partition(a_list, first, last)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               quick_sort_helper(a_list, first, splitpoint
       
       -1)
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
               quick_sort_helper(a_list, splitpoint+
       
       1, last)
      
      
     
     

     
     

      
      

     
     
     
     

      
      
 
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
       def partition(a_list, first, last):
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           pivotvalue = a_list[first]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           leftmark = first + 
       
       1
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           rightmark = last
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           done = 
       
       False
      
      
     
     

     
     

      
      

     
     
     
     

      
      
    
       
       while 
       
       not done:
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       while leftmark <= rightmark 
       
       and a_list[leftmark] <= pivotvalue:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   leftmark = leftmark + 
       
       1
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       while a_list[rightmark] >= pivotvalue 
       
       and rightmark >= leftmark:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   rightmark = rightmark 
       
       -1
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       if rightmark < leftmark:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   done = 
       
       True
      
      
     
     

     
     

      
      

     
     
     
     

      
      
        
       
       else:
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
                   a_list[leftmark], a_list[rightmark] = a_list[rightmark], a_list[leftmark]
      
      
     
     

     
     

      
      

     
     
     
     

      
      

       
           a_list[first], a_list[rightmark] = a_list[rightmark], a_list[first]
      
      
     
     
   
   

动画演示：

说明：

1.参考https://interactivepython.org/runestone/static/pythonds/SortSearch/toctree.html

2.动画来自https://visualgo.net/en 截图