几种排序算法的python实现

几种排序算法的python实现

def selection_sort(arr):
    '''
    选择排序算法，找到数组中最小的元素。和数组第一个元素交换位置
    再去剩下元素继续比较
    时间效率取决于比较次数
    运行时间与输入无关，数据移动最少
    :param arr:
    :return:
    '''
    arr = list(arr)
    N = len(arr)
    for i in range(N):
        min_number = i
        for j in range(i + 1, N):  # 找到数组中最小的那个元素
            if arr[min_number] > arr[j]:
                min_number = j
        arr[min_number], arr[i] = arr[i], arr[min_number]  # 交换位置
    return arr


def insertSort(arr):
    '''
    插入排序，将牌插入有序牌中适当位置，其余元素右移
    插入排序对部分有序数据十分高效
    :param arr:
    :return:
    '''
    arr = list(arr)
    N = len(arr)
    for i in range(1, N):
        for j in range(i, 0, -1):  # 比较大小，交换相邻元素
            if arr[j] < arr[j - 1]:
                arr[j], arr[j - 1] = arr[j - 1], arr[j]
    return arr


def shellSort(arr):
    '''
    希尔排序，基于插入排序的改进，
    排序之初，各个子数组都很短，排序后，各部分都有序，都适合插入排序
    运行时间最坏不超过平方级别
    :param arr:
    :return:
    '''
    arr = list(arr)
    N = len(arr)
    # 指定初始分组长度
    h = N // 3
    while h >= 1:
        # 按步长进行插入排序
        for i in range(h, N):
            j = i
            # 原地插入排序，之前的插入排序另辟空间存储的
            while j >= h and arr[j] < arr[j - h]:
                arr[j], arr[j - h] = arr[j - h], arr[j]
                j -= h
        # 得到新的步长
        h = h // 3
    return arr


class Merge():
    '''
    归并排序:递归地分成两半排序，然后将结果归并起来
    时间为NlogN，主要缺点是辅助数组需要额外空间N
    '''

    def mergesort(self, arr):
        arr = list(arr)
        return self.sorted(arr)

    def sorted(self, arr):
        if len(arr) <= 1:
            return arr
        mid = len(arr) // 2
        left = self.sorted(arr[mid:])  # 左边排序
        right = self.sorted(arr[:mid])  # 右边排序
        return self.merge(left, right)  # 归并操作

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


class Quick():
    '''
    快速排序：当两个子数组都有序则整个数组也就有序了
    比其他排序算法快很多，可以原地排序，
    长度为N的数组所需时间为NlgN
    内循环短小，意味着实际更快
    主要缺点是非常脆弱，错误的编写导致性能只有平方级别
    切分不平衡会使它极为低效，所以需要随机值
    '''

    def quicksort(self, arr):
        arr = list(arr)
        return self.sorted(arr, 0, len(arr) - 1)

    def sorted(self, arr, low, hight):
        if hight > low:
            j = self.partition(arr, low, hight)
            self.sorted(arr, low, j - 1)
            self.sorted(arr, j + 1, hight)
        return arr

    def partition(self, arr, low, hight):
        v = arr[low]
        while low < hight:
            while low < hight and arr[hight] >= v:
                hight -= 1
            arr[low] = arr[hight]
            while low < hight and arr[low] <= v:
                low += 1
            arr[hight] = arr[low]
        arr[low] = v
        return low