Algorithm-sort

2019年12月26日 16:35 阅读 864 评论 0

排序算法:插入排序、冒泡排序、归并排序、快速排序等。

Sorting algorithms: insert sort, bubble sort, merge sort, quick sort, etc.

排序算法 Sorting Algorithms

各个排序算法图解https://blog.csdn.net/qq_37941471/article/details/80522354

冒泡排序 Bubble Sort O(n^2) O(1)

冒泡排序(英语:Bubble Sort)是一种简单的排序算法。它重复地遍历要排序的数列,一次比较两个元素,

如果他们的顺序错误就把他们交换过来。遍历数列的工作是重复地进行直到没有再需要交换,也就是说该数

列已经排序完成。

  • 比较相邻的元素。如果第一个比第二个大(升序),就交换他们两个。

  • 对每一对相邻元素作同样的工作,从开始第一对到结尾的最后一对。这步做完后,最后的元素会是最大的数。

  • 针对所有的元素重复以上的步骤,除了最后一个。

  • 持续每次对越来越少的元素重复上面的步骤,直到没有任何一对数字需要比较。

def bubble_sort(nums):

    for j in range(len(nums) - 1, 0, -1):  # j的取值是[len(alist)-1,len(alist)-2,.....,1]

        # j 表示每次遍历需要比较的次数,是逐渐减小的

        for i in range(j):

            if nums[i] > nums[i + 1]:

                nums[i], nums[i + 1] = nums[i + 1], nums[i]





if __name__ == '__main__':

    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    bubble_sort(nums)

    print(nums)

插入排序 Insertion Sort O(n^2) O(1)

插入排序(英语:Insertion Sort)是一种简单直观的排序算法。

  • 通过构建有序序列,对于未排序数据,在已排序序列中从后向前扫描,找到相应位置并插入。

  • 插入排序在实现上,在从后向前扫描过程中,需要反复把已排序元素逐步向后挪位,为最新元素提供插入空间。

def insert_sort(nums):

    for i in range(1, len(nums)):

        for j in range(i, 0, -1):

            if nums[j] < nums[j - 1]:

                nums[j], nums[j - 1] = nums[j - 1], nums[j]





if __name__ == '__main__':

    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    insert_sort(alist)

    print(alist)

选择排序 Selection sort O(n^2) O(1)

选择排序(Selection sort)是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小(大)元素,

存放到排序序列的起始位置,然后,再从剩余未排序元素中继续寻找最小(大)元素,然后放到已排序序列的末尾。

以此类推,直到所有元素均排序完毕。

  • 选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上,则它不会被移动。

  • 选择排序每次交换一对元素,

  • 它们当中至少有一个将被移到其最终位置上,因此对n个元素的表进行排序总共进行至多n-1次交换。

  • 在所有的完全依靠交换去移动元素的排序方法中,选择排序属于非常好的一种。

def selection_sort1(nums):

    # 思路是将最小值逐一选择到前面

    n = len(nums)

    for i in range(n - 1):

        min_index = i  # 记录最小值的位置

        for j in range(i + 1, n):

            if nums[j] < nums[min_index]:

                min_index = j

        if min_index != i:

            nums[i], nums[min_index] = nums[min_index], nums[i]





def selection_sort2(nums):

    # 思路是将最大值逐一选择到后面

    n = len(nums)

    for i in range(n - 1, 0, -1):

        max_index = i  # 记录最大值的位置

        for j in range(i):

            if nums[j] > nums[max_index]:

                max_index = j



        if max_index != i:

            nums[i], nums[max_index] = nums[max_index], nums[i]





if __name__ == '__main__':

    nums = list(range(31,0,-1))

    selection_sort2(nums)

    print(nums)

快速排序 Quick Sort O(nlogn) O(logn)

通过一趟排序将要排序的数据分割成独立的两部分,其中一部分的所有数据都比另外一部分的所有数据都要小,

然后再按此方法对这两部分数据分别进行快速排序,整个排序过程可以递归进行,以此达到整个数据变成有序序列。

递归实现

def quick_sort(nums, start, end):

    if start >= end:

        return

    pivot = nums[start]  # 基准值

    low = start  # 左指针

    high = end  # 右指针

    while low < high:

        while low < high and nums[high] >= pivot:

            high -= 1

        nums[low] = nums[high]



        while low < high and nums[low] < pivot:

            low += 1

        nums[high] = nums[low]

    nums[low] = pivot

    quick_sort(nums, start, low - 1)

    quick_sort(nums, low + 1, end)





