[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)

目录 

 

1.冒泡排序

原理

 代码(python&cpp)

拓展:timeit()用法

2.选择排序

原理

3.插入排序

原理

代码(python&cpp)

4.归并排序

原理

代码

 5.快速排序

原理

代码(python&cpp)

6.计数排序

原理

 代码(python&cpp)

总结

参考


1.冒泡排序

冒泡排序(Bubble Sort)是一种很原始的排序方法,就是通过不断地交换“大数”的位置达到排序的目的。因为不断出现“大数”类似于水泡不断出现,因此被形象地称为冒泡算法。

原理

冒泡算法的基本原理就是比较相邻两个数字的大小。将两数中比较大的那个数交换到靠后的位置。不断地交换下去就可以将最大的那个数放到队列的尾部。然后重头再次交换,直到将数列排成有序数列。

一个 n 个数的数列需要排序 n -1轮。这样可以确保得到一个有序的数列。因此冒泡排序的时间复杂度是 o(n^{2})

 代码(python&cpp)

#!/user/bin/env/python3
#-*-conding:utf-8 -*-
# data:202112112
# author:yang

import random
from randomList import randomList
import sort

def bubbleSort(iList):
    iLen = len(iList)
    for i in range(iLen):
        for j in range(0,iLen-i-1):
            if iList[j] > iList[j+1]:
                iList[j],iList[j+1] = iList[j+1],iList[j]

    return iList

if __name__ == "__main__":
   iList = randomList(10)
   print("iList1:",iList)
   bubbleSort(iList)
   print("iList2:",iList)
    
void bubbleSort() {

	int iList[] = { 5,4,7,8,2,9,10,4,0,3};
	int len = sizeof(iList) / sizeof(int);
	for (int i = 0; i < len; i++)
	{
		for (int j = 0; j < len - i - 1; j++) {
			if (iList[j] > iList[j+1]) {

				int temp = iList[j+1];
				iList[j+1] = iList[j];
				iList[j] = temp;
			}
		}
	}

	for (int i = 0; i < len; i++) {
		cout << iList[i] << " ";
	}
	cout << endl;
}

拓展:timeit()用法

python中的timeit()方法, 它用于获取代码的执行时间。该库将代码语句默认运行一百万次,并提供从集合中花费的最短时间,可以用来检查代码的性能。

语法:

timeit.timeit(stmt, setup,timer, number)

参数:

stmt:这将采用您要测量其执行时间的代码。默认值为“pass”。

setup:这将包含需要在stmt之前执行的设置详细信息。这个参数可以将stmt的环境传进去。比如各种import和参数什么的。默认值为“ pass”。

timer:它将具有计时器值,timeit()已经设置了默认值,我们可以忽略它。

number:stmt将按照此处给出的编号执行。默认值为1000000。

注:

要使用timeit(),我们需要导入模块,如下:

import timeit

另外需要补充一点是,如果你想直接 stmt 那里执行函数。可以把函数申明在当前文件中,然后在 stmt = ‘func()’ 执行函数。然后使用 setup = ‘from __main__ import func’ 即可,如果要import 多个需要使用 setup = from __main__ import func; import simplejson'

2.选择排序

原理

简单地说,选择排序只做了一件事,就是从数列中选择最大(最小)的那个数,将这个数放到合适的位置。然后在抛开这个数的子数列中找最大(最小)的那个数放到合适的位置。然后……一直到子数列为空为止。与冒泡排序稍有不同的是,它不是相邻的两个数比较,而是某个数和数列中其他所有的数比较。

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第1张图片

第一轮排序:以数列中第1个数为基数,遍历数列中其他的数字,找到最小的那个数,然后交换这两个数的位置。 本轮排序的结果将数列中最小的那个数放到了数列的第一位。

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第2张图片

 第二轮排序:然后以数列中的第2个数为基数,遍历数列中剩余的其他数字,找到最小的那个数,交换这两个数的位置。第二个数字3已经是剩余数列中最小的数了。因此本轮无须交换数字,

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第3张图片

 第N轮排序:按照这个规律,不断地找剩余数列中最小的数字,交换位置,直到将原始数列排成有序数列。

选择排序数列完毕。共6个数,排序了5轮。理论上来说,选择排序的时间复杂度是 O ( n^2 )。但在Python中稍微有点特殊,因为Python 列 表 中 寻 找 最 小 的 那 个 数 不 需 要 逐 个 比 较 , 使 用min(iList[i:])就可以得到最小的那个数,所以使用Pythonic风格版本的选择排序,时间复杂度是 O ( n )。因此,理论上在Python版本的排序算法中选择排序算法是最快的。

 代码(python&cpp)

#!/user/bin/env/python3
#-*-conding:utf-8 -*-
# data:20211210
# author:yang

from randomList import randomList
import timeit

