pytho排序

冒泡排序

冒泡排序（Bubble Sort）也是一种简单直观的排序算法。它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。这个算法的名字由来是因为越小的元素会经由交换慢慢"浮"到数列的顶端。

上代码 ipython3交互模式下

In [1]: def bubble(list_):
   ...:     # 　外层循环表达比较多少轮
   ...:     for i in range(len(list_) - 1):
   ...:         # 内层循环把控比较次数
   ...:         for j in range(len(list_) - 1 - i):
   ...:             if list_[j] > list_[j + 1]:
   ...:                 list_[j], list_[j + 1] = \
   ...:                     list_[j + 1], list_[j]
   ...: 

In [2]: l = [3, 7, 6, 5, 8, 3, 4, 2]

In [3]: bubble(l)

In [4]: print(l)
[2, 3, 3, 4, 5, 6, 7, 8]

选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

In [1]: l = [3, 7, 6, 5, 8, 3, 4, 2]

In [2]: def select(list_):
   ...:     # 外层循环控制比较多少轮
   ...:     for i in range(len(list_) - 1):
   ...:         	min = i  # 假定list_[i] 为最小值
   ...:         	for j in range(i + 1, len(list_)):
   ...:            	 if list_[min] > list_[j]:
   ...:                	 min = j
   ...:         # 　如果ｉ不是最小值则交换
   ...:         	if min != i:
   ...:             	list_[i], list_[min] = \
   ...:                	 list_[min], list_[i]
   ...:             

In [3]: select(l)

In [4]: l
Out[4]: [2, 3, 3, 4, 5, 6, 7, 8]

插入排序

插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

pycharm 环境下

l = [3, 7, 6, 5, 8, 3, 4, 2]
# 　插入
def insert(list_):
    # 　控制每次ｘ选取的待插入数值
    for i in range(1, len(list_)):
      		  x = list_[i]  # 选取待处理的数
      		  j = i - 1
       		 while j >= 0 and list_[j] > x:
          			  list_[j + 1] = list_[j]
          			  j -= 1
   			 list_[j + 1] = x


insert(l)
print(l)

// 输出 :[2, 3, 3, 4, 5, 6, 7, 8]

快速排序

快速排序使用分治法（Divide and conquer）策略来把一个序列（list）分为较小和较大的2个子序列，然后递归地排序两个子序列。
步骤为：
挑选基准值：从数列中挑出一个元素，称为"基准"（pivot）;
分割：重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（与基准值相等的数可以到任何一边）。在这个分割结束之后，对基准值的排序就已经完成;
递归排序子序列：递归地将小于基准值元素的子序列和大于基准值元素的子序列排序。
递归到最底部的判断条件是数列的大小是零或一，此时该数列显然已经有序。
选取基准值有数种具体方法，此选取方法对排序的时间性能有决定性影响。

图2

# 　快排 low 第一个数序列号　high 最后一个数序列号
def quick(list_, low, high):
   		 if low < high:
        			key = sub_sort(list_, low, high)
        			quick(list_, low, key - 1)
        			quick(list_, key + 1, high)

# 完成一轮排序过程
def sub_sort(list_, low, high):
   		  # 　基准数
  		  x = list_[low]
    	 while low < high:
       			 # 　后面的数小于ｘ放到前面的空位
       			 while list_[high] >= x and high > low:
           					 high -= 1
        		 list_[low] = list_[high]  # 将数往前甩
       			 while list_[low] < x and low < high:
           					 low += 1
       			  list_[high] = list_[low]
 		 list_[low] = x  # 将基准数插入
    	 return low
l = [3, 7, 6, 5, 8, 3, 4, 2]
quick(l, 0, 7)
print(l)
// 输出结果:[2, 3, 3, 4, 5, 6, 7, 8]