八大排序的java实现

排序是计算机内经常进行的一种操作，其目的是将一组“无序”的记录序列调整为“有序”的记录序列。排序分为内部排序和外部排序。若整个排序过程不需要访问外存便能完成，则称此类排序问题为内部排序。反之，若参加排序的记录数量很大，整个序列的排序过程不可能在内存中完成，则称此类排序问题为外部排序。

 冒泡排序

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

   /**
     * 冒泡排序
     * @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);
                }
            }
        }
    }

改进冒泡排序

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

 /**
     * 冒泡排序改进
     * @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值,后移一位
        }
    }

快速排序

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

 /**
     * 快速排序
     * @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;
    }

改进快速排序

基本思想：在本改进算法中,只对长度大于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;
    }

直接插入排序

基本思想：每步将一个待排序的记录，按其顺序码大小插入到前面已经排序的子序列的合适位置（从后向前找到合适位置后），直到全部插入排序完为止。

  /**
     * 直接插入排序
     * @param v
     */
    public void insertSort(View v) {
        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;
        }
    }

希尔排序

基本思想：先将要排序的一组数按某个增量d分成若干组，每组中记录的下标相差d。
对每组中全部元素进行直接插入排序，然后再用一个较小的增量对它进行分组，在每组中再进行直接插入排序。
当增量减到1，进行直接插入排序后，排序完成。

  /**
     * 希尔排序
     * @param v
     */
    public void shellSort(View v) {
        int dk = a.length/2;
        while(dk >= 1){
            ShellInsertSort(a, dk);
            dk = dk/2;
        }
        after.setText(getText(a));
    }
    private void ShellInsertSort(int[] a, int dk) {//类似插入排序，只是插入排序增量是1，这里增量是dk,把1换成dk就可以了
        for (int i = dk; i < a.length; i++) {
            // 待插入元素
            int temp = a[i];
            int j;
            for (j = i - dk; j >= 0 && a[j] > temp; j = j-dk) {
                // 将大于temp的往后移动dk位
                a[j + dk] = a[j];
            }
            a[j + dk] = temp;
        }
    }

简单选择排序

基本思想：在要排序的一组数中，选出最小的一个数与第一个位置的数交换；然后在剩下的数当中再找最小的与第二个位置的数交换，如此循环到倒数第二个数和最后一个数比较为止。

   /**
     * 简单选择排序
     * @param v
     */
    public void selectSort(View v) {
        int min;
        for(int i = 0; i < a.length; i++){
            min = i;
            for(int j = i + 1; j < a.length; j++){//找到最小值下标
                if(a[j] < a[min]){
                   min = j;
                }
            }
            swap(a, i, min);
        }
    }

堆排序 

思想：初始时把要排序的数的序列看作是一棵顺序存储的二叉树，调整它们的存储序，使之成为一个堆，这时堆的根节点的数最大。然后将根节点与堆的最后一个节点交换。然后对前面(n-1)个数重新调整使之成为堆。依此类推，直到只有两个节点的堆，并对它们作交换，最后得到有n个节点的有序序列。从算法描述来看，堆排序需要两个过程，一是建立堆，二是堆顶与堆的最后一个元素交换位置。所以堆排序有两个函数组成。一是建堆的渗透函数，二是反复调用渗透函数实现排序的函数。
 

/**
     * 堆排序
     * @param v
     */
public void heapSort(View v) {
     for (int i = 0; i < a.length; i++) {
         createMaxHeap(a, a.length - 1 - i);
         swap(a, 0, a.length - 1 - i);
     }
 }