if __name__ == '__main__':

    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    quick_sort(nums, 0, len(nums) - 1)

    print(nums)

归并排序 Merge sort O(nlogn) O(logn)

将数组array[0,...,n-1]中的元素分成两个子数组:array1[0,...,n/2]

和array2[n/2+1,...,n-1]。分别对这两个数组单独排序,然后将已排序的

两个子数组归并成一个含有n个元素的有序数组

  • 递归实现

  • 在数组长度比较短的情况下,不进行递归,而是选择其他排序方案,如插入排序

  • 归并过程中,可以用记录数组下标的方式代替申请新内存空间;从而避免array和辅助数组间的频繁数据移动

def merge(left, right):  # 合并两个有序数组

    l, r = 0, 0

    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





def merge_sort(nums):

    if len(nums) <= 1:

        return nums

    num = len(nums) >> 1

    left = merge_sort(nums[:num])

    right = merge_sort(nums[num:])

    return merge(left, right)





# ------------------- 按第二个改进的修改----------------------------



temp = [0] * 100





def Merge(nums, low, mid, high):

    i = low

    j = mid + 1

    size = 0

    while i <= mid and j <= high:

        if nums[i] < nums[j]:

            temp[size] = nums[i]

            i += 1

        else:

            temp[size] = nums[j]

            j += 1

        size += 1

    while i <= mid:

        temp[size] = nums[i]

        size += 1

        i += 1

    while j <= high:

        temp[size] = nums[j]

        size += 1

        j += 1

    for i in range(size):

        nums[low + i] = temp[i]





def Merge_sort(nums, low, high):

    if low >= high:

        return

    mid = (low + high) >> 1

    Merge_sort(nums, low, mid)

    Merge_sort(nums, mid + 1, high)

    Merge(nums, low, mid, high)





if __name__ == '__main__':

    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    Merge_sort(nums, 0, len(nums) - 1)

    print(nums)

堆排序 heap sort O(nlogn) O(logn)

堆排序是一种树形选择排序,是对直接选择排序的有效改进。

  • 初始时把要排序的数的序列看作是一棵顺序存储的二叉树,调整它们的存储序,使之成为一个 堆,

  • 这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。

  • 依此类推,直到只有两个节点的堆,并对 它们作交换,最后得到有n个节点的有序序列。从算法描述来看,

  • 堆排序需要两个过程,一是建立堆,二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。

  • 一是建堆的渗透函数,二是反复调用渗透函数实现排序的函数。

​堆的定义下:具有n个元素的序列 (h1,h2,...,hn),当且仅当满足(hi>=h2i,hi>=2i+1)或(hi<=h2i,hi<=2i+1) (i=1,2,...,n/2)时称之为堆。

在这里只讨论满足前者条件的堆。由堆的定义可以看出,堆顶元素(即第一个元素)必为最大项(大顶堆)。

完全二叉树可以很直观地表示堆的结构。堆顶为根,其它为左子树、右子树。

#  调整堆,把最大值调整到堆顶

def adjust_heap(nums, i, size):

    lchild = 2 * i + 1

    rchild = 2 * i + 2

    max = i

    if i < size / 2:

        if lchild < size and nums[lchild] > nums[max]:

            max = lchild

        if rchild < size and nums[rchild] > nums[max]:

            max = rchild

        if max != i:

            nums[max], nums[i] = nums[i], nums[max]

            adjust_heap(nums, max, size)





# 创建堆

def build_heap(lists, size):

    for i in range(0, (size >> 1))[::-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





if __name__ == '__main__':

    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    result = heap_sort(nums)

    print(result)

希尔排序 Shell Sort O(n^(1.3))) O(1)

希尔排序(Shell Sort)也是插入排序的一种。也称为缩小增量排序,是直接插入排序算法的一种更高效的改进版本。

希尔排序是非稳定排序算法。该方法因DL.Shell于1959年提出而得名。
  • 将待排序列划分为若干组,在每一组内进行插入排序,以使整个序列基本有序,然后再对整个序列进行插入排。
def shell_sort(nums):

    size = len(nums)

    gap = size >> 1

    while gap > 0:

        for i in range(gap, size):

            j = i

            while j >= gap and nums[j - gap] > nums[j]:

                nums[j - gap], nums[j] = nums[j], nums[j - gap]

                j -= gap

        gap = gap >> 1





if __name__ == '__main__':

    nums = [54, 26, 93, 17, 77, 31, 44, 55, 20]

    shell_sort(nums)

    print(nums)

基数排序 radix sort O(n+k)

