本文深入解析了冒泡、选择、插入、希尔、快速、合并及堆排序等经典算法的原理与实现，涵盖Python与Java代码示例，是理解排序算法不可多得的资源。
冒泡排序：
重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，所以叫“冒泡排序”。
原理
冒泡排序算法的原理如下：
1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素做同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。
升序：
python
def bubble_sort(alist):
n = len(alist)
for i in range(n-1,0,-1):
for j in range(0, n-1-i):
if alist[j] > alist[j+1]:
alist[j],alist[j+1] = alist[j+1], alist[j]
def bubble_minsort(list):
for i in range(len(list)-1,0,-1):#i表示每次需要遍历的元素个数,从n-1减小到1
for j in range(i):
if list[j+1]<list[j]:
list[j],list[j+1]=list[j+1],list[j]
java
public class BubbleSort {
public void Bubble_sort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
for (int j = 1; j < arr.length - 1 - i; j++) {
if (arr[j+1] < arr[i]);
{
int temp = arr[j+1];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
}
}
public class BubbleSort {
public static void main(String[] args) {
int arr[]=new int[] {2,5,8,3,6,9};
BubbleSort2(arr);
}
public static void BubbleSort2(int arr[]) {
for(int i=arr.length-1;i>=1;i--) {//每次需要遍历的元素个数
for(int j=0;j<=i;j++) {//每次元素遍历
if (arr[j+1]<arr[j]) {//每次比较两个元素，交换
int temp=arr[j+1];
arr[j+1]=arr[j];
arr[j]=temp;
}
}
}
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
}
}
选择排序
它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到全部待排序的数据元素排完。 选择排序是不稳定的排序方法。
给对应位置选择数据元素
时间复杂度：最好：O(n);最坏：O(nn）；平均：O（nn）
不稳定
python
#每次选择最小（大）的依此放在对应位置，并将对应位置的元素与其交换
def select_minsort(list):
for i in range(len(list)-1):#0-n-1位置
min_index=i#将每个位置的初始索引作为该位置对应的最小元素索引
for j in range(i+1,len(list)):#从该位置往后查找小的元素
if list[j]<list[i]:
min_index=j#将min_index指向最小的元素索引
if min_index!=i:#如果当前位置不是最小元素的索引，进行交换。
list[min_index],list[i]=list[i],list[min_index]
java
public class SelectSort {
public static void main(String[] args) {
int arr[]=new int[] {2,5,8,3,6,9};
selectsort(arr);
}
public static void selectsort(int[] arr) {
for (int i = 0; i < arr.length - 1; i++) {
int minindex = i;//当前位置索引
for (int j = i + 1; j < arr.length; j++) {
if (arr[j] < arr[minindex]) {
int temp = arr[minindex];
arr[minindex] = arr[j];
arr[j] = temp;
}
}
}
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
}
}
插入排序
直接插入排序基本思想是每一步将一个待排序的记录，插入到前面已经排好序的有序序列中去，直到插完所有元素为止。
从第二个元素开始，每个元素向前比较，小于前面的元素则交换
时间复杂度：最好：正序有序，O(n);最坏：逆序有序：O(nn）；平均：O（nn）
稳定
#从第二个位置开始（索引为1）的元素开始,对每个位置的元素向前遍历插入
def insert_minsort(list):
for i in range(1,len(list)):#从索引1开始，至n-1元素开始寻找向前插入，也可表示每次要遍历的个数
for j in range(i,0,-1):#i表示当前位置，从i向前比较，j为当前需要比较元素的索引
if list[j]<list[j-1]:#如果当前位置元素小于前一个，则交换，直至将最小的元素放在i-1处
list[j],list[j-1]=list[j-1],list[j]
java
public class InsertSort {
public static void main(String[] args) {
int arr[]=new int[] {2,5,8,3,6,9};
Insert_Sort(arr);
}
public static void Insert_Sort(int arr[]) {
for(int i=1;i<arr.length;i++) {//从第二个位置，下标为1的开始向前插入
for(int j=i;j>=1;j--) {//寻找前面的，j对应当前的元素
if(arr[j]<arr[j-1]) {//当前元素小于前面的元素，则互换位置
int temp=arr[j];
arr[j]=arr[j-1];
arr[j-1]=temp;
}
}
}
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
}
}
希尔排序（插入排序的优化）
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。分组插入方法，在每组内进行插入排序。
时间复杂度：最好：与步长有关;最坏：？O(nn）；？平均：O（nn）
不稳定
将list按步长gap分为n//gap组，每组数进行插入排序，再合并，gap逐渐减小，重复插入排序；最终gap=1时，即为插入排序
def shell_minsort(list):
n=len(list)
gap=n//2#python3中取整=python2中/
while gap > 0:#控制外部总体循环
for i in range(gap,n):#将所有gap之后的循环比较，gap-n；所有子序列一起遍历
for j in range(i,gap-1,-gap):#对i之前的进行比较；即比较往前面gap~i进行比较，因为j-gap=0,所以向前最后一个比较的为gap，range(i,gap-1,-gap)
if list[j]<list[j-gap]:#与j-gap进行比较
list[j-gap],list[j]=list[j],list[j-gap]
gap=gap//2#gap逐渐减小
java
ublic class ShellSort {
public static void main(String[] args) {
int arr[]=new int[] {2,5,8,3,6,9};
shellsort(arr);
}
public static void shellsort(int arr[]) {
int n=arr.length;
int gap=n/2;
while(gap>0) {//插入排序，小于前面的则插到前面
for(int i=gap;i<=n-1;i++) {//从gap开始往后，按gap分的子序列一起进行
for(int j=i;j>=gap;j-=gap) {//向前，最后一个为gap,以步长递减
if(arr[j]<arr[j-gap]) {
int temp=arr[j-gap];
arr[j-gap]=arr[j];
arr[j]=temp;
}
}
}
gap=gap/2;
}
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
}
}
快速排序
它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。
步骤为：
从数列中挑出一个元素，称为"基准"（pivot），
重新排序数列，所有元素比基准值小的摆放在基准前面，所有元素比基准值大的摆在基准的后面（相同的数可以到任一边）。在这个分区结束之后，该基准就处于数列的中间位置。这个称为分区（partition）操作。
递归地（recursive）把小于基准值元素的子数列和大于基准值元素的子数列排序。
递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会结束，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。
#第一步：以第一个元素为中间值，将数据分为两部分（一部分小于mid，一部分大于mid）；然后对两个部分递归之前的操作
def quick_minsort(list,start,end):
if start >= end:#递归退出条件
return
left=start#定义临时变量left，左边开始指标，向右移动
right=end#定义临时变量right，右边开始指标，向左移动
midvalue=list[start]#序列第一个元素为中间值
while left < right:#左边索引比右边小
while right>left and list[right]>=midvalue:#先从右向左找出小于midvalue的值；
right-=1#没找到小于的，right一直左移
list[left]=list[right]#右边找到比midvalue小的，赋值给left位置
while left<right and list[left]<midvalue:#从左向右找出大于midvalue的值
left+=1#没找到大于的，left右移
list[right]=list[left]#左边找到比midvalue大的，赋值给right位置。
list[left]=midvalue#此时left指针指向中间，将中间值放在中间位置
quick_minsort(list, start,left-1)#对中间值左边递归，中间位置left
quick_minsort(list, left+1, end)#对中间值右边递归，中间位置right
return list
public class QuickSort {
public static void main(String[] args) {
int arr[]=new int[] {2,5,8,3,6,9};
quicksort(arr,0,arr.length-1);
}
public static void quicksort(int arr[],int start,int end) {
if(start>=end) {
return;
}
int left=start;
int right=end;
int midvalue=arr[left];
while(left<right) {
while (right>left && arr[right]>midvalue) {//右边向前找小于中间值得值互换到左边
right-=1;
}
arr[left]=arr[right];
while (right>left && arr[left]<midvalue) {//左边向后找，找到大于中间值的值互换到右边
left+=1;
}
arr[right]=arr[left];
}
arr[left]=midvalue;//left指针移动到中间
quicksort(arr,start,left-1);
quicksort(arr,left+1,end);
for(int i=0;i<arr.length;i++) {
System.out.print(arr[i]+" ");
}
}
}
合并排序
归并排序是采用分治法的一个非常典型的应用。归并排序的思想就是先递归分解数组，再合并数组。
将数组分解最小之后，然后合并两个有序数组，基本思路是比较两个数组的最前面的数，谁小就先取谁，取了后相应的指针就往后移一位。然后再比较，直至一个数组为空，最后把另一个数组的剩余部分复制过来即可。
def merge_minsort(list):
if len(list)<=1:
return list
n=len(list)
mid=n//2#二分分解
#递归分解数组
#leftlist返回的是合并排序后的list左边列表
leftlist=merge_minsort(list[:mid])#，递归嵌套执行嵌套执行
# rightlist返回的是合并排序后的list右边列表
rightlist=merge_minsort(list[mid:])
left,right=0,0#利用两个指针分别指向左边列表和右边列表
result=[]
while left<len(leftlist) and right<len(rightlist):#leftlist和rightlist比较大小合并，从小到大加入新的result中
if leftlist[left]<rightlist[right]:
result.append(leftlist[left])
left+=1
else:
result.append(rightlist[right])
right+=1
result+=leftlist[left:]#leftlist和rightlist长度不一时，将比较后指针后面的全部加入，若没有则不加入
result+=rightlist[right:]
return result
堆排序
思想: 堆是一种数据结构，可以将堆看作一棵完全二叉树，这棵二叉树满足，任何一个非叶节点的值都不大于（或不小于）其左右孩子节点的值。 **将一个无序序列调整为一个堆，就可以找出这个序列的最大值（或最小值），然后将找出的这个值交换到序列的最后一个，这样有序序列就元素就增加一个，无序序列元素就减少一个，对新的无序序列重复这样的操作，就实现了排序。**大顶堆实现升序排序，小顶堆实现降序
时间复杂度：最好：O(nlogn）;最坏：？O(nlogn）；平均：O(nlogn）
不稳定
https://blog.youkuaiyun.com/liangjiubujiu/article/details/82811218
https://www.jianshu.com/p/d174f1862601
堆排序的执行过程：
1.从无序序列所确定的完全二叉树的第一个非叶子节点开始，从右至左，从下至上，对每个节点进行调整，最终将得到一个大顶堆。
对节点的调整方法：将当前节点（假设为a）的值与其孩子节点进行比较，如果存在大于a的值的孩子节点，则从中选出最大的一个与a交换。当a来到下一层的时候重复上述过程，直到a的孩子节点的值都小于a为止
2**.将当前无序序列中的第一个元素（反映在数中是根节点b），与无序序列中的最后一个元素交换（假设为c）**，b进入有序序列，到达最终位置。无序序列元素减少1个，有序序列元素增加1个，此时只有节点c可能不满足堆的定义，对其进行调整。
3.重复2 的过程，直到无序序列的元素剩下一个时排序结束。
#序列从0开始
def heap_sort(alist):
firstcount=len(alist)//2-1#从最后一个有子节点的根调整最大堆
for start in range(firstcount,-1,-1):#向前减少
heap_adjust(alist,start,len(alist)-1)
# 将最大的放到堆的最后一个, 堆-1, 继续调整排序
for end in range(len(alist)-1,0,-1):#最后一个节点，每次排序后遍历的最后一个节点减一，注意遍历到1
alist[0],alist[end]=alist[end],alist[0]#第一个节点与最后一个节点交换
heap_adjust(alist,0,end-1)#交换后再调整剩下的无序堆
def heap_adjust(alist,start,end):
root=start
while True:
child=root*2+1#子节点为根节点序列*2+1，*2+2
if child>end:
break
if child+1<=end and alist[child]<alist[child+1]:
child+=1#找到大的子节点
if alist[root]<alist[child]:#根节点子节点比较，找到大的
alist[root],alist[child]=alist[child],alist[root]
root=child#修改根节点为当前节点
else:
break
if __name__ == "__main__":
array = [16, 7, 3, 20, 17, 8]
print(array)
heap_sort(array)
print(array)
#在左边加入0，序列从1开始
def heap_sort(alist):
firstcount=(len(alist)-1)//2
for start in range(firstcount,0,-1):
heap_adjust(alist,start,len(alist)-1)
for end in range(len(alist)-1,1,-1):
alist[1],alist[end]=alist[end],alist[1]
heap_adjust(alist,1,end-1)
def heap_adjust(alist,start,end):
temp=alist[start]#创建临时变量
root=start
child=root*2
while child<=end:
if child<end and alist[child]<alist[child+1]:
child+=1
if temp<alist[child]:#根节点与子节点比较
alist[root]= alist[child]#将子节点的值给根节点
root=child#当前修改的节点为根节点，继续循环
child=2*root
else:
break
alist[root]=temp#最大值放入
if __name__ == "__main__":
from collections import deque
array = deque([16, 7, 3, 20, 17, 8])
array.appendleft(0)
print(array)
heap_sort(array)
for x in range(1, len(array)):
print(array[x])
稳定：冒泡、插入排序、归并排序
时间复杂度：O（nlogn）：归并排序、堆排序、快速排序（最坏O（n2））
空间复杂度：归并排序O(n),快速排序O（nlogn）
扫一扫
58万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
