java之快速排序

1. 快速排序（采用的是一种分治的策略）
   
   1. 先从数列中取出一个数作为基准数。
   2. 分区过程，将比这个数大的数全放到它的右边，小于或等于它的数全放到它的左边。
   3. 再对左右区间重复第二步，直到各区间只有一个数。
2. 实战
   有这样一个数组：

 int arr[]={ 5,7,4,6,3,9,2 }

快速排序是这样的：

就以 0 号位的值 5 作为及基准数。
顺便要虚拟一个临时变量 key 来存放这个基准数 int key =arr[0]。
虚拟一个变量用来存放下一次从左边往右找的起始位置 int left=0;
虚拟一个变量用来存放下一次从右边往左找的起始位置 int right=6;

首先 从右边int right=6开始找第一个 比 5 小的数，发现 6号位的值2 比5小，然后将6号位的值赋给0号位，此时int right=5,int left=0; arr是这样的 
{ 2,7,4,6,3,9,2 }, 
由于6号位的值2已经赋给1号位了，此时6号位需要一个值。那就从arr数组左边int left=0开始找第一个符合值大于5的，发现1号位的值7大于5，此时将1号位的7赋值给6号位，此时int right=5,int left=2;arr是这样的：
{ 2,7,4,6,3,9,7 },
依此类推，从右边int right=5找第一个小于5的值，发现了4号位的值3符合条件，赋值完后，此时int right=3,int left=2;arr是这样的：
{ 2,3,4,6,3,9,7 },
再次从左边找第一个大于5的值，发现3号位的值6符合条件，赋值完后，此时int right=3,int left=4;arr是这样的：
{ 2,3,4,6,6,9,7 },
由于left>right,说明继续找下去，查找的范围已经交叉了，所以没有必要，将key的值赋给3号位，此时arr是这样的
{ 2,3,4,5,6,9,7 }
此时基本的已经分出来了，以 5 为基准 可以看作两部分，分别是
{ 2,3,4 }，{ 6,9,7 }，再次用刚才的方法<这样叫递归>就可以最终顺利得到答案。

1. 代码

    首先虚拟些变量来做事：
    int key = arr[0]
    int left = 0;
    int right = arr.length;
    在什么情况下不用再次查找：
    if(left<right){}
    从右向左找第一个符合条件的数，并且赋值
    while(arr[right]>key&&left<right){
        right--;
    }
    if(left<right){
        arr[left++]=arr[right];
    }
    从左向右找第一个符合条件的数，并且赋值
    while(arr[left]<key&&left<right){
        left--;
    }
    if(left<right){
        arr[right++]=arr[left]
    }
    最后不符合条件left<right,就将赋值
    while(left<right){
        arr[left]=key;
    }

    第一次就分好了，就下来就是再次调用自己。

得写个方法

由于要调用自己，所以写个方法；

private static void quick_sort(int s[], int l, int r)  
    {  
        if (l < r)  
        {         
            int i = l, j = r, x = s[l];  
            while (i < j)  
            {  
                while(i < j && s[j] >= x)
                    j--;    
                if(i < j)   
                    s[i++] = s[j];  

                while(i < j && s[i] < x)
                    i++;    
                if(i < j)   
                    s[j--] = s[i];  
            }  
            s[i] = x;  
            quick_sort(s, l, i - 1); // 递归调用   
            quick_sort(s, i + 1, r); // 递归调用 
        }  
    }