我的Java开发生涯记（21）——Java中排序的那点事

2019.8.15著

今天一个朋友突然问我冒泡排序是什么原理，一时间我还真回答不上来，有点映像，但是不深刻，也不理解。

于是去找度娘，还真让我查出不少东西，看着看着就发现还真不错，找到好几种排序算法，下面我就总结一下。

 

1.希尔排序

原理图如下：

希尔排序不需要大量的辅助空间，和归并排序一样容易实现。希尔排序是基于插入排序的一种算法， 在此算法基础之上增加了一个新的特性，提高了效率。希尔排序的时间复杂度与增量序列的选取有关，Shell算法的性能与所选取的分组长度序列有很大关系。只对特定的待排序记录序列，可以准确地估算关键词的比较次数和对象移动次数。想要弄清关键词比较次数和记录移动次数与增量选择之间的关系，并给出完整的数学分析，今仍然是数学难题。

代码实现：

public static void main(String [] args){
    int[]a={49,38,65,97,76,13,27,49,78,34,12,64,1};
    System.out.println("排序之前：");
    for(int i=0;i<a.length;i++){
        System.out.print(a[i]+" ");
    }
    //希尔排序
    int d=a.length;
    while(true){
        d=d/2;
        for(int x=0;x<d;x++){
            for(int i=x+d;i<a.length;i=i+d){
                int temp=a[i];
                int j;
                for(j=i-d;j>=0&&a[j]>temp;j=j-d){
                    a[j+d]=a[j];
                }
                a[j+d]=temp;
            }
        }
        if(d==1){
            break;
        }
    }
    System.out.println();
    System.out.println("排序之后：");
    for(int i=0;i<a.length;i++){
        System.out.print(a[i]+" ");
    }
}

 

 

2.冒泡排序

原理图如下：

冒泡排序算法的原理如下：

1. 比较相邻的元素。如果第一个比第二个大，就交换他们两个。

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

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

4. 持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

代码实现：

public static void bubbleSort(int []arr) {
    for(int i =1;i<arr.length;i++) { 
        for(int j=0;j<arr.length-i;j++) {
            if(arr[j]>arr[j+1]) {
                 int temp = arr[j];
                 arr[j]=arr[j+1];
                 arr[j+1]=temp;
            }
        }    
    }
}

 

3.插入排序

它的分类包括：直接插入排序，二分插入排序（又称折半插入排序），链表插入排序，希尔排序（又称缩小增量排序）。属于稳定排序的一种（通俗地讲，就是两个相等的数不会交换位置） 。

直接插入排序原理图如下：

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

直接插入排序的算法思路：

（1） 设置监视哨r[0]，将待插入记录的值赋值给r[0]；

（2） 设置开始查找的位置j；

（3） 在数组中进行搜索，搜索中将第j个记录后移，直至r[0].key≥r[j].key为止；

（4） 将r[0]插入r[j+1]的位置上。

 

折半插入排序（二分插入排序）

折半插入排序的算法思想：

算法的基本过程：

（1）计算 0 ~ i-1 的中间点，用 i 索引处的元素与中间值进行比较，如果 i 索引处的元素大，说明要插入的这个元素应该在中间值和刚加入i索引之间，反之，就是在刚开始的位置 到中间值的位置，这样很简单的完成了折半；

（2）在相应的半个范围里面找插入的位置时，不断的用（1）步骤缩小范围，不停的折半，范围依次缩小为 1/2 1/4 1/8 .......快速的确定出第 i 个元素要插在什么地方；

（3）确定位置之后，将整个序列后移，并将元素插入到相应位置。

 

一般来说，插入排序都采用in-place在数组上实现。具体算法描述如下：

⒈ 从第一个元素开始，该元素可以认为已经被排序

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

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

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

⒌ 将新元素插入到下一位置中

⒍ 重复步骤2~5

如果比较操作的代价比交换操作大的话，可以采用二分查找法来减少比较操作的数目。该算法可以认为是插入排序的一个变种，称为二分查找排序。

 

代码实现：

/**
*插入排序
*@paramarr
*@return
*/
private static int[] insertSort(int[]arr){
    if(arr == null || arr.length < 2){
        return arr;
    }
    for(inti=1;i<arr.length;i++){
        for(intj=i;j>0;j--){
            if(arr[j]<arr[j-1]){
                //TODO:
                int temp=arr[j];
                arr[j]=arr[j-1];
                arr[j-1]=temp;
            }else{
                //接下来是无用功
                break;
            }
        }
    }
    return arr;
}
 
