python 版排序与搜索

最新推荐文章于 2024-07-16 21:28:15 发布

Deep In

最新推荐文章于 2024-07-16 21:28:15 发布

阅读量296

点赞数 1

分类专栏：数据结构文章标签：数据结构冒泡选择排序 python

本文链接：https://blog.csdn.net/W1517055683/article/details/85274224

版权

数据结构专栏收录该内容

3 篇文章 0 订阅

订阅专栏

冒泡排序

冒泡排序算法的原理如下：

比较相邻的元素。如果第一个比第二个大，就交换他们两个。
对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
针对所有的元素重复以上的步骤，除了最后一个。
持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码：

#coding: utf-8
def bubble_sort(alist):
    ''' 列表的长度'''
    n = len(alist)
    for j in range(n-1):
        '''j:是从 0 ~ n-2  第一个到倒数第二个'''
        for i in range(0,n-1-j):
            '''每次比较都减去上次比较的次数'''
            if alist[i] > alist[i+1]:
                '''前一个数比后一个数大，则交换位置'''
                alist[i], alist[i+1] = alist[i+1], alist[i]


if __name__=="__main__":
    ls = [12,45,13,65,11,78,56,125,123]
    print(ls)
    bubble_sort(ls)
    print(ls)

选择排序

**选择排序**

分类	排序算法
数据结构	数组
最坏时间复杂度	О(n²)
最优时间复杂度	О(n²)
平均时间复杂度	О(n²)
最坏空间复杂度	О(n) total, O(1) auxiliary

选择排序的示例动画。红色表示当前最小值，黄色表示已排序序列，蓝色表示当前位置。

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理如下。首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕。

选择排序的主要优点与数据移动有关。如果某个元素位于正确的最终位置上，则它不会被移动。选择排序每次交换一对元素，它们当中至少有一个将被移到其最终位置上，因此对{\displaystyle n} $n$ 个元素的表进行排序总共进行至多{\displaystyle n-1} $n-1$ 次交换。在所有的完全依靠交换去移动元素的排序方法中，选择排序属于非常好的一种。

代码

#coding: utf-8
def select_sort(alist):
    n = len(alist)
    """从0~n-2  到倒数第二个"""
    for i in range(n-1):
        min_index = i  # 最小数的下标赋值
        """从最小数的位置到末尾选出最小的数"""
        for j in range(i+1,n):
            """从后面的数中找到比最小数还小，则把位置赋值给 min_index"""
            if alist[j] < alist[min_index]:
                min_index = j
        if min_index != i:
            alist[i], alist[min_index] = alist[min_index], alist[i]

if __name__=="__main__":
    alist = [12,34,64,23,7,86,37,39]
    print(alist)
    select_sort(alist)
    print(alist)

插入排序

**插入排序**
使用插入排序为一列数字进行排序的过程
分类	排序算法
数据结构	数组
最坏时间复杂度	{\displaystyle O(n^{2})} $O(n^{2})$
最优时间复杂度	{\displaystyle O(n)} $O(n)$
平均时间复杂度	{\displaystyle O(n^{2})} $O(n^{2})$
最坏空间复杂度	总共{\displaystyle O(n)} $O(n)$ ，需要辅助空间{\displaystyle O(1)} $O(1)$

使用插入排序为一列数字进行排序的过程

插入排序（英语：Insertion Sort）是一种简单直观的排序算法。它的工作原理是通过构建有序序列，对于未排序数据，在已排序序列中从后向前扫描，找到相应位置并插入。插入排序在实现上，通常采用in-place排序（即只需用到{\displaystyle O(1)} $O(1)$ 的额外空间的排序），因而在从后向前扫描过程中，需要反复把已排序元素逐步向后挪位，为最新元素提供插入空间。

具体算法描述如下：

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

代码

#coding: utf-8
def insert_sort(alist):
    n = len(alist)
    #从右边的元素取多少个元素进行这个过程"""
    for j in range(1, n):
        # j = [1, 2, 3, 4,....n-1]
        # i 代表的是内层循环的起始值
        i=j
        while i > 0:   # 从右边的无序序列中取出第一个数，即 i 的位置， 然后将其插入到前面的位置中
            if alist[i] < alist[i - 1]:    # 后面的一个数比前一个数大   则交换位置
                alist[i], alist[i - 1] = alist[i - 1], alist[i]
                i -= 1
            else:
                break