def selectionSort(iList):
    if len(iList) <= 1:
        return iList
    for i in range(0,len(iList)-1):
        if iList[i] != min(iList[i:]):
            minIndex = iList.index(min(iList[i:]))  # 最小数的下标
            iList[i],iList[minIndex] = iList[minIndex],iList[i]
        print("第%d轮排序结果:"%(i+1),end=" ")
        print("ilist:",iList)
    return iList

if __name__ == "__main__":
    iList = randomList(10)
    print(iList)
    print(selectionSort(iList))
    # print(timeit.timeit("selectionSort(iList)","from __main__ import selectionSort,iList",number = 1)) 

cpp待补充 

3.插入排序

插入排序(Insertion Sort)方法与打扑克取牌的排序很相似。在打扑克时,每取一张新牌,都会与手上已有的牌进行比较,将新牌插入到比自己小的牌后面。在取完所有的牌后,手上已有的牌就是个有序的序列。

原理

插入排序首先将数列分成两部分。数列的第一个数为left部分,其他的数为right部分。然后将right部分中的数逐一取出,插入left部分中合适的位置。当right部分为空时,left部分就成为了一个有序
数列。

举例:

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第4张图片

 第一轮:

首先要做的是将数列分成左、右两部分,left部分是第一个数字,right部分是数列剩余的部分。首先在牌堆中取出第一张牌,牌面是7,

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第5张图片

 第二轮排序

然后从牌堆中取出第二张牌,牌面是3。将牌面是3的牌放入手中合适的位置。将right部分的第一个数字3插入left部分合适的位置。3比7要小,插入到7的前面。

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第6张图片

第N轮排序 

循环将right部分的数字插入left部分,插入排序的时间复杂度是 O ( n ^2 )。

代码(python&cpp)

#!/user/bin/env/python3
#-*-conding:utf-8 -*-
# data:20211210
# author:yang

from randomList import randomList
import timeit

def insertSort(iList):
    if len(iList) <= 1:
        return iList
    for right in range(1,len(iList)):
        target = iList[right]
        for left in range(0,right):
            if target <= iList[left]:
                # 使用python切片赋值 
                iList[left+1:right+1] = iList[left:right] 
                iList[left] = target
                break
    return iList  

if __name__ == "__main__":
    iList = randomList(10)
    print(iList)
    print(insertSort(iList))
    # print(timeit.timeit("selectionSort(iList)","from __main__ import selectionSort,iList",number = 1))
    
        

cpp待补充 

4.归并排序

归并排序(Merge Sort)是一种典型的递归法排序。它把复杂的排序过程分解成一个简单的合并子序列的过程。至于怎么得到这个子序列,就得自己调用自己了。

原理

归并排序首先要做的就是将数列分成左右两部分(最好是等分),然后将左、右两个子数列排序完毕后再合并到一起就成了一个有序数列。左、右两个子数列怎么变成有序数列呢?那就回头调用自
己,再把子数列分成左、右两部分,直到将所有的子数列的长度分为1为止。然后把子子数列排序完毕后合并成子数列……有点像那个著名的故事,山上有座山,山里有座庙,庙里有两个和尚……。和尚讲故事是无穷无尽的,幸运的是数列的长度即使再大也不会是无尽的。所以当子子子……序列分到不可再分割的时候(最小的序列长度为1时),就可以返回开始合并数列了。逐步合并子子子子……数列,到最后就得到了一个新的有序数列。

第一次分组

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第7张图片

第二次分组

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第8张图片

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第9张图片

经过三次分组,已经将所有的子子子数列都变成了长度为1的数列。现在可以确定这些长度为1的数列必定是有序数列了,然后开始反向合并这些数列。

第一次合并

这里还需要考虑left和right长度不一致的情况。先合并数列[3]、[5]以及[9]、[4]。

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第10张图片

第二次合并 

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第11张图片

 第三次合并

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第12张图片归并排序完毕。经过3次合并,最终得到了一个有序数列。归并排序的时间复杂度是 O ( n Log n) )。

代码

#!/user/bin/env/python3
#-*-conding:utf-8 -*-
# data:20211210
# author:yang

from randomList import randomList
import timeit

def mergeSort(iList):
    if len(iList) <= 1:
        return iList
    middle = len(iList)//2
    left,right = iList[0:middle],iList[middle:]
    return mergeList(mergeSort(left),mergeSort(right))

def mergeList(left,right):
    """合并序列"""
    mList = []
    while left and right:
        if left[0] >= right[0]:
            mList.append(right.pop(0))
        else:
            mList.append(left.pop(0))
            
    while left:
        mList.append(left.pop(0))
    while right:
        mList.append(right.pop(0))
    return mList   
    
