八大排序算法总结之一（冒泡排序，快速排序，直接插入排序，希尔排序）

排序有内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序一般是排序的数据量很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。我们经常说的八大排序说的就是内部排序。 

---

冒泡排序算法：（从后往前）bubbleSort

• 比较相邻的两个数，若前面的数大于后面的数，则交换两个数；
• 这样对0到n-1个数据进行遍历，那么最大的数据就会被排到n-1处；
• 重复步骤，直至再也不能交换。

public static void bubbleSort1(int [] input,int n){        //外围循环n-1次，每次确定一个元素的位置，位于尾部        for(int i=0;i<n-1;i++){            //内部循环，相邻元素进行比较，比较次数逐步减1            for(int j=0;j<n-1-i;j++){                //从小到大排序                if(input[j]>input[j+1]){                    int temp = input[j];                    input[j] = input[j+1];                    input[j+1] = temp;                }            }        }    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

对于一些数据，前面部分是乱序的，而后面部分是有序的。当前面的排序好后，后面的元素排序还需要重复前面的操作，这种做法是非常多余的。对与这种情况可以做出优化，比如加上一个标志（flag），初始值为false，有交换则置为true，如果某次排序没有交换元素，则表明后面的元素是有序的，跳出循环，排序结束。

public static void bubbleSort2(int [] input,int n){        //外围循环n-1次，每次确定一个元素的位置，位于尾部        for(int i=0;i<n-1;i++){            //标记位，如果这一趟发生了交换，则为true，否则为false。明显如果有一趟没有发生交换，说明排序已经完成。            boolean flag = false;            //内部循环，相邻元素进行比较，比较次数逐步减1            for(int j=0;j<n-1-i;j++){                //从小到大排序                if(input[j]>input[j+1]){                    int temp = input[j];                    input[j] = input[j+1];                    input[j+1] = temp;                    //发生交换，置flag为true                    flag=true;                }            }            //没有发生交换，则表明已是有序，跳出循环            if(flag==false){                break;            }        }           }   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

时间复杂度O(n^2) , 算法稳定性：稳定（如果两个元素相等，我想你是不会再无聊地把他们俩交换一下）

---

快速排序算法（快排）：quickSort

它的基本思想是：通过一趟排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 
注意：第一遍快速排序不会直接得到最终结果，只能确定一个数的最终位置。为了得到最后结果，必须继续分解数组，直到数组不能再分解为止（只有一个数据），才能得到正确结果。

• 先从数列中取出一个数作为基准数
• 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
• 再对左右区间重复第二步，直到各区间只有一个数。

快速排序算法是基于分治法的：

分治法+挖坑（ 先从后向前找，再从前向后找）： 
3 4 6 8 9 10 5 2 16 
首先选定一个枢纽数3，pivotkey=a[0] ， a[0]被保存到pivotkey中，可以被认为，在a[0]上挖了一个坑，可以将其他数据填充到这里来。然后从后向前找到小于pivotkey的值2，a[0]=a[7]，a[0]上的坑被a[7]填上，结果又形成了一个新坑a[7].

public static void quickSort(int low,int high,int []input){        if(low<high){            int pivotloc = partion1(low,high,input);            quickSort(low,pivotloc-1,input);            quickSort(pivotloc+1,high,input);        }       }    public static int partion1(int low,int high,int[]input){        //开始挖坑，input[low]为枢纽，其值保存在pivotkey中，可以将其他数据填充过来        int pivotkey = input[low];        while(low<high){            //从后向前，直到找到小于pivotkey的值            while(low<high&&input[high]>=pivotkey){                high--;            }            //加上判断条件是因为当high==low，不必操作下面的语句            if(low<high){                //在low的位置上填坑，又形成了一个新坑                input[low] = input[high];                //从下一个位置开始                low++;            }            //从前向后，直到找到大于pivotkey的值            while(low<high&&input[low]<=pivotkey){                low++;            }            if(low<high){                //在high的位置上填坑，又形成了一个新坑                input[high]=input[low];                //从下一个位置开始                high--;            }        }        //****low==high,退出时，将pivotkey填到这个坑****pivotkey一直只是用与比较没有被填充过，当low==high，将其填充        input[low] = pivotkey;        return low;    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

分治法，但不挖坑，交换的方法。最后的那个坑不需要去填，因为在交换的过程中，已经处理好了。这样，没交换一次就需要进行3次赋值语句，而实际上，在排序过程中对枢纽节点的赋值是多余的。只需最后赋值，也就是上面的做法。下面是没有改进前的方法。

public static void quickSort(int low,int high,int []input){        if(low<high){            int pivotloc = partion2(low,high,input);            quickSort(low,pivotloc-1,input);            quickSort(pivotloc+1,high,input);        }       }public static void swap(int[] input,int begin,int end){        int temp = input[begin];        input[begin] = input[end];        input[end] = temp;    }public static int partion2(int low,int high,int[]input){        //枢纽节点        int pivotkey = input[low];        while(low<high){            //从后向前，直到找到小于pivotkey的值            while(low<high&&input[high]>=pivotkey){                high--;            }            //加上判断条件是因为当high==low，不必操作下面的语句            if(low<high){                //交换                swap(input,low,high);                //从下一个位置开始                low++;            }            //从后向前，直到找到大于pivotkey的值            while(low<high&&input[low]<=pivotkey){                low++;            }            if(low<high){                //交换                swap(input,low,high);                //从下一个位置开始                high--;            }        }        //返回之前没有填坑，是因为在交换过程中已经完成        return low;    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42

有时是以中间的数作为基准数的，要实现这个非常方便，直接将中间的数和第一个数进行交换就可以了。时间复杂度O（nlogn）, 算法稳定性：不稳定。

---

直接插入排序： insertSort

直接插入排序(Insertion Sort)的基本思想是：每次将一个待排序的记录，按其关键字大小插入到前面已经排好序的子序列中的适当位置，直到全部记录插入完成为止。

直接插入排序时使用顺序查找，找到关键字应该插入的位置，然后将该位置后面的所有元素向后移动。然后将要插入的值插入目标位置。

public static void insertSort(int []input){        for(int i=1;i<input.length;i++){            //用来标记临界点            int j=i-1;            for(;j>=0;j--){                //插入input[i]时，前面的都是有序的序列，直到找到一个小于input[i]的值input[j]，那么该位置后面的一个位置就是input[i]的位置                if(input[j]<input[i]){                    break;                }            }            //j==i-1,表明input[i]前面的一个数input[i-1]就小于input[i],就不必移动数组了            if(j!=i-1){                int temp = input[i];                for(int k=i-1;k>j;k--){                    input[k+1] = input[k];                }                //标记点的后一位就是input[i]的位置                input[j+1]=temp;            }               }    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

改进（折半插入排序）：在直接插入排序时，采用折半查找的方法找到插入的标记点，然后将标记点后面的元素从后向前依次移动一个位置。

public static void bInsertSort(int []input){        for(int i=1;i<input.length;i++){            int low=0;            int high = i-1;            //high作为标记节点，input[high]<input[i]            while(high>=low){                int middle = (low+high)/2;                if(input[middle]<input[i])                    low = middle+1;                else                    high=middle-1;            }            //保存input[i]            int temp = input[i];            for(int k=i-1;k>high;k--){                input[k+1] = input[k];            }            input[high+1] = temp;                   }    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

折半插入排序所需附件的存储空间和直接插入排序相同，从时间复杂度上来讲，折半插入排序仅仅减少了关键字之间的比较次数，但移动次数不变。因此时间复杂度还是O（n^2）. 算法稳定性：稳定。

改进：直接插入排序时，将收索和后移两个动作同时进行。

public static void insertSort3(int []input){        for(int i=1;i<input.length;i++){            //0~i-1位为有序，若第i位大于i-1位，忽略此次循环，相当于continue            if(input[i-1]>input[i]){                int temp = input[i];                int j = i-1;                //收索和移动同时进行                for(;j>=0&&input[j]>temp;j--){                    //input[j]后移一位，在input[i]处挖了一个坑                    input[j+1] = input[j];                }                input[j+1] = temp;            }        }    }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

再对上面的方法进行改写， 用数据交换代替数据后移。

public static void insertSort2(int []input){        for(int i=1;i<input.length;i++){            for(int j=i-1;j>=0;j--){                //基于有i前面的元素数有序的，交换之后input[i]的值向前移动了一位，直到有input[j]<input[j+1]为止                if(input[j]>input[j+1]){                    int temp = input[j];                    input[j] = input[j+1];                    input[j+1] = temp;                }            }        }    }
1
2
3
4
5
6
7
8
9
10
11
12
1
2
3
4
5
6
7
8
9
10
11
12

---

希尔排序：：shellSort

希尔排序(Shell Sort)是插入排序的一种。也称缩小增量排序，是直接插入排序算法的一种更高效的改进版本。 
基本思想是：先取一个小于n的整数d1作为第一个增量，把文件的全部记录分组。所有距离为d1的倍数的记录放在同一个组中。先在各组内进行直接插入排序；然后，取第二个增量d2(d2小于d1),重复上述的分组和排序;依次取d3、d4、…..直至取到dt=1为止,即所有记录放在同一组中进行直接插入排序。

import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.StreamTokenizer;public class ShellSort {    public static void shellInsert(int[]input,int dk){        /*         * 对数组做一趟希尔排序。本算法和直接插入排序相比，做了如下修改：         * 前后记录位置的增量是dk，而不是1;         * */        //所有距离为dk的倍数的记录放在同一个组中，对组内元素进行直接插入排序        for(int i=dk;i<input.length;i++){            if(input[i-dk]>input[i]){                //用于保存将要插入有序分组的元素input[i]                int temp = input[i];                ////收索和移动同时进行                int j = i-dk;                for(;j>=0&&input[j]>temp;j-=dk){                    //input[j]后移dk位，在input[j]处挖了一个坑                    input[j+dk] = input[j];                }                //填坑                input[j+dk] = temp;            }        }           }    public static void shellSort(int []input,int[]dk){        for(int i=0;i<dk.length;i++){            //执行多个分组插入排序，但最后一个dk，必须是1            shellInsert(input,dk[i]);        }    }    public static void main(String[] args) throws IOException {        StreamTokenizer cin = new StreamTokenizer (new BufferedReader(new InputStreamReader(System.in)));        while(cin.nextToken()!=cin.TT_EOF){            int n =(int)cin.nval;            int []input = new int[n];            for(int i=0;i<n;i++){                cin.nextToken();                input[i] = (int)cin.nval;            }            int[]dk ={6,5,4,3,1};//{6,5,1}、{4,3,1}都是合理的            shellSort(input,dk);            for(int i=0;i<input.length;i++){                System.out.print(input[i]+" ");            }        }    }}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50

该方法实质上是一种分组插入方法。专家们提倡，几乎任何排序工作在开始时都可以用希尔排序，若在实际使用中证明它不够快，再改成快速排序这样更高级的排序算法. 本质上讲，希尔排序算法是直接插入排序算法的一种改进，减少了其复制的次数，速度要快很多。 原因是，当n值很大时数据项每一趟排序需要的个数很少，但数据项的距离很长。当n值减小时每一趟需要和动的数据增多，此时已经接近于它们排序后的最终位置。 正是这两种情况的结合才使希尔排序效率比插入排序高很多。希尔排序的时间复杂度与增量序列的选取有关，O(n^2)~O(nlog2n), 算法稳定性：不稳定。