八大经典排序算法——Python（PS：二分查找）

一、冒泡排序（交换排序）  

# BubbleSort - Using bubble sort method for a chaotic sequence in ascending order, request the first to come up to the minimum.

class Solution(object):
    def bubbleSort(self, nums):
        size = len(nums)
        for i in range(0, size - 1):
            j = size - 1
            while j > 0:
                if nums[j] < nums[j - 1]:
                    nums[j - 1], nums[j] = nums[j], nums[j - 1]
                j -= 1
        return nums

if __name__ == "__main__":
    s = Solution()
    print(s.bubbleSort(nums=[35, 80, 21, 54, 11, 45, 92, 39]))

二、选择排序  

# SelectionSort - Using the selection method for a chaotic sequence in ascending order.

def SelectSort(a):
    for i in range(0, len(a) - 1):    # 外层循环 找i次最小值
        min = i               # 此处记录最小值位置，不能改变数列中的数值
        for j in range(i + 1, len(a) - 1):    # 内层循环 找到最小值
            if a[j] < a[min]:
                min = j      # 变量 j 更新并记录最小值位置
        p = a[i]      # 变量 p 储存最小值（把第一个最小值放入的位置的那个原有值记录在temp里）
        a[i] = a[min]   # 将最小值覆盖到那个位置里
        a[min] = p    # 再把p里保存的最小值更新到未排数列的第一个
    return a

print(SelectSort(a=[35, 80, 21, 54, 11, 45, 92, 39]))

三、插入排序  

# InsertSort - Using insertion sort method for a chaotic sequence in ascending order.

class Solution(object):
    def insertionSort(self, nums):
        size = len(nums)
        for i in range(1, size):
            if nums[i] < nums[i - 1]:
                temp = nums[i]
                j = i        # 记下未排序第一个的位置
                while j > 0 and temp < nums[j - 1]:
                    nums[j] = nums[j - 1]
                    j -= 1
                nums[j] = temp   # 插入待排序的数字
        return nums

if __name__ == "__main__":
    s = Solution()
    print(s.insertionSort(nums=[35, 80, 21, 54, 11, 45, 92, 39]))

四、希尔排序——（插入排序的改进）

#!/usr/bin/env python
# coding:utf-8

def shellSort(nums):
    # 设定步长
    step = len(nums)/2
    while step > 0:
        for i in range(step, len(nums)):
            # 类似插入排序, 当前值与指定步长之前的值比较, 符合条件则交换位置
            while i >= step and nums[i-step] > nums[i]:
                nums[i], nums[i-step] = nums[i-step], nums[i]
                i -= step
        step = step/2
    return nums

if __name__ == '__main__':
    nums = [9,3,5,8,2,7,1]
    print shellSort(nums)

五、快速排序——（冒泡排序的改进）

    过程：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序（递归实现）。

一趟快速排序的算法是：

1）设置两个变量low、high，排序开始的时候：low=0，high=len(a)-1；

2）以第一个数组元素作为关键数据，赋值给key，即key=a[low]；

3）从j开始向前搜索，即由后开始向前搜索(high--)，找到第一个小于key的值a[high]，将a[high]和a[low]互换；

4）从i开始向后搜索，即由前开始向后搜索(low++)，找到第一个大于key的a[low]，将a[low]和a[high]互换；

