数据结构复习---排序（2）

交换类排序、

1、冒泡排序算法

冒泡排序在众多排序算法中算比较简单的一个，基本思想是重复的进行整个数列的排序，一次比较两个元素(两两排序)，如果它们顺序不符合就交换，重复这样直到数列没有再需要交换的数为止(结束条件)。就好像气泡一样，轻的气泡会往上漂浮，在不断漂浮的过程中，发生了两两交换过程，所以叫冒泡排序。

 //冒泡排序
    public static void bubSort(Comparable[] arr){
        int N=arr.length;
        for(int i=0;i<N-1;i++){
            for (int j = 0; j <N-1-i ; j++) {
                if(!less(arr[j],arr[j+1]))//从小到大排序  前面的比后面的大就这样
                    exch(arr,j,j+1);
            }
        }
    }

2、快速排序

1.概念

快速排序，听这个名字就能想到它排序速度快，它是一种原地排序（只需要一个很小的辅助栈，注意不是数组），且将长度为N的数组排序所需的时间和NlgN成正比

缺点是：非常脆弱，在实现时一定要注意几个小细节（下面详细讲），才能避免错误。

2.基本思想：

随机找出一个数（通常就拿数组第一个数据就行），把它插入一个位置，使得它左边的数都比它小，它右边的数据都比它大，这样就将一个数组分成了两个子数组，然后再按照同样的方法把子数组再分成更小的子数组，直到不能分解为止。    它也是分治思想的一个经典实验（归并排序也是）

3.快速与归并排序的区别：

（1）归并排序将数组分成两个子数组，然后分别排序，并将有序的子数组归并以将整个数组排序；

         快速排序将数组排序的方式是当两个子数组都有序时整个数组也就自然有序了

（2）归并排序的递归调用发生在处理整个数组之前

        快速排序的递归调用发生在处理整个数组之后

4.举例说明

假设我们现在对“6  1  2 7  9  3  4  5 10  8”这个10个数进行排序。首先在这个序列中随便找一个数作为基准数（不要被这个名词吓到了，就是一个用来参照的数，待会你就知道它用来做啥的了）。为了方便，就让第一个数6作为基准数吧。接下来，需要将这个序列中所有比基准数大的数放在6的右边，比基准数小的数放在6的左边，类似下面这种排列。

      3  1  2 5  4  6  9 7  10  8

       在初始状态下，数字6在序列的第1位。我们的目标是将6挪到序列中间的某个位置，假设这个位置是k。现在就需要寻找这个k，并且以第k位为分界点，左边的数都小于等于6，右边的数都大于等于6。想一想，你有办法可以做到这点吗？

       给你一个提示吧。请回忆一下冒泡排序，是如何通过“交换”，一步步让每个数归位的。此时你也可以通过“交换”的方法来达到目的。具体是如何一步步交换呢？怎样交换才既方便又节省时间呢？先别急着往下看，拿出笔来，在纸上画画看。我高中时第一次学习冒泡排序算法的时候，就觉得冒泡排序很浪费时间，每次都只能对相邻的两个数进行比较，这显然太不合理了。于是我就想了一个办法，后来才知道原来这就是“快速排序”，请允许我小小的自恋一下(^o^)。

方法其实很简单：分别从初始序列“6  1  2 7  9  3  4  5 10  8”两端开始“探测”。先从右往左找一个小于6的数，再从左往右找一个大于6的数，然后交换他们。这里可以用两个变量i和j，分别指向序列最左边和最右边。我们为这两个变量起个好听的名字“哨兵i”和“哨兵j”。刚开始的时候让哨兵i指向序列的最左边（即i=1），指向数字6。让哨兵j指向序列的最右边（即j=10），指向数字8。

      首先哨兵j开始出动。因为此处设置的基准数是最左边的数，所以需要让哨兵j先出动，这一点非常重要（请自己想一想为什么）。哨兵j一步一步地向左挪动（即j–），直到找到一个小于6的数停下来。接下来哨兵i再一步一步向右挪动（即i++），直到找到一个数大于6的数停下来。最后哨兵j停在了数字5面前，哨兵i停在了数字7面前。

      现在交换哨兵i和哨兵j所指向的元素的值。交换之后的序列如下。

       6  1  2  5  9 3  4  7  10  8

       到此，第一次交换结束。接下来开始哨兵j继续向左挪动（再友情提醒，每次必须是哨兵j先出发）。他发现了4（比基准数6要小，满足要求）之后停了下来。哨兵i也继续向右挪动的，他发现了9（比基准数6要大，满足要求）之后停了下来。此时再次进行交换，交换之后的序列如下。

       6  1  2 5  4  3  9  7 10  8

       第二次交换结束，“探测”继续。哨兵j继续向左挪动，他发现了3（比基准数6要小，满足要求）之后又停了下来。哨兵i继续向右移动，糟啦！此时哨兵i和哨兵j相遇了，哨兵i和哨兵j都走到3面前。说明此时“探测”结束。我们将基准数6和3进行交换。交换之后的序列如下。

