排序算法-笔记

1、冒泡排序：

def bubbleSort(array):
        '''
        时间复杂度： 最好：O(n) 平均：O(n^2) 最坏： O(n^2)
        空间复杂度：
        稳定性：稳定
        '''
        n = len(array)
        for i in range(n):
            for j in range(n-i-1):
                if array[j]>array[j+1]:
                    array[j], array[j+1] = array[j+1], array[j]
        return array

2、快速排序

def quickSort(array):
        '''
        快速排序是冒泡排序的优化，快速排序从数组两侧进行排序
        时间复杂度：最好： O(nlogn) 最坏：O(n^2) 平均：O(nlogn)
        空间复杂度：
        稳定性：

        递归算法的时间复杂度公式：T[n] = aT[n/b] + f(n)  a为递归次数 ；
        注意：递归时基准数不要放到右侧进行递归，否则递归无法停止;基准数距不再进行递归，否则基准数据重复时可能会出错
        '''
        n = len(array)
        if n<=1:
            return array
        left_index = 0
        rigth_index = n-1
        base = array[0]
        while left_index<rigth_index:
            while array[rigth_index]>base and left_index!=rigth_index:
                rigth_index -= 1
            while array[left_index]<=base and left_index!=rigth_index:
                left_index += 1
            if left_index==rigth_index:
                array[0], array[left_index] = array[left_index], array[0]
                k = left_index
            array[left_index], array[rigth_index] = array[rigth_index], array[left_index]
        array[0:k] = quickSort(array[0:k])
        array[k+1::] = quickSort(array[k+1::])

        return array

3、选择排序

def selectionSort(array):
        '''
        时间复杂度： 最好：O(n^2) 平均：O(n^2) 最坏： O(n^2)
        空间复杂度：O(1)
        稳定性： 数组实现时不稳定，利用链表实现稳定
        '''
        n = len(array)
        for i in range(n):
            best_index = 0
            for j in range(n-i):
                if array[best_index]<array[j]:
                    best_index = j
            array[best_index], array[n-i-1] = array[n-i-1], array[best_index]
        return array

4、插入排序

def insertionSort(array):
        '''
        直接插入排序原理：将数据插入有序数组中，直至所有数据排序完成
        时间复杂度：最好： O(n) 最坏：O(n^2) 平均：O(n^2)
        空间复杂度：O(1)
        稳定性：稳定
        适用场景：
        '''
        n = len(array)
        sorted_num = 1
        for i in range(sorted_num,n):
            tmp = array[i]
            while array[i-1]>tmp and i>=1:
                array[i] = array[i-1]
                i = i-1
            array[i] = tmp
        return array

5、归并排序

    def mergeSort(array):
        '''
        时间复杂度：最好：O(nlogn) 最坏：O(nlogn) 平均O(nlogn)
        空间复杂度：O(n)
        稳定性：稳定
        '''
        n = len(array)
        if n<2:
            return array
        else:
            left = mergeSort(array[0:n//2])
            right = mergeSort(array[n//2::])
            i = j = 0
            tmp = []
            while i<n//2 and j<(n-n//2):
                if left[i]<=right[j]:
                    tmp.append(left[i])
                    i+=1
                else:
                    tmp.append(right[j])
                    j+=1
            while i<n//2:
                tmp.append(left[i])
                i+=1
            while j<(n-n//2):
                tmp.append(right[j])
                j+=1

        return tmp

6、桶排序

def bucketSort(array):
        '''
        桶排序原理： 略
        时间复杂度： 遍历数组和桶（m个桶）O(n+m)
        空间复杂度： O(m)
        适用条件： 数据范围跨度不大，桶排序非常快，是一种非比较型排序算法，但是对空间的消耗非常大
        '''
        bucket_nums = max(array)
        buckets = [0 for i in range(bucket_nums)]
        for x in array:
            buckets[x] += 1
        tmp = []
        for index,nums in enumerate(buckets):
            while nums!=0:
                tmp.append(index)
                nums -= 1
        return tmp

7、基数排序

def radixSort(array):
        '''
        基数排序：
        时间复杂度：
        空间复杂度：
        稳定性：
        适用条件
        '''
        n = len(array)
        maxnum = max(array)
        bits = 0
        k = 1
        while maxnum%10 != 0:
            bits = bits+1
            maxnum = maxnum//10
        while k<=bits:
            #print('k:',k)
            buckets = [[] for i in range(10)]
            for num in array:
                buckets[int(num/(10**(k-1))%10)].append(num)
            i = 0
            #print('buckets:{}'.format(buckets))
            for bucket in buckets:
                for x in bucket:
                    array[i] = x
                    i+=1
            #print('array:{}'.format(array))
            k+=1
        return array