Java中常见的几种数组排序方法

这篇文章总结一下我学习到的几种常见的数组排序方法

冒泡排序

冒泡排序在我看来是最简单、最基本的排序方法，我们应当将冒泡排序的原理和代码熟记于心。

冒泡排序的原理十分简单：用数组的第一个元素和第二个元素进行比较，将大的放到后面，这个过程称为一次，。然后用第二个和第三个比较，大的放后面，以此类推，直到最后一个元素，这个过程称为一趟。在一趟结束后，最大的元素已经放在最后一位了，然后开始第二趟，第二趟结束后第二大的元素就被放到倒数第二个位置，就这样持续直到所有元素有序为止。那么下面使用代码实现：

  public static void BubbleSort2(int[] A){
         for (int j = 0; j < A.length-1; j++) {//外层循环遍历数组
 ​
             for (int i = 0; i < A.length-1-j;i++) {//里层循环遍历数组控制次数。
                 if (A[i]>A[i+1]) {//判断本元素是否比下一个元素大，如果大，则交换位置
                     int temp=A[i];
                     A[i] = A[i+1];
                     A[i+1]=temp;
                 }
             }
         }
         System.out.println(Arrays.toString(A));
     }

需要注意的是，每一趟运行完之后，下一趟的次数需要减一，因为每一趟都会排好一个元素，而这个元素已经不需要排序了，为了提高效率，我们就不让计算机做无谓的运算了。

选择排序

选择排序的原理和冒泡排序差不多，不过冒泡排序是相邻两个元素比较，以此类推，而选择排序则是使用第一个元素和后面的其他元素挨个比较，将大的放到后面，然后使用第二个元素与后面的元素比较，大的放后面，以此类推最终达到有序。

下面使用代码演示：

 public static void XuanZeSort(int[] A){

        for (int j = 0; j < A.length; j++) {
            for (int i =1+j; i < A.length; i++) {
                if (A[j]>A[i]) {//使用第j个元素与其后的所有元素比较
                    int t=A[i];
                    A[i] = A[j];
                    A[j]=t;
                }
            }
        }
        System.out.println(Arrays.toString(A));
    }

需要注意的是：每个元素只需要与其后的元素进行比较即可，因为前面的元素已将是由小到大排序的了。 

插入排序

插入排序的原理会比较麻烦，他是将第一个元素作为起始数组，不管这个元素是大还是小。然后用第二个元素与这个元素进行比较，如果比起始元素大，则放在起始元素之后，反之放在之前，组成一个有序集合，然后用其他元素跟有序集合中的元素比较，插入到正确的位置，以此类推达到有序。

画图帮助大家更直观的理解：

 可以看到，后续的元素都插入到前面的有序集合中，当所有元素插入到有序集合中时，也就意味着整体都有序了。

下面用代码实现一下：

 public static void charuSort(int[] A) {
        for (int i = 1; i < A.length; i++) {
            int j=i;
            while (j>0&&A[j]<A[j-1]){
                int t = A[j];
                A[j] = A[j-1];
                A[j-1]=t;
                j--;

            }
        }
        System.out.println(Arrays.toString(A));
    }

快速排序

       快速排序是这四种排序中最复杂的，但在处理大量数据的排序时，快速排序却是效率最高的，他的原理很简单：先从一堆数据中挑选出一个基准数，然后将比这个基准数小的数据全部放在基准数的前面，将比他大的放在基准数后面，此时，不管前后，都是无序的，然后再分别在前后两组数据中挑出一个基准数，重复此操作，一直分下去，分成两部分、四部分、八部分。。。直到每一个数据的左边都比他小，右边都比他大，此时整个数组就是有序的了。

为什么快速排序效率高

      为什么快速排序效率会高呢，通俗一点讲，在我们进行不管是插入排序还是冒泡排序的时候，我们总是使用一个数跟其他的数比较，然后依次类推，当这个数进行比较的时候，其他数相当于“闲置”状态，比如第一个数和第二个数比较的时候，第三个数不参与运算，是闲置的。这就达不到效率最大化。而快速排序则做到了让所有的数据都“动起来”，每一个数都与基准数进行比较，刚开始是一个基准数，然后是两个、四个、六个，到最后每个数据旁边都是基准数，这样每个数都与他旁边的数进行比较，没有一个数据是闲置的。这就决定了数据越多，快速排序的效率提高越明显。当然了，这是我的理解，可能不太准确，但是我觉得是可以说明问题的，不然为什么使用更加复杂的代码，效率反而更高呢？

下面使用代码进行演示（代码比较复杂）：

public static void QuickSort(int[] arr, int start,int end ){
        if(start<end){
            int index=getIndex(arr,start,end);//定义getIndex方法传入参数

            QuickSort(arr,start,index-1);//使用递归的方法，对基准数左边部分进行递归

            QuickSort(arr, index+1, end);//对右边部分递归
        }
    }

    private static int getIndex(int[] arr, int start, int end) {
        int i=start;
        int j=end;
        //定义一个基准数
        int x=arr[i];
        while (i<j){
            //从后往前找比他小的数的下标。
            while (i < j&&arr[j]>x) {
                j--;              //如果比他大则向前移动，直到找到小的为止。
            }
            //将找到的数填到上一个数的位置。
            if (i < j) {
                arr[i] = arr[j];
                i++;
            }
            //从前往后找比他大于等于的数的下标。
            while (i < j && arr[i]<= x) {
                i++;
            }
            if (i < j) {
                arr[j] = arr[i];
                j--;
            }
        }

        arr[i]=x;
        return i;

    }

这就是常见的几大排序方法啦，当然了，排序方法有很多，只要能达到排序的目的，无非是有效率上的差异罢了，比如有趣的猴子排序和睡眠排序，虽然效率奇低，但是思想是很有趣的。