Python实现经典七种排序算法

#2018-06-02  June Saturday the 22 week, the 153 day SZ
#数组排序算法大全用Python3实现
#参考https://www.cnblogs.com/zhizhan/p/4549099.html
'''
算法1：冒泡法：让两数比较大的值一直滚动到最右侧，类似泡泡一直往上飘每次滚动都要进行比较
思路：
步骤：
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对第0个到第n-1个数据做同样的工作。这时，最小的数就“浮”到了数组最左边位置上
3.针对所有的元素重复以上的步骤，除了单一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
'''

class Solution(object):
    def selectSort(self,array):
        n = len(array)
        for i in range(n): #一次for循环，直接从i+1计算，就不算i前面已经排好序的数值
            for j in range(1, n-i): #一次for循环确定一次最小值
                if array[j-1] > array[j]: #和选择排序法的核心区别 
                    array[j-1],array[j] = array[j], array[j-1]
        return array 

my_solution = Solution()
a = [9,3,8,5]
b = my_solution.selectSort(a)
print("sequence is:", b)


'''
算法2：
选择排序：保持最小元素在最左侧，用最左侧的元素依次和右边的元素比较，谁小谁放在左边。
步骤：
1.在未排序序列中找到最小元素，存放到排序序列的起始位置。
2.再从剩余未排序元素中继续寻找最小元素，然后放到已排序序列的末尾。
3.以此类推，直到所有元素均排序完毕。
'''
class Solution(object):
    def selectSort(self,a):
        for i in range(len(a)): #一次for循环，直接从i+1计算，就不算i前面已经排好序的数值
            for j in range(i + 1, len(a)): #一次for循环确定一个最小值.通过让i对应的值和i之后的每个值进行比较，让a[i]处于最小值
                if a[i] > a[j]: #保持a[i]最小 
                    a[i],a[j] = a[j], a[i]
        return a 

my_solution = Solution()
a = [9,3,8,5]
b = my_solution.selectSort(a)
print("sequence is:", b)



'''
三、插入排序 InsertionSort,有些复杂，没有理解，问题

介绍：

插入排序的工作原理是，对于每个未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。

步骤：
1.从第一个元素开始，该元素可以认为已经被排序
2.取出下一个元素，在已经排序的元素序列中从后向前扫描
3.如果被扫描的元素（已排序）大于新元素，将该元素后移一位
4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置
5.将新元素插入到该位置后
6.重复步骤2~5
'''

class Solution(object):
    def insertSort(self,array):
        length = len(array)
        for i in range(1, length):
            if array[i-1] > array[i]:
                temp = array[i] 
                index = i 
            for j in range(i -1,-1,-1):
                if array[j] > temp:
                    array[j+1] = array[j]
                    index = j
                else:
                    break
            array[index] = temp #temp时刻保持最小值，index是最小值的索引

        return array
my_solution = Solution()
array = [9,3,8,5]
sorted_array = my_solution.insertSort(array)
print(sorted_array)


'''
四、希尔排序 ShellSort 复杂，不好实现。问题,思路理解，程序无法理解。

介绍：

希尔排序，也称递减增量排序算法，实质是分组插入排序。由 Donald Shell 于1959年提出。希尔排序是非稳定排序算法。源码的步长的选择是从n/2开始，每次再减半，直至为0。

希尔排序的基本思想是：将数组列在一个表中并对列分别进行插入排序，重复这过程，不过每次用更长的列（步长更长了，列数更少了）来进行。最后整个表就只有一列了。将数组转换至表是为了更好地理解这算法，算法本身还是使用数组进行排序。

例如，假设有这样一组数[ 13 14 94 33 82 25 59 94 65 23 45 27 73 25 39 10 ]，
如果我们以步长为5开始进行排序，我们可以通过将这列表放在有5列的表中来更好地描述算法，这样他们就应该看起来是这样：
13 14 94 33 82
25 59 94 65 23
45 27 73 25 39
10


然后我们对每列进行排序：
10 14 73 25 23
13 27 94 33 39
25 59 94 65 82
45


将上述四行数字，依序接在一起时我们得到：[ 10 14 73 25 23 13 27 94 33 39 25 59 94 65 82 45 ]。这时10已经移至正确位置了，然后再以3为步长进行排序：
10 14 73
25 23 13
27 94 33
39 25 59
94 65 82
45


排序之后变为：
10 14 13
25 23 33
27 25 59
39 65 73
45 94 82
94


最后以1步长进行排序（此时就是简单的插入排序了）。
'''
class Solution(object):
    def shellSort(self,array):
        len_array = len(array)
        step = round(len_array/2)       #初始步长为数组的一半，round函数用来四舍五入的
        while step > 0:            
            for i in range(step, len_array):
                temp = array[i]
                j= i 
                while(j >= step and array[j - step] > temp):
                    array[j] = array[j-step]
                    j = j - step 
                array[j] = temp
            step = round(step/2) #重新设置步长
        return array


my_solution = Solution()
a = [9,3,8,5]
b = my_solution.shellSort(a)
print("sequence is:", b)



