排序算法：冒泡排序、插入排序、选择排序、希尔排序

冷不防 2022-03-22 14:54 318阅读 0赞

相关博客：

[排序算法：冒泡排序、插入排序、选择排序、希尔排序][Link 1]

[排序算法：归并排序、快速排序][Link 2]

[排序算法：桶排序、计数排序、基数排序][Link 3]

[排序算法：堆排序][Link 4]

[十大排序算法小结][Link 5]

--------------------

# 一、冒泡排序： #

**1、算法原理：**

冒泡排序只会操作相邻的两个数据。每次冒泡操作都会对相邻的两个元素进行比较，看是否满足大小关系的要求。如果不满足就让它俩互换位置。一次冒泡会让至少一个元素移动到它应该在的位置，重复n次，就完成了n个数据的排序工作。

**2、算法描述：**

（1）比较相邻的元素。如果第一个比第二个大，就交换它们两个；

（2）对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对，这样在最后的元素应该会是最大的数；

（3）针对所有的元素重复以上的步骤，除了最后一个；

重复步骤1~3，直到排序完成。

**3、动图演示**：

![2018121918593457][]

**4、Java代码实现：**

//1、冒泡排序
    	public void bubbleSort(int[] a){
    		int len = a.length;
    		for(int i=0;i<len;++i){
    			
    			//提前退出冒泡循环的标志
    			boolean flag = false;
    			
    			for(int j=0;j<len-i-1;++j){
    				if(a[j]>a[j+1]){
    					int temp = a[j];
    					a[j]=a[j+1];
    					a[j+1]=temp;
    					flag=true;//true表示有数据交换
    				}
    			}
    			
    			if(!flag) break;//没有数据交换，提前退出
    		}
    	}

**5、算法分析：**

