数据结构利用Python实现常用排序算法的基本思路和代码

一、冒泡排序

基本思路&＃xff1a;冒泡排序&＃xff08;Bubble Sort&＃xff09;&＃xff0c;是一种计算机科学领域简单的排序算法。它重复地走访过要排序的数列&＃xff0c;一次比较两个元素&＃xff0c;如果他们的顺序错误就把他们交换过来。这个算法的名字由来是因为越小的元素会慢慢“浮”到数列的顶端&＃xff0c;越重的元素会慢慢的沉入到底端&＃xff0c;故名“冒泡排序”。时间复杂度最快: O(n)。,最坏: O(n^2)。注意&＃xff0c;缺点是每一次只能确定一个元素。

python语言实现代码如下&＃xff1a;

# 冒泡排序
def bubble_sort(my_list):length &＃61; len(my_list)# 序列长度为length&＃xff0c;需要执行length-1轮交换
for i in range(1, length):# 对于每一轮交换&＃xff0c;都将序列当中的左右元素进行比较
# 每轮交换当中&＃xff0c;由于序列最后的元素一定是最大的&＃xff0c;因此每轮循环到序列未排序的位置即可
for i in range(0, length-i):if my_list[i] > my_list[i&＃43;1]:temp &＃61; my_list[i]my_list[i] &＃61; my_list[i&＃43;1]my_list[i&＃43;1] &＃61; tempreturn my_list
if __name__ &＃61;&＃61; &＃39;__main__&＃39;:my_list &＃61; [1, 4, 5, 7, 3, 9, 10, 24, 0]new_mylist &＃61; bubble_sort(my_list)print(new_mylist)

二、直插法排序

基本思路&＃xff1a;直插排序法就是将一个新的数据直接插入到已经排好的数据当中&＃xff0c;将数组中的所有元素依次跟前面已经排好的元素相比较&＃xff0c;如果选择的元素比已排序的元素小&＃xff0c;则交换&＃xff0c;直到全部元素都比较过&＃xff0c; 时间复杂度为O(n^2)。

python语言实现代码如下&＃xff1a;

# 直接插入排序
def insert_sort(my_list):# 遍历数组中的所有元素&＃xff0c;其中0号索引元素默认已排序&＃xff0c;因此从1开始
for i in range(1, len(my_list)):# 将该元素与已排序好的前序数组依次比较&＃xff0c;如果该元素小&＃xff0c;则交换
# range(x-1,-1,-1):从i-1倒序循环到0
for j in range(i-1, -1, -1):# 判断&＃xff1a;如果符合条件则交换
if my_list[j] > my_list[j&＃43;1]:temp &＃61; my_list[j&＃43;1]my_list[j&＃43;1] &＃61; my_list[j]my_list[j] &＃61; tempreturn my_list
if __name__ &＃61;&＃61; &＃39;__main__&＃39;:my_list &＃61; [1, 2, 10, 3, 9, 4, 5, 7]new_list &＃61; insert_sort(my_list)print(new_list)

三、选择排序

基本思路&＃xff1a;比较&＃43;交换。从将要排序的序列中&＃xff0c;找到最小的元素&＃xff1b;如果最小元素不是待排序序列的第一个元素&＃xff0c;将其和第一个元素互换&＃xff1b;从余下的 N - 1 个元素中&＃xff0c;找出关键字最小的元素&＃xff0c;重复(1)、(2)步&＃xff0c;直到排序结束。

时间复杂度&＃xff1a;O(n^2)。

python语言实现代码如下&＃xff1a;

# 选择排序
def select_sort(my_list):# 依次遍历序列中的每一个元素
for x in range(0, len(my_list)):# 将当前位置的元素定义为当前的最小值
mixnum &＃61; my_list[x]# 将该元素与剩下的元素依次比较寻找最小元素
for i in range(x&＃43;1, len(my_list)):if my_list[i] # 将比较后得到的真正的最小值赋值给当前位置
my_list[x] &＃61; mixnumreturn my_list
if __name__ &＃61;&＃61; &＃39;__main__&＃39;:my_list &＃61; [2, 4, 1, 6, 7, 3, 9, 8]new_list &＃61; select_sort(my_list)print(new_list)

四、堆排序

基本思路&＃xff1a;

取出大顶堆的根节点&＃xff0c;和末尾的节点进行交换&＃xff0c;在满足的大顶堆的前提下&＃xff0c;进行重复交换&＃xff0c;剩下的哪个值就是最小值。时间复杂度&＃xff1a;O(n^2)

