vlambda博客
学习文章列表

(from unsplash)

选择排序

是一种灵巧的算法，但速度不是很快。数据规模越小越好。

运行时间：O(n^2)

算法思想：

1. 在未排序序列中找到最小（最大）元素，存放到排序序列的起始位置。

2. 再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。

3. 重复第二步，直到所有元素均排序完毕。

Python3

（代码已上传https://github.com/sisyphuswxg/algorithms_python）

  
    
    
  
 
   # -*- coding: utf-8 -*-
 
  
  
    
    
  
 
   #
 
  
  
    
    
  
 
   # Author: sisyphuswxg
 
  
  
    
    
  
 
   # Date: 2020-12-8
 
  
  
    
    
  
 
   # Desc: Selection Sort
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   class SelectionSort:
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
       def find_smallest(self, arr):
 
  
  
    
    
  
 
           smallest = arr[0]
 
  
  
    
    
  
 
           smallest_index = 0
 
  
  
    
    
  
 
           for i in range(1, len(arr)):
 
  
  
    
    
  
 
               if arr[i] < smallest:
 
  
  
    
    
  
 
                   smallest_index = i
 
  
  
    
    
  
 
           return smallest_index
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
       def selection_sort(self, arr):
 
  
  
    
    
  
 
           new_arr = []
 
  
  
    
    
  
 
           for i in range(len(arr)):
 
  
  
    
    
  
 
               smallest_index = self.find_smallest(arr)
 
  
  
    
    
  
 
               new_arr.append(arr.pop(smallest_index))
 
  
  
    
    
  
 
           return new_arr
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   if __name__ == "__main__":
 
  
  
    
    
  
 
       my_list = [5, 3, 6, 3, 3, 38, 99, 2, 10, 7, 53, 532]
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
       ss = SelectionSort()
 
  
  
    
    
  
 
       print(ss.selection_sort(my_list))
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   # run:
 
  
  
    
    
  
 
   [2, 3, 3, 3, 5, 6, 7, 10, 38, 53, 99, 532] 
  

快速排序

算法思想是分而治之D&C（divide and conquer），是一种著名的非递归式问题解决方法。 
快速排序是一种常用的排序算法，比选择排序快得多。

时间复杂度：O(nlogn) 
【平均运行时间为O(nlogn)，最坏的情况下为O(n^2)】

步骤：

1. 在数列之中，选择一个元素作为“基准”（pivot）

2. 数列中所有元素都和这基准值作比较：比基准值小的就移动到基准值的左边，比基准值大的移动到基准值的右边

3. 以基准值左右两边的子列作为新数列，不断重复第一步和第二步，知道所有子集只剩下一个元素为止

特点：

• 稳定性：是不稳定排序，如基准值的前后都存在与基准值相同的元素，那么相同值就会被放在一边，这样就打乱了之前的相对顺序

• 比较性：因为排序时元素之间需要比较，所以是比较排序

• 有一个缺点就是对于小规模的数据集性能不是很好

Python3

  
    
    
  
 
   # -*- coding: utf-8 -*-
 
  
  
    
    
  
 
   #
 
  
  
    
    
  
 
   # Author: sisyphuswxg
 
  
  
    
    
  
 
   # Date: 2020-12-9
 
  
  
    
    
  
 
   # Desc: Quick Sort
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   class QuickSort:
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
       def quick_sort(self, arr):
 
  
  
    
    
  
 
           if len(arr) < 2:
 
  
  
    
    
  
 
               return arr
 
  
  
    
    
  
 
           else:
 
  
  
    
    
  
 
               pivot = arr[0]
 
  
  
    
    
  
 
               less = [i for i in arr[1:] if i <= pivot]
 
  
  
    
    
  
 
               greater = [i for i in arr[1:] if i > pivot]
 
  
  
    
    
  
 
               return self.quick_sort(less) + [pivot] + self.quick_sort(greater)
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   if __name__ == "__main__":
 
  
  
    
    
  
 
       my_list = [5, 3, 6, 3, 3, 38, 99, 2, 10, 7, 53, 532]
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
       qs = QuickSort()
 
  
  
    
    
  
 
       print(qs.quick_sort(my_list))
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   
 
  
  
    
    
  
 
   # run：
 
  
  
    
    
  
 
   [2, 3, 3, 3, 5, 6, 7, 10, 38, 53, 99, 532] 
  

[1]. 算法图解