/**
*插入排序,上面的todo交换很频繁,增加很多步骤
*二分法
*@paramarr
*@return
*/
private static int[] insertSort(int[]arr){
    if(arr == null || arr.length < 2){
        return arr;
    }
    for(inti=1;i<arr.length;i++){
        int temp = arr[i];
        int indx = 0;
        for(intj=i;j>0;j--){
            if(arr[j]<arr[j-1]){
                //TODO:
                arr[j] = arr[j-1];
                indx = j-1;
            }else{
                //接下来是无用功
                break;
            }
            arr[indx]=temp;
        }
    }
    return arr;
}

 

4.选择排序

选择排序（Selection sort）是一种简单直观的排序算法。它的工作原理是：第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始位置，然后再从剩余的未排序元素中寻找到最小（大）元素，然后放到已排序的序列的末尾。以此类推，直到全部待排序的数据元素的个数为零。选择排序是不稳定的排序方法。

原理图如下：

利用满二叉树的性质，将输入的数据存放到满二叉树的叶节点，通过比较树中剩余可用节点（从底层的叶节点开始）的大小，每次选择最小的数值（比较复制到二叉树的顶端），并且把最小数值赋给排序数组的前端，把最小数值原来叶节点的位置设置为不可用；依次循环直至最后一个可用叶节点。

代码实现：

public static void selectionSort(int[] arr){
    for (int i = 0; i < arr.length - 1; i++) {    
        int  min = i;
        for (int j = i + 1; j < arr.length; j++) {
            if (arr[min] > arr[j]) {
                min = j;
            }
        }
        if (min != i) {
            int tmp = arr[min];
            arr[min] = arr[i];
            arr[i] = tmp;
        }             
    }
}

 

5.堆排序

是指利用堆这种数据结构所设计的一种排序算法。堆是一个近似完全二叉树的结构，并同时满足堆积的性质：即子结点的键值或索引总是小于（或者大于）它的父节点。

原理图如下：

在堆的数据结构中，堆中的最大值总是位于根节点（在优先队列中使用堆的话堆中的最小值位于根节点）。堆中定义以下几种操作：

• 最大堆调整（Max Heapify）：将堆的末端子节点作调整，使得子节点永远小于父节点

• 创建最大堆（Build Max Heap）：将堆中的所有数据重新排序

• 堆排序（HeapSort）：移除位在第一个数据的根节点，并做最大堆调整的递归运算

代码实现：

/**
* 选择排序-堆排序
* @param array 待排序数组
* @return 已排序数组
*/
public static int[] heapSort(int[] array) {
    //这里元素的索引是从0开始的,所以最后一个非叶子结点array.length/2 - 1
    for (int i = array.length / 2 - 1; i >= 0; i--) {  
        adjustHeap(array, i, array.length);  //调整堆
    }
    // 上述逻辑，建堆结束
    // 下面，开始排序逻辑
    for (int j = array.length - 1; j > 0; j--) {
        // 元素交换,作用是去掉大顶堆
        // 把大顶堆的根元素，放到数组的最后；换句话说，就是每一次的堆调整之后，都会有一个元素到达自己的最终位置
        swap(array, 0, j);
        // 元素交换之后，毫无疑问，最后一个元素无需再考虑排序问题了。
        // 接下来我们需要排序的，就是已经去掉了部分元素的堆了，这也是为什么此方法放在循环里的原因
        // 而这里，实质上是自上而下，自左向右进行调整的
        adjustHeap(array, 0, j);
    }
    return array;
}

/**
* 整个堆排序最关键的地方
* @param array 待组堆
* @param i 起始结点
* @param length 堆的长度
*/
public static void adjustHeap(int[] array, int i, int length) {
    // 先把当前元素取出来，因为当前元素可能要一直移动
    int temp = array[i];
    for (int k = 2 * i + 1; k < length; k = 2 * k + 1) {  //2*i+1为左子树i的左子树(因为i是从0开始的),2*k+1为k的左子树
    // 让k先指向子节点中最大的节点
        if (k + 1 < length && array[k] < array[k + 1]) {  //如果有右子树,并且右子树大于左子树
            k++;
        }
        //如果发现结点(左右子结点)大于根结点，则进行值的交换
        if (array[k] > temp) {
            swap(array, i, k);
            // 如果子节点更换了，那么，以子节点为根的子树会受到影响,所以，循环对子节点所在的树继续进行判断
            i = k;  //这一步决定了下一个步骤执行到的是左子树还是右子树
        } else {  //不用交换，直接终止循环
            break;
        }
    }
}

 

排序的方式有很多，这里我就不一一列举了。

 

总结:未知是可怕的，我们面对未知的东西从来都是迷茫，害怕，不愿接触。但是当你真正接触过后才知道，其实并没有你想的那么差，当然也没有那么好，总之干一行爱一行保持积极的心态就好。