堆的概念&＃xff1a;堆&＃xff0c;分为大顶堆和小顶堆&＃xff0c;

大顶堆要求节点的元素都要大于其孩子&＃xff0c;

小顶堆要求节点元素都小于其左右

利用堆排序&＃xff0c;就是基于大顶堆或者小顶堆的一种排序方法。一下是通过大顶堆来实现。

python语言实现代码如下&＃xff1a;

# -------------------------堆排序--------------------------------
# **********获取左右叶子节点**********
def Left(i):return 2*i &＃43; 1
def Right(i):return 2*i &＃43; 2
# ********** 调整大顶堆 **********
# L:待调整序列 length: 序列长度 i:需要调整的下标
def adjust_max_header(L, length, i):# 定义一个int值保存当前序列最大值的下标
largest &＃61; i# 执行循环操作&＃xff1a;两个任务&＃xff1a;1 寻找最大值的下标&＃xff1b;2.最大值与父节点交换
while True:# 获得序列左右叶子节点的下标
left, right &＃61; Left(i), Right(i)# 当左叶子节点的下标小于序列长度 并且 左叶子节点的值大于父节点时&＃xff0c;将左叶子节点的下标赋值给largest
if (left and (L[left] > L[i]):largest &＃61; leftprint(&＃39;左叶子节点&＃39;, largest)else:largest &＃61; i# 当右叶子节点的下标小于序列长度 并且 右叶子节点的值大于父节点时&＃xff0c;将右叶子节点的下标值赋值给largest
if (right and (L[right] > L[largest]):largest &＃61; rightprint(&＃39;右叶子节点&＃39;, largest)# 如果largest不等于i 说明当前的父节点不是最大值&＃xff0c;需要交换值
if largest !&＃61; i:temp &＃61; L[i]L[i] &＃61; L[largest]L[largest] &＃61; tempi &＃61; largestcontinue
else:break
return L# ********** 建立大顶堆 **********
def build_max_header(L):length &＃61; len(L)for x in range(int((length-1)/2), -1, -1):adjust_max_header(L, length, x)# ********** 堆排序 **********
def do_header_sort(L):# 先建立大顶堆&＃xff0c;保证最大值位于根节点&＃xff1b;并且父节点的值大于叶子结点
build_max_header(L)# i&＃xff1a;当前堆中序列的长度.初始化为序列的长度
i &＃61; len(L)# 执行循环&＃xff1a;1. 每次取出堆顶元素置于序列的最后(len-1,len-2,len-3...)
# 2. 调整堆&＃xff0c;使其继续满足大顶堆的性质&＃xff0c;注意实时修改堆中序列的长度
while i > 0:temp &＃61; L[i-1]L[i-1] &＃61; L[0]L[0] &＃61; temp
# 堆中序列长度减1
i -&＃61; 1
# 调整大顶堆
adjust_max_header(L, i, 0)return L# 程序执行入口
if __name__ &＃61;&＃61; &＃39;__main__&＃39;:L &＃61; [2, 4, 3, 1, 7, 8, 9, 5, 10, 12, 11]print(do_header_sort(L))

五、快速排序

基本思路&＃xff1a;从序列当中选择一个基准数(pivot)&＃xff08;我们选择第一个数为基准数&＃xff09;
将序列当中的所有数依次遍历&＃xff0c;比基准数大的位于其右侧&＃xff0c;比基准数小的位于其左侧
重复步骤&＃xff0c;直到所有子集当中只有一个元素为止。

python语言实现代码如下&＃xff1a;

# 快速排序
# L&＃xff1a;待排序的序列 start排序的开始 index,end序列末尾的index
# 对于长度为length的序列&＃xff1a;start &＃61; 0;end &＃61; length - 1
def quick_sort(L, start, end):if start , j, pivot &＃61; start, end, L[start]while i # 从右开始向左寻找第一个小于pivot的值
while (i and (L[j] >&＃61; pivot):j &＃61; j - 1
# 将小于pivot的值移到左边
if i 1
# 从左开始向右寻找第一个大于pivot的值
while (i and (L[i] 1
# 将大于pivot的值移到右边
if i 1
# 循环结束后&＃xff0c;说明 i&＃61;j&＃xff0c;此时左边的值全都小于pivot,右边的值全都大于pivot
# pivot的位置移动正确&＃xff0c;那么此时只需对左右两侧的序列调用此函数进一步排序即可
# 递归调用函数&＃xff1a;依次对左侧序列&＃xff1a;从0 ~ i-1//右侧序列&＃xff1a;从i&＃43;1 ~ end
L[i] &＃61; pivot# 左侧序列继续排序
quick_sort(L, start, i-1)# 右侧序列继续排序
quick_sort(L, i&＃43;1, end)return Lif __name__ &＃61;&＃61; &＃39;__main__&＃39;:L &＃61; [9, 7, 2, 1, 7, 5, 3, 4]print(quick_sort(L, 0, len(L) - 1))

六、希尔排序

基本思路&＃xff1a;将待排序数组按照步长进行分组&＃xff0c;然后将每组的元素利用直接插入排序的方法进行排序&＃xff1b;每次将gap折半减小&＃xff0c;循环上述操作&＃xff1b;当gap&＃61;1时&＃xff0c;利用直接插入&＃xff0c;完成排序。

python语言实现代码如下&＃xff1a;

# 希尔排序
def insert_shell(L):# 初始化gap值&＃xff0c;此处利用序列长度的一般为其赋值
gap &＃61; int(len(L)/2)# 第一层循环&＃xff1a;依次改变gap值对列表进行分组
while gap >&＃61; 1:# 下面&＃xff1a;利用直接插入排序的思想对分组数据进行排序
# range(gap,len(L)):从gap开始
for x in range(gap, len(L)):# range(x-gap,-1,-gap):从x-gap开始与选定元素开始倒序比较&＃xff0c;每个比较元素之间间隔gap
for i in range(x-gap, -1, -gap):# 如果该组当中两个元素满足交换条件&＃xff0c;则进行交换
if L[i] > L[i&＃43;gap]:temp &＃61; L[i&＃43;gap]L[i&＃43;gap] &＃61; L[i]L[i] &＃61; temp# while循环条件折半
gap &＃61; int(gap/2)return Lif __name__ &＃61;&＃61; &＃39;__main__&＃39;:L &＃61; [3, 2, 4, 6, 3, 9, 4, 2]print(insert_shell(L))

七、归并排序

基本思路&＃xff1a;将已有的子序列合并&＃xff0c;达到完全有序的序列&＃xff1b;即先使每个子序列有序&＃xff0c;再使子序列段间有序。

首先将序列每次折半拆分&＃xff0c;然后将划分后的序列段两两排序合并

python语言实现代码如下&＃xff1a;

# 归并排序
# 这是合并的函数
# 将序列L[first...mid]与序列L[mid&＃43;1...last]进行合并
def mergearray(L,first,mid,last,temp):# 对i,j,k分别进行赋值
i, j, k &＃61; first, mid&＃43;1, 0
# 当左右两边都有数时进行比较&＃xff0c;取较小的数
while (i <&＃61; mid) and (j <&＃61; last):if L[i] <&＃61; L[j]:temp[k] &＃61; L[i]i &＃61; i&＃43;1
k &＃61; k&＃43;1
else:temp[k] &＃61; L[j]j &＃61; j&＃43;1
k &＃61; k&＃43;1
# 如果左边序列还有数
while i <&＃61; mid:temp[k] &＃61; L[i]i &＃61; i&＃43;1
k &＃61; k&＃43;1
# 如果右边序列还有数
while j <&＃61; last:temp[k] &＃61; L[j]j &＃61; j&＃43;1
k &＃61; k&＃43;1
# 将temp当中该段有序元素赋值给L待排序列使之部分有序
for x in range(0, k):L[first&＃43;x] &＃61; temp[x]
# 这是分组的函数
def merge_sort(L,first,last,temp):if first int((first &＃43; last) / 2)# 使左边序列有序
merge_sort(L, first, mid, temp)# 使右边序列有序
merge_sort(L, mid&＃43;1, last, temp)# 将两个有序序列合并
mergearray(L, first, mid, last, temp)
# 归并排序的函数
def merge_sort_array(L):# 声明一个长度为len(L)的空列表
temp &＃61; len(L)*[None]# 调用归并排序
merge_sort(L, 0, len(L)-1, temp)

八、基数排序

 基本思路&＃xff1a;通过序列中各个元素的值&＃xff0c;对排序的N个元素进行若干趟的“分配”与“收集”来实现排序。

分配&＃xff1a;我们将L[i]中的元素取出&＃xff0c;首先确定其个位上的数字&＃xff0c;根据该数字分配到与之序号相同的桶中

收集&＃xff1a;当序列中所有的元素都分配到对应的桶中&＃xff0c;再按照顺序依次将桶中的元素收集形成新的一个待排序列L[ ]

对新形成的序列L[]重复执行分配和收集元素中的十位、百位...直到分配完该序列中的最高位&＃xff0c;则排序结束

python语言实现代码如下&＃xff1a;

八、桶排序&＃xff08;简化版&＃xff1a;最简单最快速的排序&＃xff09;

基本思路&＃xff1a;个人理解-逆向思维&＃xff0c;首先将要排序的目标排序好&＃xff0c;然后将出现的数值记录&＃43;1&＃xff0c;形象的说就是&＃xff0c;每出现一次&＃xff0c;就将它放入对应的桶中&＃xff0c;然后将出现的次数输出。

demo:

第一步&＃xff1a;将分数按照大小排序&＃xff0c;分数由0-100分构成&＃xff0c;我们就定义一个数组int a[100] ,然后循环遍历数组的下标&＃xff0c;将所有的下标对应的值初始化为0

# python中没有数组&＃xff0c;我们用列表代替
a &＃61; []
for i in range(0, 101):# 初始化0
a.append(0)

第二步&＃xff1a;第一步以后&＃xff0c;我们现在已经有了代表一百个分数的列表元素了&＃xff0c;初始化为0&＃xff0c;那么&＃xff0c;我们的思维是&＃xff0c;每一个元素就代表一个‘’桶‘’&＃xff0c;每出现一次就将元素初始化的值对应&＃43;1&＃xff0c;也就是说&＃xff0c;列表中&＃xff08;C语言中是数组&＃xff0c;下标&＃xff09;每一个元素的值&＃xff0c;就代表下标&＃xff08;分数&＃xff09;对应出现的次数。

# 循环输入5个数
for i in range(5):n &＃61; int(input("请输入第%d个分数:" % i))a[n] &＃43;&＃61; 1

第三步&＃xff0c;遍历这个列表&＃xff0c;将大于0的元素&＃xff0c;输出对应的下标&＃xff08;分数&＃xff09;&＃xff0c;0不输出&＃xff08;没有出现过&＃xff09;&＃xff0c;值是多少就输出几。

# 循环遍历&＃xff0c;一次将出现大于0次数的元素输出&＃xff0c;值是多少就输出多少&＃xff0c;下标的对应的分数
for i in range(0, 101):for j in range(0, a[i]):print(i)

完整代码如下&＃xff1a;

# python中没有数组&＃xff0c;我们用列表代替
a &＃61; []
for i in range(0, 101):# 初始化0
a.append(0)# 循环输入5个数
for i in range(5):n &＃61; int(input("请输入第%d个分数:" % i))a[n] &＃43;&＃61; 1


# 循环遍历&＃xff0c;一次将出现大于0次数的元素输出&＃xff0c;值是多少就输出多少&＃xff0c;下标的对应的分数
for i in range(0, 101):for j in range(0, a[i]):print(i)

这里的桶排序只是一个简化版本的桶排序&＃xff0c;并不是真正意义的桶排序&＃xff0c;不过思想是这样的&＃xff0c;&＃xff08;个人理解是逆向思维&＃xff0c;从问题着手&＃xff09;&＃xff0c;由于python3中&＃xff0c;已经没有数组的定义&＃xff0c;只好用列表代替&＃xff0c;希望大家不要纠结代码&＃xff0c;要学会这种数据结构的抽象思维&＃xff0c;只有这样&＃xff0c;才能编程你们的东西。

桶排序最大的问题就是&＃xff0c;当你的数据达到数以万计的时候&＃xff0c;他就需要定义相应的空间&＃xff0c;十分浪费&＃xff0c;所以这样用空间换时间的做法不靠谱&＃xff0c;再者&＃xff0c;要是小数更没有办法进行排序了&＃xff0c;所以引入了冒泡&＃xff0c;快排&＃xff0c;选择&＃xff0c;直插&＃xff0c;希尔等排序。

总结&＃xff1a;

当数据量小的时候&＃xff0c;这八种排序不会有什么区别。

但是当数据量达到几万&＃xff0c;甚至几十万的时候&＃xff0c;就会拉开差距。

从运行结果上来看&＃xff0c;堆排序、归并排序、基数排序比其他算法要快的多。

提醒&＃xff1a;这里的排序只是C语言中排序的最简单的思想&＃xff0c;想要深入研究和挖掘&＃xff0c;需要对算法进行不断的优化处理&＃xff0c;以后有时间给大家更新。