三种简单排序（冒泡、插入、选择）的比较和图解- 校招VIP

转载声明：文章来源 https://blog.csdn.net/cc1258000/article/details/79113211

冒泡排序
这种排序方式是最容易理解的，主体思想就是：
指针重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。
走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成。
这个算法的名字由来是因为越大的元素会经由交换慢慢“浮”到数列的顶端，故名。

接下来我们来看看冒泡排序的图解，这里一个推荐网站：https://visualgo.net/ ，里面有很多算法实现的动画，可以对运行过程有一个更直观的了解：

冒泡排序一次只比较两个数字，并且这两个数字是相邻的。
从图上我们可以看到，原数组为【30，8，15，18，12】。
第一次比较首先比较第0位和第一位，并且将结果大的数字往后移动，也就是交换。第0位是40，第1 位是8，40>8，所以我们将大的数字往后移动。
同理，如果第0位<第1 位，我们就不进行交换。

之后我们在比较第1位和第2位的数字。将结果大的往后移动。
就这样，通过n-1次比较后（n为数组长度），我们就将最大的数字移到了数组的最末端。然后再继续进行第二轮比较，找出第二大的数字，往后以此类推。
一共需要比较的次数为： (n-1)+(n-2)+(n-3)+·····+1;

以下是JAVA代码实现：

public class BubbleSort {
    public static void sort(int[] a) {
        for(int i=a.length-1;i>=0;i--){ //i控制比较的轮数
            for(int j=0;j<i;j++){ //j每一轮比较的次数
                if(a[j]>a[j+1]){
                    a[j]=a[j]^a[j+1];
                    a[j+1]=a[j]^a[j+1];
                    a[j] = a[j]^a[j+1];
                }
            }
        }
    }
}

选择排序

选择排序（Selection sort）是一种简单直观的排序算法。
它的工作原理是每一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，直到全部待排序的数据元素排完。
我们来看一下图解：

选择排序就是对数组中的元素进行比较选择，然后直接放置在排序后的位置。

首先指针K先指向数组0号位置，K相当于指明一个目标位置。然后另一个指针min从K开始，往后一次比较，找到最小的值，并存储在min中，比较了一轮后，min中存储的数就是整个数组中最小的数字。
这是直接将min中的数字和K指向的数字交换即可。
然后找到数组中第二小的数，让他跟数组中第二个元素交换一下值，以此类推。

JAVA代码实现：

public class StraightSelectionSort {
    public static void sort(int a[]) {  
        int k=0;
        for(int i=0;i<a.length-1;i++){
            k=i;
            for(int j=i+1;j<a.length;j++){
                if(a[j]<a[k]){
                    k=j;
                }
            }
            if(k!=i){
                a[k] = a[k]^a[i];
                a[i] = a[k]^a[i];
                a[k] = a[k]^a[i];
            }
        }
    }
}

插入排序

要求在这个已经排好的数据序列中插入一个数，但要求插入后此数据序列仍然有序，这个时候就要用到一种新的排序方法——插入排序法,插入排序的基本操作就是将一个数据插入到已经排好序的有序数据中，从而得到一个新的、个数加一的有序数据，算法适用于少量数据的排序，时间复杂度为O(n^2)。

直接插入排序

直接插入排序是一种简单的插入排序法，其基本思想是：把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列。
我们来看一下图解：

这张图虽然只有一步，但是很好的表现了插入排序的运行过程。

例如,已知待排序的一组记录是：

1，3，5，8，2，1
加入之前的1，3，5，8已经按照直接插入排序排序好了，现在我们需要对2进行排序。首先将2存在一个临时变量temp中，然后指针从2的前一位开始判断，如果前一位比2大，则将前一位往后移，以此类推，直到找到比2小的元素。这时将2插入进去。

JAVA代码实现:

public static void StraightInsertSort(int[] a) {
        int temp = 0,j = 0;
        for(int i = 1;i < a.length;i++){
            temp = a[i];
            j = i;
            while(j > 0 && a[j-1] >= temp){
                a[j] = a[j-1];
                j--;
            }
            a[j] = temp;
        }
    }

二分插入排序

将直接插入排序中寻找A[i]的插入位置的方法改为采用折半比较，即可得到折半插入排序算法。
在处理A[i]时，A[0]……A[i-1]已经按关键码值排好序。
所谓折半比较，就是在插入A[i]时，取A[i-1/2]的关键码值与A[i]的关键码值进行比较，
如果A[i]的关键码值小于A[i-1/2]的关键码值，则说明A[i]只能插入A[0]到A[i-1/2]之间，故可以在A[0]到A[i-1/2-1]之间继续使用折半比较；
否则只能插入A[i-1/2]到A[i-1]之间，故可以在A[i-1/2+1]到A[i-1]之间继续使用折半比较。
如此担负，直到最后能够确定插入的位置为止。一般在A[k]和A[r]之间采用折半，其中间结点为A[k+r/2]，经过一次比较即可排除一半记录，把可能插入的区间减小了一半，故称为折半。
执行折半插入排序的前提是文件记录必须按顺序存储。

JAVA代码实现：

public static void binaryInsertSort(int array[],int size)  
    {  
        int i,j,k,temp;  
        for(i=1;i<size;i++)  
        {  
            temp=array[i];  
            if(array[i]<array[0])  
                k=0;  
            else  
                k = binarySearch(array,0,i,temp);  

            for(j=i;j>k;j--)  
            {  
                array[j]=array[j-1];  
            }  
            array[k]=temp;  
            System.out.println(Arrays.toString(array));  
        }  
    }

希尔排序