（1）冒泡的过程中只涉及相邻数据的交换操作，只需要常量级的临时空间，所以它的空间复杂度为O(1），是一个原地排序算法。

（2）冒泡排序是稳定的排序算法。

（3）最好时间复杂度为O(n)，最坏时间复杂度为O(n^2)，平均时间复杂度为O(n^2)。

--------------------

# 二、插入排序： #

**1、算法原理：**

将数组的数据分为两个区间，**已排序区间**和**未排序区间**。初始已排序区间只有一个元素，就是数组的第一个元素。算法的核心思想就是，取未排序区间中的元素，在已排序区间中找到合适的位置将其插入，并保证已排序区间的数据一直有序。重复这个过程，直到未排序区间中元素为空，算法结束。

**2、算法描述：**

（1）从第一个元素开始，该元素可以认为已经被排序；

（2）取出下一个元素，在已经排序的元素序列中从后向前扫描；

（3）如果该元素（已排序）大于新元素，将该元素移到下一位置；

（4）重复步骤3，直到找到已排序的元素小于或者等于新元素的位置；

（5）将新元素插入到该位置后；

（6）重复步骤2~5。

**3、动图演示：**

![20181219185934155][]

**4、Java代码实现：**

//2、插入排序
    	public void insertSort(int[] a){
    		int len=a.length;
    		
    		for(int i=1;i<len;++i){
    			int current=a[i];
    			int j=i-1;
    			//查找需要插入的位置
     			for(;j>=0;--j){
     				if(a[j]>current){
     					a[j+1]=a[j];
     				}else{
     					break;
     				}
     			}
     			a[j+1]=current;//插入数据
    		}
    	}

**5、算法分析：**

（1）插入算法的运行只需要用到一个额外的额存储空间，所以空间复杂度为O(1),是原地排序算法。

（2）插入算法是稳定的排序算法。

（3）最好时间复杂度为O(n)，最坏时间复杂度为O(n^2)，平均时间复杂度为O(n^2)。

--------------------

# 三、选择排序： #

**1、算法原理：**

选择排序的实现思路和插入排序类似，也分为已排序区间和未排序区间。但是选择排序每次会从未排序区间中选择最小（最大）的元素，存放已排序区间的末尾。重复此操作，直到所有元素排序完毕。

**2、算法描述：**

（1）初始状态：无序区为R\[1..n\]，有序区为空；

（2）第i趟排序(i=1,2,3…n-1)开始时，当前有序区和无序区分别为R\[1..i-1\]和R(i..n）。该趟排序从当前无序区中-选出关键字最小的记录 R\[k\]，将它与无序区的第1个记录R交换，使R\[1..i\]和R\[i+1..n)分别变为记录个数增加1个的新有序区和记录个数减少1个的新无序区；

（3）n-1趟结束，数组有序化了。

**3、动图演示：**

![20181219185934115][]

**4、Java代码实现：**

//3、选择排序：
    	public void selectionSort(int[] a){
    		int len = a.length;
    		int minIndex,temp;
    		
    		for(int i=0;i<len;i++){
    			minIndex=i;
    			//寻找未排序部分的最小值的索引
    			for(int j=i+1;j<len;j++){
    				if(a[j]<a[minIndex]){
    					minIndex=j;
    				}
    			}
    			
    			temp=a[i];
    			a[i]=a[minIndex];
    			a[minIndex]=temp;
    		}
    	}

**5、算法分析：**

（1）选择排序的空间复杂度为O(1)，是一种原地排序算法。

（2）选择排序不是一种稳定的排序算法。因为选择排序每次都要从未排序区间中选择最小值，并和前面的元素交换位置，这样会破坏稳定性。

（3）选择排序的最好、最坏、平均时间复杂度都是O(n^2)。

--------------------

# 四、希尔排序： #

**1、算法原理：**

希尔排序是简单插入排序的改进版。他与插入排序的不同之处在于，它会优先比较较远的元素。希尔排序又叫缩小增量排序。希尔排序的核心在于间隔序列的设定（也就是增量）。既可以提前设定好间隔序列，也可以动态定义间隔序列。

**2、算法描述：**

先将整个待排序的记录序列分割成为若干子序列分别进行直接插入排序，具体算法描述：

（1）选择一个增量序列t1，t2，…，tk，其中ti>tj，i<j，tk=1；

（2）按增量序列个数k，对序列进行k 趟排序；

（3）每趟排序，根据对应的增量ti，将待排序列分割成若干长度为m（m=length/ti） 的子序列，分别对各子表进行直接插入排序。仅增量因子为1 时，整个序列作为一个表来处理，表长度即为整个序列的长度。

**3、动图演示：**

![20181219185934194][]

**4、Java代码实现：**

//4、希尔排序：
    	public void shellSort(int[] a){
    		int len = a.length;
    		
    		//希尔排序的关键在于设置增量，这里我们动态设置一个增量
    		int gap=1;
    		while(gap<len/3){
    			gap=gap*3+1;
    		}
    		
    		int temp;
    		for(;gap>0;gap=(int) Math.floor(gap/3)){
    			for(int i=gap;i<len;i++){
    				temp = a[i];
    				int j=i-gap;
    				for(;j>=0 && a[j]>temp;j-=gap){
    					a[j+gap]=a[j];
    				}
    				a[j+gap]=temp;
    			}
    		}
    	}

**5、算法分析：**

（1）希尔排序的空间复杂度为O(1)，是一种原地排序算法。

（2）希尔排序不是一种不稳定的排序算法。多次插入排序，我们知道一次插入排序是稳定的，不会改变相同元素的相对顺序，但在不同的插入排序过程中，相同的元素可能在各自的插入排序中移动，最后其稳定性就会被打乱，所以希尔排序是不稳定的。

（3）选择排序的最好时间复杂度为O(n)、最坏时间复杂度都是O(n^2)，平均时间复杂度为O(n^1.3)。

参考文章：[https://www.cnblogs.com/onepixel/p/7674659.html][https_www.cnblogs.com_onepixel_p_7674659.html]

[Link 1]: https://blog.csdn.net/a745233700/article/details/86683603
[Link 2]: https://blog.csdn.net/a745233700/article/details/86689225
[Link 3]: https://blog.csdn.net/a745233700/article/details/86693150
[Link 4]: https://blog.csdn.net/a745233700/article/details/86696956
[Link 5]: https://blog.csdn.net/a745233700/article/details/80794084
[2018121918593457]: /images/20220322/bd88c0c8e1e547d586c87e6ac16294e2.png
[20181219185934155]: /images/20220322/9969cfefb5b54caeaa9f12f8c8f70983.png
[20181219185934115]: /images/20220322/5e8d56280e6b41e3a795f1e099354665.png
[20181219185934194]: /images/20220322/185ad72d672e41b3821d07b89c1cb2bf.png
[https_www.cnblogs.com_onepixel_p_7674659.html]: https://www.cnblogs.com/onepixel/p/7674659.html