if __name__=="__main__":
    alist = [12,34,64,23,7,86,37,39]
    print(alist)
    shell_sort(alist)
    print(alist)

希尔排序

**希尔排序**
以23, 10, 4, 1的步长序列进行希尔排序。
分类	排序算法
数据结构	数组
最坏时间复杂度	根据步长序列的不同而不同。已知最好的：{\displaystyle O(n\log ^{2}n)} $O(n\log^2 n)$
最优时间复杂度	O(n)
平均时间复杂度	根据步长序列的不同而不同。
最坏空间复杂度	O(n)

希尔排序算法彩条

希尔排序，也称递减增量排序算法，是插入排序的一种更高效的改进版本。希尔排序是非稳定排序算法。

希尔排序是基于插入排序的以下两点性质而提出改进方法的：

插入排序在对几乎已经排好序的数据操作时，效率高，即可以达到线性排序的效率
但插入排序一般来说是低效的，因为插入排序每次只能将数据移动一位

例如，假设有这样一组数[ 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为步长进行排序：

排序之后变为：

最后以1步长进行排序（此时就是简单的插入排序了）。

代码

#coding: utf-8
def shell_sort(alist):
    n = len(alist)
    gap = n //2
    # 步长 gap 折半
    #从右边的元素取多少个元素进行这个过程"""
    while gap > 0:  # 循环 gap ~ 1
        for j in range(gap, n):
            # j = [gap, gap+1, gap+2, .... n-1]
            # i 代表的是内层循环的起始值
            i=j

            while i > 0:   # 从右边的无序序列中取出第一个数，即 i 的位置， 然后将其插入到前面的位置中
                    if alist[i] < alist[i - gap]:    # 后面的一个数比前一个数大   则交换位置
                        alist[i], alist[i - gap] = alist[i - gap ], alist[i]
                        i -= gap
                    else:
                        break
        gap //= 2
if __name__=="__main__":
    alist = [12,34,64,23,7,86,37,39]
    print(alist)
    shell_sort(alist)
    print(alist)

快速排序

**快速排序**
使用快速排序法对一列数字进行排序的过程
分类	排序算法
数据结构	不定
最坏时间复杂度	{\displaystyle \Theta (n^{2})} $\Theta (n^{2})$
最优时间复杂度	{\displaystyle \Theta (n\log n)} $\Theta (n\log n)$
平均时间复杂度	{\displaystyle \Theta (n\log n)} $\Theta (n\log n)$
最坏空间复杂度	根据实现的方式不同而不同

快速排序（英语：Quicksort），又称划分交换排序（partition-exchange sort），简称快排，一种排序算法，最早由东尼·霍尔提出。在平均状况下，排序{\displaystyle n} $n$ 个项目要{\displaystyle \ O(n\log n)} $\ O(n\log n)$ （大O符号）次比较。在最坏状况下则需要{\displaystyle O(n^{2})} $O(n^{2})$ 次比较，但这种状况并不常见。事实上，快速排序{\displaystyle \Theta (n\log n)} $\Theta (n\log n)$ 通常明显比其他算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地达成。

步骤为：

从数列中挑出一个元素，称为“基准”（pivot），
重新排序数列，所有比基准值小的元素摆放在基准前面，所有比基准值大的元素摆在基准后面（相同的数可以到任何一边）。在这个分割结束之后，该基准就处于数列的中间位置。这个称为分割（partition）操作。
递归地（recursively）把小于基准值元素的子数列和大于基准值元素的子数列排序。

递归到最底部时，数列的大小是零或一，也就是已经排序好了。这个算法一定会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

Deep In

关注

1
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
python 版排序与搜索

冒泡排序冒泡排序算法的原理如下：比较相邻的元素。如果第一个比第二个大，就交换他们两个。对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。针对所有的元素重复以上的步骤，除了最后一个。持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。代码：#coding: utf-8def bubble_sort(a...
复制链接

扫一扫