3  1 2  5  4  6  9 7  10  8

、

       到此第一轮“探测”真正结束。此时以基准数6为分界点，6左边的数都小于等于6，6右边的数都大于等于6。回顾一下刚才的过程，其实哨兵j的使命就是要找小于基准数的数，而哨兵i的使命就是要找大于基准数的数，直到i和j碰头为止。

       OK，解释完毕。现在基准数6已经归位，它正好处在序列的第6位。此时我们已经将原来的序列，以6为分界点拆分成了两个序列，左边的序列是“3  1 2  5  4”，右边的序列是“9  7  10  8”。接下来还需要分别处理这两个序列。因为6左边和右边的序列目前都还是很混乱的。不过不要紧，我们已经掌握了方法，接下来只要模拟刚才的方法分别处理6左边和右边的序列即可。现在先来处理6左边的序列现吧。

       左边的序列是“3  1  2 5  4”。请将这个序列以3为基准数进行调整，使得3左边的数都小于等于3，3右边的数都大于等于3。好了开始动笔吧。

       如果你模拟的没有错，调整完毕之后的序列的顺序应该是。

       2  1  3  5  4

       OK，现在3已经归位。接下来需要处理3左边的序列“2 1”和右边的序列“5 4”。对序列“2 1”以2为基准数进行调整，处理完毕之后的序列为“1 2”，到此2已经归位。序列“1”只有一个数，也不需要进行任何处理。至此我们对序列“2 1”已全部处理完毕，得到序列是“1 2”。序列“5 4”的处理也仿照此方法，最后得到的序列如下。

       1  2  3 4  5  6 9  7  10  8

       对于序列“9  7  10  8”也模拟刚才的过程，直到不可拆分出新的子序列为止。最终将会得到这样的序列，如下。

       1  2  3 4  5  6  7  8 9  10

       到此，排序完全结束。细心的同学可能已经发现，快速排序的每一轮处理其实就是将这一轮的基准数归位，直到所有的数都归位为止，排序就结束了。下面上个霸气的图来描述下整个算法的处理过程。

       快速排序之所比较快，因为相比冒泡排序，每次交换是跳跃式的。每次排序的时候设置一个基准点，将小于等于基准点的数全部放到基准点的左边，将大于等于基准点的数全部放到基准点的右边。这样在每次交换的时候就不会像冒泡排序一样每次只能在相邻的数之间进行交换，交换的距离就大的多了。因此总的比较和交换次数就少了，速度自然就提高了。当然在最坏的情况下，仍可能是相邻的两个数进行了交换。因此快速排序的最差时间复杂度和冒泡排序是一样的都是O(N²)，它的平均时间复杂度为O(NlogN)。其实快速排序是基于一种叫做“二分”的思想。

  //对元素进行比较
    private static boolean less1(Comparable v,Comparable w){
        return v.compareTo(w)<=0;
    }

 //快速排序
    public static  void quickSort(Comparable[] a,int left,int right){
        if(left>right)
            return;
        int i=left;
        int j=right;
        Comparable v=a[left];
        while (i!=j){
            //先从右往左开始找  第一个小于等于v的数据
            while(less1(v,a[j])&&(i<j))
                j--;
            //从左往右找 第一个大于等于v的数据
            while(less1(a[i],v)&&(i<j))
                i++;
            if(i<j){
                exch(a,i,j);
            }
        }
        //校准数据
        exch(a,left,i);

        quickSort(a,left,i-1);
        quickSort(a,i+1,right);
    }

归并排序

思想：讲一个数组排序，首先要将（递归的）分成两半分别进行排序，然后将结果归并起来。

原地归并

//归并排序要用的    把两个数组合并成一个数组的方法
    public static void merge(Comparable[] a,int left,int mid,int right){
       int i=left;
       int j=mid+1;
        Comparable[] aux=new Comparable[a.length];
        int t=0;
        while(i<=mid&&j<=right){
            if(less(a[i],a[j])){
                aux[t++]=a[i++];
            }
            else{
                aux[t++]=a[j++];
            }
        }
        while(i<=mid)//将左边剩余元素填充
            aux[t++]=a[i++];
        while(j<=right)//将右边剩余元素填充
            aux[t++]=a[j++];
        t=0;
        while(left<=right)
            a[left++]=aux[t++];
    }

//归并排序
    public static void mergSort(Comparable[] arr,int left,int right){
        if(left<right){
            int mid = (right+left)/2;
           mergSort(arr,left,mid);//左边归并排序，使得左子序列有序
            mergSort(arr,mid+1,right);//右边归并排序，使得右子序列有序
            merge(arr,left,mid,right);//将两个有序子数组合并操作
        }
    }

调用实现

 public static void main(String[] args) {
             Comparable[] sort={1,2,4,3,0,8};
             //insertSort(sort);
             mergSort(sort,0,sort.length-1);
             show(sort);
    }

实验结果

快速排序

参考文章：https://blog.csdn.net/yuehailin/article/details/68961304