public void createMaxHeap(int[] data, int lastIndex) {
        // 从lastIndex处节点（最后一个节点）的父节点开始
        for (int i = (lastIndex - 1) / 2; i >= 0; i--) {
            // 保存当前正在判断的节点
            int k = i;
            // 如果当前k节点的子节点存在
            while (2 * k + 1 <= lastIndex) {
                // biggerIndex总是记录较大节点的值,先赋值为当前节点的左子节点的索引
                int biggerIndex = 2 * k + 1;
                // 若当前节点的右子节点存在
                if (biggerIndex + 1 <= lastIndex) {
                    if (data[biggerIndex] < data[biggerIndex + 1]) {
                        // 若右子节点值比左子节点值大，则biggerIndex记录的是右子节点的索引
                        biggerIndex++;
                    }
                }
                // 如果k节点的值小于其较大的子节点的值
                if (data[k] < data[biggerIndex]) {
                    // 交换两者的值
                    swap(data, k, biggerIndex);
                    // 将biggerIndex赋予k，开始while循环的下一次循环，重新保证k节点的值大于其左右子节点的值
                    k = biggerIndex;
                } else {
                    break;
                }
            }
        }
    }

归并排序

基本思想：归并（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];
        }
    }

基数排序

 基本思想：将所有待比较数值（正整数）统一为同样的数位长度，数位较短的数前面补零。然后，从最低位开始，依次进行一次排序。这样从最低位排序一直到最高位排序完成以后,数列就变成一个有序序列。

 /**
     * 桶排序/基数排序
     * @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++;
                }
            }
        }
    }

时间复杂度：

（1）平方阶(O(n2))排序

• 直接插入
• 直接选择
• 冒泡排序

（2）线性对数阶(O(nlog2n))排序

• 希尔排序
• 堆排序
• 快速排序
• 归并排序

（3）线性阶(O(n))排序

• 基数排序

说明： 
当原表有序或基本有序时，直接插入排序和冒泡排序将大大减少比较次数和移动记录的次数，时间复杂度可降至O（n）； 
而快速排序则相反，当原表基本有序时，将蜕化为冒泡排序，时间复杂度提高为O（n2）； 
原表是否有序，对简单选择排序、堆排序、归并排序和基数排序的时间复杂度影响不大。

稳定性：

排序算法的稳定性：若待排序的序列中，存在多个具有相同关键字的记录，经过排序， 这些记录的相对次序保持不变，则称该算法是稳定的；若经排序后，记录的相对 次序发生了改变，则称该算法是不稳定的。

稳定性的好处：排序算法如果是稳定的，那么从一个键上排序，然后再从另一个键上排序，第一个键排序的结果可以为第二个键排序所用。基数排序就是这样，先按低位排序，逐次按高位排序，低位相同的元素其顺序再高位也相同时是不会改变的。另外，如果排序算法稳定，可以避免多余的比较。

（1）稳定的排序算法

• 直接插入排序
• 冒泡排序
• 归并排序
• 基数排序

（2）不是稳定的排序算法

• 希尔排序
• 简单选择排序
• 堆排序
• 快速排序

排序算法选择：

1）当n较大，则应采用时间复杂度为O(nlog2n)的排序方法：快速排序、堆排序或归并排序。

• 快速排序：是目前基于比较的内部排序中被认为是最好的方法，当待排序的关键字是随机分布时，快速排序的平均时间最短；
• 归并排序：它有一定数量的数据移动，所以我们可能过与插入排序组合，先获得一定长度的序列，然后再合并，在效率上将有所提高。

2） 当n较大，内存空间允许，且要求稳定性 =》归并排序 
3） 当n较小，可采用直接插入或直接选择排序。

• 直接插入排序：当元素分布有序，直接插入排序将大大减少比较次数和移动记录的次数。
• 直接选择排序 ：元素分布有序，如果不要求稳定性，选择直接选择排序

5）一般不使用或不直接使用传统的冒泡排序。 
6）基数排序 
它是一种稳定的排序算法，但有一定的局限性：

• 关键字可分解
• 记录的关键字位数较少，如果密集更好
• 如果是数字时，最好是无符号的，否则将增加相应的映射复杂度，可先将其正负分开排序