希尔排序(Shell’s Sort)是插入排序的一种又称“缩小增量排序”（Diminshing Increment Sort），是直接插入排序算法的一种更高效的改进版本。
希尔排序是非稳定排序算法。该方法因D.L.Shell于1959年提出而得名。
希尔排序是把记录按下标的一定增量分组，对每组使用直接插入排序算法排序；随着增量逐渐减少，每组包含的关键词越来越多，当增量减至1时，整个文件恰被分成一组，算法便终止。

下面我们来看图解:

希尔排序意在减少直接排序中的数字移动次数，通过设置一个间隔，每次进行比较的都是间隔的数字。
比如说如图：
第一次的间隔是5，则可以将数字分为5组，每一组两个数字，将这两个数字进行比较，逆序就交换。这样我们第一次排序就完成了。
这时候的数组肯定还是存在许多的逆序对，所以我们需要将间隔缩小，在进行比较。如图，这时候间隔变成了3，也就是可以将4个数字分为一组比较，这时候可以使用直接插入排序的思想，在组内进行直接插入排序比较。只是跨度为间隔数而不是1了。
之后以此类推，直到间隔为1的时候，这时候就直接是直接选择排序了。

关于间隔的选择
这个间隔怎么确定，是个数学难题，至今没有解答。但是通过大量的实验，还是有个经验值。

减小间隔
上面已经演示了以5为初始间隔对包含10个数据项的数组进行排序的情况。对于更大的数组开始的间隔也应该更大。然后间隔不断减小，直到间隔变成1。
举例来说:
含有1000个数据项的数组可能先以364为增量，然后以121为增量，以40为增量，以13为增量，以4为增量，最后以 1为增量进行希尔排序。
用来形成间隔的数列被称为间隔序列。

这里所表示的间隔序列由Knuth提出，此序列是很常用的。
数列以逆向形式从1开始，通过递归表达式
h=3*b+1
来产生，初始值为1。

在排序算法中，首先在一个短小的循环中使用序列的生成公式来计算出最初的间隔。h值最初被赋为1，然后应用公式h=3*h+1生成序列1,4,13,40,121,364，等等。
当间隔大于数组大小的时候，这个过程停止。
对于一个含有1000个数据项的数组，序列的第七个数字，1093就太大了。

因此，使用序列的第六个数字作为最大的数字来开始这个排序过程，作364-增量排序。
然后，每完成一次排序全程的外部循环，用前面提供的此公式倒推式来减小间隔：
h=(h-1)/3

这个倒推的公式生成逆置的序列364,121,40,13,4,1。
从364开始，以每一个数字作为增量进行排序。当数组用1-增量排序后，算法结束。

希尔排序比插入排序快很多，它是基于什么原因呢？
当h值大的时候，数据项每一趟排序需要移动元素的个数很少，但数据项移动的距离很长。
这是非常有效率的。当h减小时，每一趟排序需要移动的元素的个数增多，但是此时数据项已经接近于它们排序后最终的位置，这对于插入排序可以更有效率。正是这两种情况的结合才使希尔排序效率那么高。

注意后期的排序过程不撤销前期排序所做的工作。例如，已经完成了以40-增量的排序的数组，在经过以13-增量的排序后仍然保持了以40-增量的排序的结果。
如果不是这样的话，希尔排序就无法实现排序的目的。

选择间隔序列可以称得上是一种魔法。至此只讨论了用公式h=h*3+1生成间隔序列，但是应用其他间隔序列也取得了不同程序的成功，只是一个绝对的条件，就是逐渐减小的间隔最后一定要等于1，因此最后一趟排序是一次普通的插入排序。

在希尔的原稿中，他建议初始的间距为N/2，简单地把每一趟排序分成了两半。
因此，对于N=100的数组逐渐减小的间隔序列为50,25,12,6,3,1。这个方法的好处是不需要在不开始排序前为找到初始的间隔而计算序列；而只需要用2整除N。
但是，这被证明并不是最好的数列。

尽管对于大多数的数据来说这个方法还是比插入排序效果好，但是这种方法有时会使运行时间降到O(N2)，这并不比插入排序的效率更高。
这个方法的一个变形是用2.2而非2来整除每一个间隔。
对于N=100的数组来说，会产生序列45,20,9,4,1。
这比用2整除显著改善了效果，因为这样避免了某些导致时间复杂度为O(N2)的最坏情况的发生。
不论N为何值，都需要一些额外的代码来保证序列的最后取值为1。

JAVA代码实现:

public static void sort(int[] a) {
        int h = 1;
        while (h < a.length / 3) {
            h = h * 3 + 1;
        }
        int temp = 0, j = 0;
        while (h >= 1) {
            for (int i = h; i < a.length; i++) {
                temp = a[i];
                for (j = i; j >= h && a[j - h] >= temp; j -= h) {
                    a[j] = a[j - h];
                }
                a[j] = temp;
            }
            h = (h - 1) / 3;
        }
    }

几种排序算法的时间比较

这里的稳定性意思是，拿选择排序举例子。
选择排序是给每个位置选择当前元素最小的，比如给第一个位置选择最小的，在剩余元素里面给第二个元素选择第二小的，依次类推，直到第n-1个元素，第n个元素不用选择了，因为只剩下它一个最大的元素了。
那么，在一趟选择，如果一个元素比当前元素小，而该小的元素又出现在一个和当前元素相等的元素后面，那么交换后稳定性就被破坏了。
比较拗口，举个例子，序列5 8 5 2 9，我们知道第一遍选择第1个元素5会和2交换，那么原序列中两个5的相对前后顺序就被破坏了，所以选择排序是一个不稳定的排序算法。