'''
五、归并排序 MergeSort 问题

介绍：

归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。

先考虑合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。

再考虑递归分解，基本思路是将数组分解成left和right，如果这两个数组内部数据是有序的，那么就可以用上面合并数组的方法将这两个数组合并排序。如何让这两个数组内部是有序的？可以再二分，直至分解出的小组只含有一个元素时为止，此时认为该小组内部已有序。然后合并排序相邻二个小组即可。
'''

def merge_sort(ary):
    if len(ary) <= 1 : return ary
    num = int(len(ary)/2)       #二分分解
    left = merge_sort(ary[:num])
    right = merge_sort(ary[num:])
    return merge(left,right)    #合并数组

def merge(left,right):
    '''合并操作，
    将两个有序数组left[]和right[]合并成一个大的有序数组'''
    l,r = 0,0           #left与right数组的下标指针
    result = []
    while l<len(left) and r<len(right) :
        if left[l] < right[r]:
            result.append(left[l])
            l += 1
        else:
            result.append(right[r])
            r += 1
    result += left[l:]
    result += right[r:]
    return result
a = [9,3,8,5]
b = merge_sort(a)
print("sequence is:", b)


'''
六、快速排序 QuickSort

介绍：
快速排序通常明显比同为Ο(n log n)的其他算法更快，因此常被采用，而且快排采用了分治法的思想，所以在很多笔试面试中能经常看到快排的影子。可见掌握快排的重要性。

步骤：
1.从数列中挑出一个元素作为基准数。
2.分区过程，将比基准数大的放到右边，小于或等于它的数都放到左边。
3.再对左右区间递归执行第二步，直至各区间只有一个数。
'''

def quick_sort(ary):
    return qsort(ary,0,len(ary)-1)

def qsort(ary,left,right):
    #快排函数，ary为待排序数组，left为待排序的左边界，right为右边界
    if left >= right : return ary
    key = ary[left]     #取最左边的为基准数
    lp = left           #左指针
    rp = right          #右指针
    while lp < rp :
        while ary[rp] >= key and lp < rp :
            rp -= 1
        while ary[lp] <= key and lp < rp :
            lp += 1
        ary[lp],ary[rp] = ary[rp],ary[lp]
    ary[left],ary[lp] = ary[lp],ary[left]
    qsort(ary,left,lp-1)
    qsort(ary,rp+1,right)
    return ary

a = [9,3,8,5]
b = quick_sort(a)
print("sequence is:", b)


'''
七、堆排序 HeapSort

介绍：

堆排序在 top K 问题中使用比较频繁。堆排序是采用二叉堆的数据结构来实现的，虽然实质上还是一维数组。二叉堆是一个近似完全二叉树 。

二叉堆具有以下性质：
1.父节点的键值总是大于或等于（小于或等于）任何一个子节点的键值。
2.每个节点的左右子树都是一个二叉堆（都是最大堆或最小堆）。

步骤：

1.构造最大堆（Build_Max_Heap）：若数组下标范围为0~n，考虑到单独一个元素是大根堆，则从下标n/2开始的元素均为大根堆。于是只要从n/2-1开始，向前依次构造大根堆，这样就能保证，构造到某个节点时，它的左右子树都已经是大根堆。


2.堆排序（HeapSort）：由于堆是用数组模拟的。得到一个大根堆后，数组内部并不是有序的。因此需要将堆化数组有序化。思想是移除根节点，并做最大堆调整的递归运算。第一次将heap[0]与heap[n-1]交换，再对heap[0...n-2]做最大堆调整。第二次将heap[0]与heap[n-2]交换，再对heap[0...n-3]做最大堆调整。重复该操作直至heap[0]和heap[1]交换。由于每次都是将最大的数并入到后面的有序区间，故操作完后整个数组就是有序的了。


3.最大堆调整（Max_Heapify）：该方法是提供给上述两个过程调用的。目的是将堆的末端子节点作调整，使得子节点永远小于父节点 。


'''
def heap_sort(ary) :
    n = len(ary)
    first = int(n/2-1)       #最后一个非叶子节点
    for start in range(first,-1,-1) :     #构造大根堆
        max_heapify(ary,start,n-1)
    for end in range(n-1,0,-1):           #堆排，将大根堆转换成有序数组
        ary[end],ary[0] = ary[0],ary[end]
        max_heapify(ary,0,end-1)
    return ary


#最大堆调整：将堆的末端子节点作调整，使得子节点永远小于父节点
#start为当前需要调整最大堆的位置，end为调整边界
def max_heapify(ary,start,end):
    root = start
    while True :
        child = root*2 +1               #调整节点的子节点
        if child > end : break
        if child+1 <= end and ary[child] < ary[child+1] :
            child = child+1             #取较大的子节点
        if ary[root] < ary[child] :     #较大的子节点成为父节点
            ary[root],ary[child] = ary[child],ary[root]     #交换
            root = child
        else :
            break



a = [9,3,8,5]
b = heap_sort(a)
print("sequence is:", b)