java实现快速排序算法

csdn详细文章解读：http://blog.csdn.net/maoyuanming0806/article/details/78167041

代码：
    public class SortTest {  
      
        /** 
         *title:main 
         *@param args 
         */  
        public static void main(String[] args) {  
              
            /* 
             * 获得随机8个0到99之间数的数组  
             */  
            int[] arr = new int[8];  
            for(int i = 0;i < 8;i++){  
                arr[i] = (int) (Math.random() * 99);  
            }  
              
              
            //排序前的输出  
            for(int a:arr){  
                System.out.print(a+" ");  
            }  
            System.out.println();  
              
            quickSort(arr,0,arr.length - 1);  
            //System.out.println("划分后关键字的位置："+division(arr, 0, arr.length - 1));  
              
            //排序后的输出  
            for(int a:arr){  
                System.out.print(a+" ");  
            }  
              
        }  
          
          
          
        //=======================QUICK SORT=============================================================================  
        //首先对当前需要快速排序的序列进行一次快排，最后基数的左边全是小的，右边全是大的  
        //关键步骤：设置关键字、划分、递归  
        /** 
         * 快速扫描，划分数组 
         *title:division 
         *@param arr 要排序的数组 
         *@param left 左边界，边界指的是扫描指针的起始位置 
         *@param right 右边界 
         *@return 返回本轮扫描后关键字的位置，方便得到子数组的边界位置 
         */  
        public static int division(int[] arr,int left,int right){  
              
            int point = right;      //选取最右边数为关键字  
              
            /* 
             * 这里为了减少语句，就先设置左边扫描起点-1，右边扫描起点+1， 
             * 这里由于选取的是最右边的数为关键字，所以右边扫描就是从right-1开始，所以就不需要再减 
             */  
            int leftPre = left - 1;  
            int rightPre = right;  
              
            //让它一直扫描，进行划分  
            while(true){  
                /* 
                 * 从左往右扫描，比关键字小就继续扫描，若找到了比关键字大的当前 
                 * 扫描就先停下来，等待交换。这也就是把比关键字小的放在关键字左边 
                 */  
                while(leftPre < rightPre && arr[++leftPre] < arr[point]);  
                  
                /* 
                 * 从右往左扫描，比关键字大就继续扫描，若找到了比关键字小的当前 
                 * 扫描就先停下来，等待交换。这也就是把比关键字大的放在关键字右边 
                 */  
                while(leftPre < rightPre && arr[--rightPre] > arr[point]);  
                  
                //当两个扫描停下来了，如果是leftPre >= rightPre则本轮扫描结束，否则就是需要交换位置了  
                if(leftPre >= rightPre){  
                    break;  
                }else{  
                    //如果是等待交换（左扫描找到了比关键字大的或右扫描找到了比关键字小的）那么就交换  
                    int temp = arr[leftPre];  
                    arr[leftPre] = arr[rightPre];  
                    arr[rightPre] = temp;  
                }  
                  
            }  
              
            /* 
             * 本轮扫描划分结束，那么关键字就应该出于中间位置，由于选取的是最右边的数做关键字， 
             * 那么和右边的比关键字大的数组的第一个位置交换即可，也就是和leftPre所在位置的值交换 
             */  
            int temp = arr[leftPre];  
            arr[leftPre] = arr[point];  
            arr[point] = temp;  
              
            //返回本轮划分的划分点，也就是关键字交换后所在的中间位置  
            return leftPre;  
              
        }  
          
          
        /** 
         * 递归完成快速排序：左边界至右边界之间的数 构成子数组，进行子数组的快速排序 
         *title:quickSort 
         *@param arr 需要排序的数组 
         *@param left 当前排序的左边界 
         *@param right 当前排序的右边界 
         */  
        public static void quickSort(int[] arr,int left,int right){  
            //递归划分，完成排序，递归的出口就是当left>=right时，也就时排序完成了  
            if(left >= right){  
                return;  
            }else{  
                int pointPosition = division(arr,left,right);  
                  
                //对划分后关键字左边的数进行排序  
                quickSort(arr, left, pointPosition - 1);  
                  
                //对划分后关键字右边的数进行排序  
                quickSort(arr, pointPosition + 1, right);  
            }     
              
        }  
        //==========================QUICK SORT 完======================================================================================  
    }  



上方代码一次执行结果：
3 30 52 34 98 54 79 50 
3 30 34 50 52 54 79 98 

完美排序