5）重复第3、4步，直到low=high；

       (3,4步中，没找到符合条件的值，即3中a[high]不小于key,4中a[low]不大于key的时候改变high、low的值，使得high=high-1，low=low+1，直至找到为止。找到符合条件的值，

进行交换的时候low， high指针位置不变。另外，low==high这一过程一定正好是low+或high-完成的时候，此时令循环结束）。

# QuickSort - Using quick sort method for a chaotic sequence in ascending order.


def partition(a, left, right):   # 定义分区函数，第一遍排序
    low = left
    high = right
    key = a[low]
    while low < high:
        while low < high and a[high] >= key:    # 因为基准 key 从左开始，所以第一遍从右开始遍历
            high -= 1
        a[low] = a[high]
        while low < high and a[low] <= key:
            low += 1
        a[high] = a[low]
        a[low] = key                       # 每一次循环结束记录一次基准 key 的位置，防止 key 值丢失
    return low

def QuickSort(a, left, right):            # 定义递归函数
    if left < right:                      # ！！！判断条件很重要，很容易忽略
        p = partition(a, left, right)
        QuickSort(a, left, p - 1)
        QuickSort(a, p + 1, right)
    return a

a = [35, 80, 21, 54, 11, 45, 92, 39]
print(QuickSort(a, 0, len(a) - 1))

六、归并排序（递归）

def merge(left,right):  
    result=[]  
    i,j=0,0  
    while i<len(left) and j<len(right):  
        if left[i]<=right[j]:  
            result.append(left[i])  
            i+=1  
        else:  
            result.append(right[j])  
            j+=1  
    result+=left[i:]  
    result+=right[j:]  
    return result  

def mergesort(seq):  
    if len(seq)<=1:  
        return seq  
    mid=int(len(seq)/2)  
    left=mergesort(seq[:mid])  
    right=mergesort(seq[mid:])  
    return merge(left,right)

if __name__=='__main__':  
    seq=[4,5,7,9,7,5,1,0,7,-2,3,-99,6]  
    print(mergesort(seq))

七、堆排序—— （选择排序的改进）

#coding: utf-8 
#!/usr/bin/python   
import random
import math

#随机生成0~100之间的数值
def get_andomNumber(num):  
    lists=[]  
    i=0  
    while i<num:  
        lists.append(random.randint(0,100))  
        i+=1
    return lists


# 调整堆
def adjust_heap(lists, i, size):
    lchild = 2 * i + 1
    rchild = 2 * i + 2
    max = i
    if i < size / 2:
        if lchild < size and lists[lchild] > lists[max]:
            max = lchild
        if rchild < size and lists[rchild] > lists[max]:
            max = rchild
        if max != i:
            lists[max], lists[i] = lists[i], lists[max]
            adjust_heap(lists, max, size)

# 创建堆
def build_heap(lists, size):
    for i in range(0, (int(size/2)))[::-1]:
        adjust_heap(lists, i, size)

# 堆排序
def heap_sort(lists):
    size = len(lists)
    build_heap(lists, size)
    for i in range(0, size)[::-1]:
        lists[0], lists[i] = lists[i], lists[0]
        adjust_heap(lists, 0, i)
    return lists


a = get_andomNumber(10)
print("排序之前：%s" %a)

b = heap_sort(a)

print("排序之后：%s" %b)

八、桶排序（bucket sort & bin sort）

# BucketSort - Using the Bucket Sort method for a chaotic sequence in ascending order.

def BucketSort(a):
    b = [0] * max(a)    #预先设定的列表，全部置零
    result = []
    for num in a:       #遍历成绩，相应得分位置+1
        b[num - 1] += 1      #a的值成为b的索引，此时标记b中不为空的位置
    for i in range(0, len(b)):   #遍历生成的列表
        for j in range(0, b[i]):
            result.append(i + 1)
    return result

print(BucketSort(a=[35, 80, 21, 54, 11, 45, 92, 39]))

PS：

排序算法稳定性：

        假定在待排序的记录序列中，存在多个具有相同的关键字的记录，若经过排序，这些记录的相对次序保持不变，即在原序列中，ri=rj，且ri在rj之前，而在排序后的序列中，ri仍在rj之前，则称这种排序算法是稳定的；否则称为不稳定的。

        稳定的排序算法：基数排序、冒泡排序、直接插入排序、折半插入排序、归并排序

        不稳定的排序算法：堆排序、快速排序、希尔排序、直接选择排序

 排序算法复杂度：

                                          

PS——二分查找（binary_search）

def binary_search(a, key):
    if not a:
        return 0
    time = 0
    low = 0
    high = len(a) - 1
    while low <= high:
        time += 1
        mid = int((low + high) / 2)
        if a[mid] == key:
            print("times: %s" % time)
            return mid
        elif a[mid] > key:
            high = mid - 1
        else:
            low = mid + 1
    return False

if __name__ == '__main__':
    LIST = [1, 5, 7, 8, 22, 54, 99, 123, 200, 222, 444]
    result = binary_search(LIST, 200)
    print(result)