插入排序[数据结构](复习)

Posted ZzUuOo666

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了插入排序[数据结构](复习)相关的知识,希望对你有一定的参考价值。

  主要由三个插入排序的重要算法:直接插入排序、折半插入排序和希尔排序。

  其基本思想在于每次讲一个待排序的记录,按其关键字大小插入到前面已经排好序的子序列中,直到全部记录插入完成。

  直接插入排序    稳定  O(n^2)


  适用性:直接插入排序算法适用于顺序存储和链式存储的线性表。当为链式存储时,可以从前往后查找指定元素的位置

  大部分排序算法都仅适用于顺序存储的线性表。

 1    /**
 2      * 插入排序
 3      * 平均O(n^2),最好O(n),最坏O(n^2);空间复杂度O(1);稳定;简单
 4      * @author zuo
 5      *
 6      */
 7     static void insertionSort(int[] a) {
 8         int tmp;
 9         for(int i=1;i<a.length;i++){
10             for(int j=i;j>0;j--){
11                 if(a[j]<a[j-1]){
12                     tmp=a[j-1];
13                     a[j-1]=a[j];
14                     a[j]=tmp;
15                 }
16             }
17         }
18     }
19     
20     public static void main(String[] args) {
21         int array[] = {10,9,2,3,6,4,7,1,5,11,8};
22         insertionSort(array);
23         for (int i : array)
24             System.out.print(i + " ");
25     }

初始:   10、9、2、3、6、4、7、1、5、11、8

第一趟:9、10、2、3、6、4、7、1、5、11、8

第二趟:2、9、10、3、6、4、7、1、5、11、8

第三趟:2、3、9、10、6、4、7、1、5、11、8

第四趟:2、3、6、9、10、4、7、1、5、11、8

第五趟:2、3、4、6、9、10、7、1、5、11、8

第六趟:2、3、4、6、7、9、10、1、5、11、8

第七趟:1、2、3、4、6、7、9、10、5、11、8

第八趟:1、2、3、4、5、6、7、9、10、11、8

第九趟:1、2、3、4、5、6、7、9、10、11、8

第十趟:1、2、3、4、5、6、7、8、9、10、11

 

折半插入排序


 

  ①每次插入,都从前面的有序子表中查找出待插入元素应该被插入的位置; 

  ②给插入位置腾出空间,将待插入元素复制到表中的插入位置。 
  注意到该算法中,总是边比较边移动元素,下面将比较和移动操作分离开来,即先折半查找出元素的待插入位置,然后再同意地移动待插入位置之后的所有元素。当排序表为顺序存储的线性表时,可以对直接插入排序算法作如下改进:由于是顺序存储的线性表,所以查找有序子表时可以用折半查找来实现。在确定出待插入位置后,就可以统一地向后移动元素了。

 1    /**
 2      * 折半插入排序 
 3      * 折半查找只是减少了比较次数,但是元素的移动次数不变。
 4      * 它的空间复杂度 O(1) ,时间复杂度O(n^2),是一种稳定的排序算法
 5      * @param data
 6      * @author zuo
 7      */
 8     static void binaryInsertSort(int[] data) {  
 9         for(int i=1;i<data.length;i++){
10             if(data[i]<data[i-1]){
11                 int tmp=data[i];//缓存处的元素值
12                 int low=0;//记录搜索范围的左边界
13                 int high=i-1;//记录搜索范围的右边界
14                 while(low<=high){
15                     int mid=(low+high)/2;//记录中间
16                     if(data[mid]<tmp){//比较中间位置数据和处数据大小,以缩小搜索范围
17                         low=mid+1;
18                     }else{
19                         high=mid-1;
20                     }
21                 }
22                 for(int j=i;j>low;j--){
23                     data[j]=data[j-1];
24                 }
25                 data[low]=tmp;
26                 print(data);
27             }
28         }
29     }  
30     
31     public static void main(String[] args) {
32         int array[] = {10,9,2,3,6,4,7,1,5,11,8};
33         binaryInsertSort(array);
34         for (int i : array)
35             System.out.print(i + " ");
36     }

 

每一趟和直接插入排序相同。

性能分析:

折半查找只是减少了比较次数,但是元素的移动次数不变。约为O(nlog2n),该比较次数与待排序表的初始状态无关,仅取决于表中的元素个数n;

而元素的异动次数没有变,它依赖于待排序表的初始状态,因此折半插入排序的时间复杂度仍为O(n^2)。

 

希尔排序

 


 

 又称为缩小增量排序。

希尔排序的基本思想是:先将待排序表分割成若干个形如L[i,i+d,i+2d,...,i+kd]的“特殊”字表,分别进行直接插入排序;

然后取第二个步长d2<d1,重复上述过程,直到所取到的dt=1,即所有记录已放在同一组中,再进行直接插入排序,

由于此时已经具有较好的局部有序性,故可以很快得到最终结果。 

 

 1 static void shellSortSmallToBig(int[] data) {
 2         int j = 0;
 3         int temp = 0;
 4         for (int increment = data.length / 2; increment > 0; increment /= 2) {
 5             System.out.println("increment:" + increment);
 6             for (int i = increment; i < data.length; i++) {
 7                 System.out.println("i:" + i);
 8                 temp = data[i];
 9                 for (j = i - increment; j >= 0; j -= increment) {
10                      System.out.println("j:" + j);
11                      System.out.println("temp:" + temp);
12                      System.out.println("data[" + j + "]:" + data[j]);
13                     if (temp < data[j]) {
14                         data[j + increment] = data[j];
15                     } else {
16                         break;
17                     }
18                 }
19                 data[j + increment] = temp;
20             }
21             for (int i = 0; i < data.length; i++)
22                 System.out.print(data[i] + " ");
23         }
24     }
25     
26     public static void main(String[] args) {
27         int array[] = {10,9,2,3,6,4,7,1,5,11,8};
28         shellSortSmallToBig(array);
29         for (int i : array)
30             System.out.print(i + " ");
31     }

 

性能分析:

空间效率:仅使用了常数个辅助单元,空间复杂度为0(1)

时间效率:由于希尔排序的时间复杂度依赖于增量序列的函数,这涉及数学上还未解决的难题,所以其时间复杂度分析比较困难。当n在某个特定范围时,希尔排序的世界复杂度约为O(n^1.3)。在最坏情况下希尔排序的时间复杂度为O(n^2)。

稳定性:当相同关键字的记录被划分到不同字表时,可能会改变他们之间的相对次序,因此,希尔排序是一个不稳定的排序方法。

例如:表L={3,2,2},经过一趟排序后,L={2,2,3},显然2与2的相对次序发生变化。

适用性:希尔排序算法仅适用于当线性表为顺序存储的情况。

 

以上是关于插入排序[数据结构](复习)的主要内容,如果未能解决你的问题,请参考以下文章

六千字快速复习七种常用排序

六千字快速复习七种常用排序

数据结构复习之--“插入排序”-JAVA实现

2023数据结构考研复习-排序

2023数据结构考研复习-排序

2021-10-21java:六千字快速复习七种常用排序