八大排序算法详解（2）---交换类排序，归并排序和基数排序

各种排序的稳定性，时间复杂度、空间复杂度、稳定性总结如下图：

 

三、交换类排序 

方法：

• 冒泡排序
• 快速排序

1、冒泡排序

基本思想

在要排序的一组数中，对当前还未排好序的范围内的全部数，自上而下对相邻的两个数依次进行比较和调整，让较大的数往下沉，较小的往上冒。即：每当两相邻的数比较后发现它们的排序与排序要求相反时，就将它们互换。

 

 /**
     * 冒泡排序
     * @param v
     */
    public void bubbleSort(View v) {
        for (int i = 0; i < a.length; i++) {
            for (int j = 0; j < a.length - i - 1; j++) {
                // 每遍历一次都把最大的数沉到最底下去了
                if (a[j] > a[j + 1]) {
                    swap(a, j, j + 1);
                }
            }
        }
    }

复杂度

• 时间复杂度：O（n2）
• 空间复杂度：O（1）

改进的冒泡排序

传统冒泡排序中每一趟排序操作只能找到一个最大值或最小值,我们考虑利用在每趟排序中进行正向和反向两遍冒泡的方法一次可以得到两个最终值(最大者和最小者) , 从而使排序趟数几乎减少了一半。

 /**
     * 冒泡排序改进
     * @param v
     */
    public void bubbleSort2(View v) {
        int low = 0;
        int high= a.length -1; //设置变量的初始值
        int i;
        while (low < high) {
            for (i = low; i < high; i++) //正向冒泡,找到最大者
                if (a[i]> a[i + 1]) {
                    swap(a, i, i + 1);
                }
            --high;//修改high值, 前移一位
            for (i = high; i > low; i--) //反向冒泡,找到最小者
                if (a[i]<a[i-1]) {
                    swap(a, i, i - 1);
                }
            ++low;//修改low值,后移一位
        }
    }

2、快速排序

基本思想

选择一个基准元素,通常选择第一个元素或者最后一个元素,通过一趟扫描，将待排序列分成两部分,一部分比基准元素小,一部分大于等于基准元素,此时基准元素在其排好序后的正确位置,然后再用同样的方法递归地排序划分的两部分。

 /**
     * 快速排序
     * @param
     */
    public void quickSort(View v) {
        quickSort(a, 0 , a.length - 1);
        after.setText(getText(a));
    }

    private  void quickSort(int[] a,int low, int high) {
        if(low < high){ //如果不加这个判断递归会无法退出导致堆栈溢出异常
            int middle = getMiddle(a, low, high);
            quickSort(a, 0, middle-1);  //递归对低子表递归排序
            quickSort(a, middle + 1, high);  //递归对高子表递归排序
        }
    }

    public int getMiddle(int[] a, int low, int high){
        int key = a[low];//基准元素，排序中会空出来一个位置
        while(low < high){
            while(low < high && a[high] >= key){//从high开始找比基准小的，与low换位置
                high--;
            }
            a[low]=a[high];
            while(low < high && a[low] <= key){//从low开始找比基准大,放到之前high空出来的位置上
                low++;
            }
            a[high] = a[low];
        }
        a[low] = key;//此时low=high 是基准元素的位置，也是空出来的那个位置
        return low;
    }

复杂度

快速排序是通常被认为在同数量级（O(nlog2n)）的排序方法中平均性能最好的。但若初始序列按关键码有序或基本有序时，快速排序反而蜕化为冒泡排序。为改进之，通常以“三者取中法”来选取基准记录，即将排序区间的两个端点与中点三个记录关键码居中的调整为支点记录。快速排序是一个不稳定的排序方法。

• 时间复杂度：O（nlog2n）
• 空间复杂度：O（nlog2n）

改进的快速排序

基本思想

在本改进算法中,只对长度大于k的子序列递归调用快速排序,让原序列基本有序，然后再对整个基本有序序列用插入排序算法排序。实践证明，改进后的算法时间复杂度有所降低，且当k取值为 8 左右时,改进算法的性能最佳。

 /**
     * 快速排序改进
     * @param
     */
    public void quickSort2(View v) {
        quickSort2(a, 0, a.length - 1, 8);//先调用改进算法Qsort使之基本有序,k=8
        //再用插入排序对基本有序序列排序
        for(int i = 1; i < a.length; i++){
            int temp = a[i];
            int j;
            for (j = i - 1; j >= 0 && a[j] > temp; j--) {
                // 将大于temp的往后移动一位
                a[j + 1] = a[j];
            }
            a[j + 1] = temp;
        }
    }

    private void quickSort2(int[] a,int low, int high, int k) {
        if(high -low > k) { //长度大于k时递归, k为指定的数
            int pivot = partition(a, low, high); // 调用的Partition算法保持不变
            quickSort2(a, low, pivot - 1, k);
            quickSort2(a, pivot + 1, high, k);
        }
    }

    private int partition(int a[], int low, int high) {
        int privotKey = a[low]; //基准元素
        while(low < high){   //从表的两端交替地向中间扫描
            while(low < high  && a[high] >= privotKey) { 
//从high 所指位置向前搜索，至多到low+1 位置。将比基准元素小的交换到低端
                high--;
            }
            swap(a, low, high);
            while(low < high  && a[low] <= privotKey ) {
                low++;
            }
            swap(a, low, high);
        }
        return low;
    }

