排序第一记——交换排序(冒泡、快排)

今天开始复习一下排序，其实这个最近都有再捡起来练，毕竟太久远拿起来还挺不容易的。
简单说一下——自己复习排序的时候理解是这样的：基本的排序分为三类：交换排序、选择排序、插入排序。用一张图表示一下：

基本的排序

不得不说，我画的图简直太丑了......
将就看一下吧，大概是这样的。前面的话有点多了，直接进入今天的正题——交换排序。

---

冒泡排序：BubbleSort

冒泡排序应该是最简单的了吧？额，至少我个人觉得应该是最好理解的一种排序。
百度百科的原理：

1.比较相邻的元素。如果第一个比第二个大，就交换他们两个。
2.对每一对相邻元素作同样的工作，从开始第一对到结尾的最后一对。在这一点，最后的元素应该会是最大的数。
3.针对所有的元素重复以上的步骤，除了最后一个。
4.持续每次对越来越少的元素重复上面的步骤，直到没有任何一对数字需要比较。

说起原理来感觉好难懂是吧？？？
其实可以简单去思考：为啥叫冒泡排序呢？
不知道有没有注意过水里的气泡，大的气泡会浮到上面去。冒泡排序也是：每一轮的排序,在这一轮中参与比较的元素中最大的数将会浮到最后。
时间复杂度之类的分析，我写在了备注中~~~
So,直接上代码：
请注意第二层for循环，循环次数会越来越小，简单思考一下就会发现：毕竟每轮过后相对来说最大的数都会排到应该在的地方去，所以如果再多比较那几次也没啥意义~

/**
 * Created by AceCream on 2017/3/19.
 * 冒泡排序BubbleSort（属于交换排序）
 * 时间复杂度： 平均：O(n^2)   最佳：O(n)   最坏：O(n^2)
 * 空间复杂度： O(1)
 * 稳定性： 稳定
 */
public class BubbleSort {

    public static void bubbleSort(int[] values){
        for (int i=0;ivalues[j]){
                    int temp = values[i];
                    values[i] = values[j];
                    values[j] = temp;
                }
            }
        }
    }

    public static void main(String[] args) {
        int value[] = {1,7,5,8,3};
        bubbleSort(value);
        for (int result : value) {
            System.out.print(result+" ");
        }

    }
}

---

快速排序：Quicksort

为啥叫快速排序？因为他比别的排序快啊！当然这是一般情况下，也就是平均情况下，快速排序的时间复杂度是O(nlogn)，这速度真的不要太快！
！！！但是！！！
“快速排序是最快的排序”，这句话是正确的吗？？？
答案是：“不准确！”
因为按照平均速度来说，它确实很快，但是如果“枢纽元”为最大或者最小数字，那这个时候简直就是灾难！对！灾难！它就直接成为了——冒泡排序（Ps：冒泡：“靠！这个锅，我不背！”）
具体这个“枢纽元”是啥？还是从快速排序的原理说起来：

快排原理

原理：

• 确定一个基准值
• 一次循环：从后往前比较，用基准值和最后一个值比较，
• 如果比基准值小的交换位置，如果没有继续比较下一个，
• 直到找到第一个比基准值小的值才交换。
• 找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，
• 如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。
• 直到从前往后的比较索引>从后往前比较的索引，结束第一次循环。
• 此时，对于基准值来说，左右两边就是有序的了。
• 接着分别比较左右两边的序列，重复上述的循环。

行了，看了原理，我相信基本上都懵逼了，我当初也是被快排折磨是不行，找了大量的文档，没看懂。后来自己每一步都在纸上写一遍，终于发现了其精髓所在！
简单来说，快速排序其实是冒泡排序的加强版！从成熟体化身为完全体！至于究极体，还得在其基础上继续优化~~
我们第一次循环中，确定的这个“基准值”，就是上文所述的“枢纽元”。
借用一下百科的图片：

快速排序

这个图挺好，但是“初始”和“一次划分”中间省略了很多步，我来补充一下：想象一下挖坑~
1.首先把第一个值，也就是49作为key值，取出来存坑里
2.从右边开始向左边，依次和key值比较，一旦发现比它小的了也就是27，就把27挖出来，填在它曾经的坑里(第一个位置)。这时候变成了这个样子：

27，38，65，97，76，13，27，49

3.那么这时候，出现了俩27，这第二个27，人已经走了，但是它的坑还在，很尴尬，咋办？我们继续走下一步，从左边开始比较(注意！就不要从第一个开始了，已经比较完了，就从38开始吧)，比较谁？还是依次与key(49)比较，直到发现比key大的数，也就是65，这时候就把65，放到刚刚那个尴尬的坑里，把“坑里的值”更新掉~于是变成了这样：

27，38，65，97，76，13，65，49

然后把最开始挖出来的那个49填坑里

27，38，49，97，76，13，65，49

但是这样就结束第一此划分了吗？并没有，因为从start开始的left值和end开始的right值，还没有碰到一起(left 这之后我们看一下上面的图，以49为中心，分成了两个部分，这里就体现了“分治”的思想。将一个问题，分解成两个小的部分，分别做相同的操作。将两个部分做同样的操作，你想到了什么方式？对！递归！快速排序，体现了算法的两大思想：递归和分治。所以快速排序才这么重要。
这里多说一句，前面说过如果这个"枢纽元"选的不好，那就很尴尬了，比如说，这组数，我第一个值如果不是49而是13呢？那第一次划分后，13放在了最左边，我们再看第二个值，如果第二个值是27呢？以此类推，如果我的这串数字刚开始就比较有序，那么快排反而成为了冒泡啊！时间复杂度变为了N(n^2)，所以说，快速排序并不稳定。
但是！我们不能因为这个就否定它，毕竟在大量的测试中，快速排序的速度是要优与堆排序和shell排序的。

是不是听起来很晕。自己动手（请在纸上）写一遍流程其实就懂得了~~

接下来，直接手敲代码：

/**
 * Created by AceCream on 2017/3/19.
 * 快速排序QuickSort （属于交换排序）
 * 原理：
 * 一次循环：从后往前比较，用基准值和最后一个值比较，
 * 如果比基准值小的交换位置，如果没有继续比较下一个，
 * 直到找到第一个比基准值小的值才交换。
 * 找到这个值之后，又从前往后开始比较，如果有比基准值大的，交换位置，
 * 如果没有继续比较下一个，直到找到第一个比基准值大的值才交换。
 * 直到从前往后的比较索引>从后往前比较的索引，结束第一次循环。
 * 此时，对于基准值来说，左右两边就是有序的了。
 * 接着分别比较左右两边的序列，重复上述的循环。
 *
 * 时间复杂度： 平均：O(nlog2n)   最佳：O(nlog2n)   最坏：O(n^2)
 * 空间复杂度： O(1)
 * 稳定性： 不稳定
 *
 */
public class QuickSort {

    private static void quickSort(int[] value, int start, int end) {
        int left = start;
        int right = end;
        int key = value[start];
        while (left=key){
                right--;
            }
            if (leftstart) quickSort(value,start,left-1);
            if (right