算法之常见排序算法-冒泡排序、归并排序、快速排序

引言

    对于编程中琳琅满目的算法，本人向来是不善此道也不精于此的，而提及排序算法，也只是会冒泡排序。还记得当初刚作开发工做面试第一家公司时，面试官便让手写冒泡排序（入职以后才知道，这面试官就是一个冒泡排序"病态"爱好者，逢面试必考冒泡排序-__-）。后来看吴军的一些文章，提到提升效率的关键就是少作事情不作无用功，便对这不起眼的排序算法有了兴趣。恰好今天周末有闲，遂研究一二，与各位道友共享。

    冒泡排序时间之因此效率低，就是由于将全部数都一视同仁不作区分挨个比较，这是最普通的作事方法，因此效率也是最普通的，时间复杂度为N的平方；而归并排序效率高，则是采用了分治的思想，将一个总体分红多个小份，每一个小份排好序以后再互相比较，这样就比冒泡快了很多，时间复杂度为NlogN；快速排序的平均时间复杂度也是NlogN，可是实际的耗费时间会比归并排序快两三倍（固然快排在最坏的状况下时间复杂度仍是N的平方，比归并排序大），它的平均执行时间能比归并更快一些是由于它每次分组时不是随机分组而是相对有序的分组，即先从数组中随机取一个数做为基数，而后将数据移动，使得基数一边的数都比它小，另外一边的数都比它大，再在两边各取一个基数进行相同的移动、分组操做，递归下去，这样每一个细分的小组都在总体的大数组中有个位置，合并时直接按从小到大将各个分组合并起来便可，因此通常状况下会比归并快一些。

    了解了思想以后，再用代码实现相对就会容易不少。此处就再借用一个直观一点的例子来讲明归并与快排两者的区别。假设有1000个学生，想对他们的成绩进行排序。方法1借用归并排序的思想，具体这样作：将这1000我的分红10组，将每组的100人进行排序，排完以后再在各组之间从小到大依次进行比较，最后获得整个的成绩排名。方法2借用快速排序的思想，具体需这样作：将1000我的也是分红10组，可是是按分数段分，0-10分的放在一组，10-20分的放在一组，20-30分的放在一组，依次类推，分完组以后再在各个小组中进行排序，而当你合并各个小组时，只需将其按从小到大的顺序直接合并就行，无需跟方法1同样将各小组中的数据取出来跟其余小组中的数据挨个比较。看到这里，想必各位道友对快排比归并排序还要快一些的缘由就有了解了。

    算法能够理解成作事的技巧或者说套路，咱们对其的理解能够不止于编程，彻底能够推广出去。好比归并的分治法，将一个大事情拆解成多个小事件，解决起来就会方便不少。闲话扯了一大堆，下面就将我本身写的排序给你们贴出来，附带上注释讲解，若是有以前不了解的道友，相信看完以后便会念头通透，原地飞升 >_<。

正文

归并排序

// 归并排序
    public static void mergeSort (int[] arr) {
        // 建一个临时数据来存放数据
        int[] temp = new int[arr.length];
        mergeSort(arr, 0, arr.length - 1, temp);
    }

    private static void mergeSort(int[] arr, int left, int right, int[] temp) {
        if (left < right) { // 若是起始下标跟结束下标差值小于1，则不进行操做
            int mid = (left + right) / 2;
            mergeSort(arr, left, mid, temp); // 分组，将左边分为一组，递归调用进行排序
            mergeSort(arr, mid+1, right, temp); // 将右边分为一组
            merge(arr, left, mid, right, temp); //将左右分组合并
        }
    }

    private static void merge(int[] arr, int left, int mid, int right, int[] temp) {
        int i = left; // 定义左指针
        int j = mid + 1; // 定义右指针
        int t = 0; // 给temp临时数组用的指针
        while (i <= mid && j <= right) { // 设置左右指针的移动边界
            if (arr[i] <= arr[j]) { // 此处是升序，故谁小谁先赋给临时数组
                temp[t++] = arr[i++];
            } else {
                temp[t++] = arr[j++];
            }
        }
        while (i <= mid) { // 若是左边有剩余，则放在temp中
            temp[t++] = arr[i++];
        }
        while (j <= right) { // 若是右边有剩余，依次放入temp中
            temp[t++] = arr[j++];
        }
        t = 0;
        // 此时temp中已是arr数组中下标从left到right之间排好序的数据了，由于temp每次都是从0开始赋值，因此需将排好序的数放回arr的对应位置
        while (left <= right) {
            // 将left到right之间排好序的数据放回arr中，此时left到right之间的数就是最终排好序的数
            arr[left++] = temp[t++];
        }
    }

快速排序

 1 // 快速排序
 2     public static void quickSort (int[] arr, int left, int right) {
 3         // 先将异常状况处理掉
 4         if (arr == null || arr.length < 2) {
 5             return;
 6         }
 7         if (right <= left) {
 8             return;
 9         }
10         if (right - left == 1 && arr[left] <= arr[right]) {
11             return;
12         }
13         // 取第一个数为基准数(基数取哪一个都行，此处是为了方便)
14         int index = arr[left];
15         int i = left + 1; // 左指针
16         int j = right; // 右指针
17         while (i < j && i < right && j > left) { // 设置指针的移动边界
18             while (arr[j] > index && j > left) {j--;} // 找到从右边数第一个比index小的数
19             while (arr[i] < index && i < right) {i++;} // 找到从左边数第一个比index大的数
20             if (i < j) { // 交换这两个数  若是i == j，说明两者定位到了同一个位置，则不用交换；若是i > j，说明两者已经相遇而后背向而行了，也不交换
21                 int temp = arr[i];
22                 arr[i] = arr[j];
23                 arr[j] = temp;
24             }
25         }
26         // 执行完上面循环后，arr已是左边比index小，右边比index大的数组了，只是基准数仍在基准位置left处，需放到它应该在的位置
27         if (j != left && arr[j] != arr[left]) {
28             // j最后停留位置的数，确定是一个小于等于index的值，因此若是不是同一个位置的话，直接将两者调换一下位置便可
29             int temp = arr[j];
30             arr[j] = arr[left];
31             arr[left] = temp;
32         }
33         quickSort(arr, left, j-1); // 将基准数左边排序
34         quickSort(arr, j+1, right); // 将基准数右边排序
35     }

此次的排序算法就到这里，若是有不妥之处，还请道友指正。后面若是遇到有意思的算法题，也会跟道友们分享，下期见！