四、归并排序

基本思想

归并（Merge）排序法是将两个（或两个以上）有序表合并成一个新的有序表，即把待排序序列分为若干个子序列，每个子序列是有序的。然后再把有序子序列合并为整体有序序列。

 /**
     * 归并排序
     * @param
     */
    public void mergeSort(View v) {
        mergeSort(a, 0 , a.length - 1);
    }

    public void mergeSort(int[] a, int low, int high) {
        int mid = (low + high) / 2;
        if (low < high) {
            // 左边
            mergeSort(a, low, mid);
            // 右边
            mergeSort(a, mid + 1, high);
            // 左右归并
            merge(a, low, mid, high);
        }
    }

    public void merge(int[] a, int low, int mid, int high) {
        int[] temp = new int[high - low + 1];
        int i = low;// 左指针
        int j = mid + 1;// 右指针
        int k = 0;
        // 把较小的数先移到新数组中
        while (i <= mid && j <= high) {
            if (a[i] < a[j]) {
                temp[k++] = a[i++];
            } else {
                temp[k++] = a[j++];
            }
        }
        // 把左边剩余的数移入数组
        while (i <= mid) {
            temp[k++] = a[i++];
        }
        // 把右边边剩余的数移入数组
        while (j <= high) {
            temp[k++] = a[j++];
        }
        // 把新数组中的数覆盖a数组
        for (int k2 = 0; k2 < temp.length; k2++) {
            a[low + k2] = temp[k2];
        }
    }

复杂度

• 时间复杂度：O（nlog2n）
• 空间复杂度：O（n）

五、桶排序/基数排序

算法思想：基数排序又称为“桶子法”，从低位开始将待排序的数按照这一位的值放到相应的编号为0~9的桶中。等到低位排完得到一个子序列，再将这个序列按照次低位的大小进入相应的桶中，一直排到最高位为止，数组排序完成。

算法执行步骤：

(1)遍历序列找出最大的数(为的是确定最大的数是几位数)；

(2)开辟一个与数组大小相同的临时数组tmp；

(3)用一个count数组统计原数组中某一位(从低位向高位统计)相同的数据出现的次数；

(4)用一个start数组计算原数组中某一位(从最低位向最高位计算)相同数据出现的位置；

(5)将桶中数据从小到大用tmp数组收集起来；

(6)重复(3)(4)(5)直到所有位都被统计并计算过，用tmp收集起来；

(7)将tmp数组拷回到原数组中；

 

 /**
     * 桶排序/基数排序
     * @param
     */
    public void radixSort(View v) {
        // 找到最大数，确定要排序几趟
        int max = 0;
        for (int i = 0; i < a.length; i++) {
            if (max < a[i]) {
                max = a[i];
            }
        }
        // 判断位数
        int times = 0;
        while (max > 0)  {
            max = max / 10;
            times++;
        }
        // 建立十个队列
        List<ArrayList> queue = new ArrayList<>();
        for (int i = 0; i < 10; i++) {
            ArrayList queue1 = new ArrayList();
            queue.add(queue1);
        }
        // 进行times次分配和收集
        for (int i = 0; i < times; i++) {
            // 分配
            for (int j = 0; j < a.length; j++) {
                int x = a[j] % (int) Math.pow(10, i + 1) / (int) Math.pow(10, i);
                ArrayList queue2 = queue.get(x);
                queue2.add(a[j]);
                queue.set(x, queue2);
            }
            // 收集
            int count = 0;
            for (int j = 0; j < 10; j++) {
                while (queue.get(j).size() > 0) {
                    ArrayList<Integer> queue3 = queue.get(j);
                    a[count] = queue3.get(0);
                    queue3.remove(0);
                    count++;
                }
            }
        }
    }

复杂度

• 时间复杂度：O（d（n+r））
• 空间复杂度：O（n+r）