快速排序

快速排序是比较排序中，较好的，是基于分治策略的排序算法。

对于输入的数组arr[s~e]排序的步骤：
（1）、分解：以arr[s]为基准，将数组分成三段arr[s~i-1]、arr[i]和arr[i+1~e]，使得arr[s~i-1]<=arr[i]<=arr[i+1~e]，下表i在划分过程中确定。
（2）、递归求解：通过递归调用快速排序算法对arr[s~i-1]和arr[i+1~e]进行排序。

---

在排序的过程中需要注意的几点：
（1）、数组下标不能越界
（2）、控制好条件（边界条件我是很难把握，笑哭.jpg）

1、将符合条件的值与基数交换位置。

public static void quick_sort_from_start(int[] arr,int start,int end){ 
        if(start>=end) return;
        //key保存基数，index保存基数被替换后的位置。
        int key = arr[start],index=start;
        //保存数组的始末端
        int tstart=start,tend=end;
        boolean flag = false;
        while(start<end){ 
        //从末端开始找小于基数的数@1
            while((flag=end>start)&&arr[end]>=key) end--;
            if(flag){//end>start找到了符合条件的数，替换
                arr[index]=arr[end];
                index=end;
            }
        //从始端开始大于基数的数@2 
            while((flag=end>start)&&arr[start]<=key) start++;
            if(flag){//end>start找到符合条件的，替换
                arr[index]=arr[start];
                index=start;
            }           
        //index始终同步着基数被更换的索引，结束大的while后
        //数组按规则被划分好
        arr[index]=key;

        quick_sort_from_start(arr,tstart,index-1);
        quick_sort_from_start(arr,index+1,tend);
    }

举个栗子：
index:0 1 2 3 4
arr: 3 2 5 1 4 key=3 index=0 start=0 end=4
1 2 5 1 4 key=3 index=3 start=0 end=3 执行@1段代码后
1 2 5 5 4 key=3 index=3 start=2 end=3 执行@2段代码后
再次执行@1时 end=2,跳出循环，执行arr[index] =key
结果：
1 2 3 5 4 这是第一趟的结果。

对条件的分析：

          while((flag=end>start)&&arr[end]>=key) end--;
            if(flag){
                arr[index]=arr[end];
                index=end;
            }
            while((flag=end>start)&&arr[start]<=key) start++;
            if(flag){
                arr[index]=arr[start];
                index=start;
            }       

在找一个满足条件可以和基数比较的条件要同时满足end>start和arr[start]<=key,跳出while的情况有：
（1）end>start ,arr[start]>key,此时满足替换条件。
（2）end=start,有两种情况，后面的arr[start]<=key也可能arr[start]>key,但是不管是什么情况，index=start=end,因为在找数的过程中index一直在随着start和end更新。这个条件下基数已经将数组划分好。

注意：arr[start]<=不能改写成arr[start]，因为出现重复的数时，while就变成死循环了。比如：key等3,end也等于3，跳出循环，替换，end没变，还是指向3，在和key比的时候又是相同的结果。所以相同的值就不做处理

---

2、两个值交换

public static void quick_sort_excahnge(int[] arr,int start,int end){
        if(start>=end) return;
        //保存基数值
        int key=arr[end];
        //保存始末索引
        int first=start,last=end;
        int temp;
        while(start<end){ 
            //找到比基数大的@1
            while(start<end&&arr[start]<=key)start++;
            //找到比基数小的@2
            while(start<end&&arr[end]>=key) end--;
            if(start<end){//两个交换的数已找到
                temp = arr[start];
                arr[start]=arr[end];
                arr[end]=temp;  
            }
        }
        //end=start结束大while,将key和start或是end替换以划分数组
        temp =arr[end];
        arr[end] = arr[last];
        arr[last] = temp;

        quick_sort_excahnge(arr,first,end-1);
        quick_sort_excahnge(arr,end+1,last);
    }

条件分析：
找出两个数和 1 中相同，但最后划分数组时，选择start或是end都可以，原因如下：
跳出@1循环的条件要么是找到了大于key的值，要么就是end=start,跳出@2循环的条件要么是找到小于key的值，要么end=start;

对于图片中的的条件（1） ：a、刚开始，还没进行交换，arr[start]=arr[end] =key;b、进行了几轮交换，交换之后都是arr[end]>key,所以此时arr[end]=arr[start]>key,最后都不影响结果。
（2）:在判断end>start时结束，无法知道此值的情况，只能按照(1)
来确定
（3）和（4）就很容易看出了。

---

小结：
自己感觉快排蛮简单的，控制条件上，敏感度不强，不能很快地弄清楚边界值的控制，导致需要调试多次才能考虑清楚。
算法除了需要一定的思维，还需要有清晰的边界分析。