基数排序是一种非比较型整数排序算法,其原理是将整数按位数切割成不同的数字,然后按每个位数分别比较。由于整数也可以表达字符串(比如名字或日期)和特定格式的浮点数,所以基数排序也不是只能使用于整数。

  • 该算法所花的时间基本是在把元素分配到桶里和把元素从桶里串起来;把元素分配到桶里:循环 length 次;

- 把元素从桶里串起来:这个计算有点麻烦,看似两个循环,其实第二循环是根据桶里面的元素而定的,可以表示为:k×buckerCount;其中 k 表示某个桶中的元素个数,buckerCount  则表示存放元素的桶个数;

- 有几种特殊情况:

- 第一、所有的元素都存放在一个桶内:k = lengthbuckerCount = 1

- 第二、所有的元素平均分配到每个桶中:k = length/ bukerCountbuckerCount = 10;(这里已经固定了10个桶)

- 所以平均情况下收集部分所花的时间为:length (也就是元素长度 n)

- 综上所述:时间复杂度为:posCount * (length  + length) ;其中 posCount 为数组中最大元素的最高位数;简化下得:O( k*n ) ;其中k为常数,n为元素个数;

基数排序 vs 计数排序 vs 桶排序

  1. 这三种排序算法都利用了桶的概念,但对桶的使用方法上有明显差异:

  2. 基数排序:根据键值的每位数字来分配桶;

  3. 计数排序:每个桶只存储单一键值;

  4. 桶排序:每个桶存储一定范围的数值;

https://www.runoob.com/

def radix_sort(s):

    """基数排序"""

    i = 0 # 记录当前正在排拿一位,最低位为1

    max_num = max(s)  # 最大值

    j = len(str(max_num))  # 记录最大值的位数

    while i < j:

        bucket_list =[[] for _ in range(10)] #初始化桶数组

        for x in s:

            bucket_list[int(x / (10**i)) % 10].append(x) # 找到位置放入桶数组

        print(bucket_list)

        s.clear()

        for x in bucket_list:   # 放回原序列

            for y in x:

                s.append(y)

        i += 1



if __name__ == '__main__':

    a = [54, 26, 93, 17, 77, 31, 44, 55, 20, 2, 4]

    radix_sort(a)

    print(a)

计数排序 count Sort O(n+k)

计数排序的核心在于将输入的数据值转化为键存储在额外开辟的数组空间中。作为一种线性时间复杂度的排序,计数排序要求输入的数据必须是有确定范围的整数。

def countSort(arr):

    output = [0 for i in range(256)]

    count = [0 for i in range(256)]

    ans = ["" for _ in arr]

    for i in arr:

            count[ord(i)] += 1

    for i in range(256):

            count[i] += count[i-1]

    for i in range(len(arr)):

            output[count[ord(arr[i])]-1] = arr[i]

            count[ord(arr[i])] -= 1

    for i in range(len(arr)):

            ans[i] = output[i]

    return ans



arr = "asdfghjklpoiuytrewq"

ans = countSort(arr

print ( "字符数组排序 %s"  %("".join(ans)) )

桶排序 bucketSort O(m),其中 m 为桶的个数

桶排序是计数排序的升级版。它利用了函数的映射关系,高效与否的关键就在于这个映射函数的确定。为了使桶排序更加高效,我们需要做到这两点:

在额外空间充足的情况下,尽量增大桶的数量

使用的映射函数能够将输入的 N 个数据均匀的分配到 K 个桶中

同时,对于桶中元素的排序,选择何种比较排序算法对于性能的影响至关重要。

  1. 什么时候最快

当输入的数据可以均匀的分配到每一个桶中。

  1. 什么时候最慢

当输入的数据被分配到了同一个桶中。

def bucketSort(nums):

    # 选择一个最大的数

    max_num = max(nums)

    # 创建一个元素全是0的列表, 当做桶

    bucket = [0]*(max_num+1)

    # 把所有元素放入桶中, 即把对应元素个数加一

    for i in nums:

        bucket[i] += 1



    # 存储排序好的元素

    sort_nums = []

    # 取出桶中的元素

    for j in range(len(bucket)):

        if bucket[j] != 0:

            for y in range(bucket[j]):

                sort_nums.append(j)



    return sort_nums



nums = [5,6,3,2,1,65,2,0,8,0]

print bucketSort(nums)

原创文章,转载请注明出处:https://boywithacoin.cn/article/algorithm-sort/


您尚未登录,请 登录注册 后评论
    0 人参与 | 0 条评论
    暂时没有评论,欢迎来尬聊!