if __name__ == "__main__":
    iList = randomList(10)
    print(iList)
    print(mergeSort(iList))
    # print(timeit.timeit("selectionSort(iList)","from __main__ import selectionSort,iList",number = 1))
               

 5.快速排序

快速排序(Quick Sort)算法也是一种递归排序。

原理

以列表中的任意一个数为基准(一般选择列表中的第一个数),将列表分为左、右(前、后)两个子列表:左边子列表的数要比基准数小,右边子列表的数要比基准数大。然后继续把左边子列表和右边子列表按同样的方法继续分解、比较,一直到分无可分为止。然后按照左边子列表(比基准数小)+基准数+右边子列表(比基准数大)的方式连接起来。最后得到一个有序的数列。

以数列[7,3,5,1,9,4]为例。

第一次分组

以“7”为基准,比7小的分在左边的子数列中,比7大的分在右边的子数列中。

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第13张图片

 此时左边的子序列有4个数[3, 5, 1, 4],还需要继续分组。右边的子序列中只有一个数9,不需要再分了。第二次只需要将左边的部分分组排序就可以了。

第二次分组

左边的子序列还剩下[3, 5, 1, 4],现在以第一个数3为基准数,将后面部分的[5, 1, 4]分成两部分。同样还是比基准数(3)小的放到左边子序列,比基准数(3)大的放到右边子序列。

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第14张图片

 数分组完毕后。只要按照一定的顺序重新组合起来就可以了。组合很简单,就是小的数(左边部分)+中间数(基准数)+大的数(右边部分)。

第一次合并

将子序列合并,具体规则是left + [base] + right。这里需要稍微注意一下,left和right都是序列(列表),而base部分是单独的一个数,所以需要将它序列化。

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第15张图片

 第二次合并

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第16张图片

 第三次合并

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第17张图片

 经过3次分组、合并后,得到了有序数列。快速排序的时间复杂度最坏的情况下是 O ( n ^2 )。

代码(python&cpp)

#!/user/bin/env/python3
#-*-conding:utf-8 -*-
# data:20211210
# author:yang

from randomList import randomList
import timeit

def quickSort(iList):
    if len(iList) <= 1:
        return iList
    left = []
    right = []
    for i in iList[1:]:
        if i <= iList[0]:
            left.append(i)
        else:
            right.append(i)
    return quickSort(left) + [iList[0]] + quickSort(right)
        

if __name__ == "__main__":
    iList = randomList(10)
    print(iList)
    print(quickSort(iList))
    # print(timeit.timeit("selectionSort(iList)","from __main__ import selectionSort,iList",number = 1))

注:此方法速度快。

6.计数排序

计数排序(Counting Sort)算法是一种比较特殊的算法,因为它不是一个基于比较的算法。将两个数进行比较,将大的数放后面、小的数放前面,这样的算法都是基于比较的算法。

原理

它采用了一个巧妙的方法,选择一个数为基数,然后统计整个数列中有多少个数比基数小。如果有 n 个数比基数小,那么基数就放到新数列的第n +1的位置上(rList[n])。以数列[7, 3, 5, 1, 9, 4]为例,首先要做的是先创建一个与[7, 3, 5, 1, 9, 4]相同长度的空数列。

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第18张图片

 第一个数的位置

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第19张图片

第二个数的位置

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第20张图片

第三个数的位置

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第21张图片

依次类推

将所有的数字都插入到新数列后,排序就完成了。计数排序的时间复杂度是 O ( n + k ),其中 k 是整数的范围。

 代码(python&cpp)

#!/user/bin/env/python3
#-*-conding:utf-8 -*-
# data:20211210
# author:yang

from randomList import randomList
import timeit

def countingSort(iList):
    if len(iList) <= 1:
        return iList
    iLen = len(iList)
    rList = [None]*iLen
    for i in range(iLen):
        small = 0   # 比基数小的
        same = 0    # 与基数相等的
        for j in range(iLen):
            if iList[j] < iList[i]:
                small += 1
            elif iList[j] == iList[i]:  # 相同的数
                same += 1
        for k in range(small,small+same):
            rList[k] = iList[i]
    return rList
           

if __name__ == "__main__":
    iList = randomList(10)
    print(iList)
    print(countingSort(iList))
    # print(timeit.timeit("selectionSort(iList)","from __main__ import selectionSort,iList",number = 1))
    
                 

总结

[leetcode]排序算法(冒泡排序,选择排序,插入排序,快速排序,计数排序)_第22张图片

 从表格上来看,排序100次用时最少,速度最快的应该是快速排序。果然是名副其实。选择排序的速度与快速排序相差无几。用时最多、速度最慢的是插入排序,其次就是冒泡排序。当然,根据输入数列的不同,这个排名可能会有所变动。

参考

图解leetcode初级算法(python版)--胡松涛

你可能感兴趣的:(leetcode刷题,排序算法,leetcode,算法)