用JAVA代码实现快速排序

快速排序是对冒泡排序的一种改进。它和堆排法、希尔法一样效率较高，但稳定性稍差。 
对于小的数组，常用的排序方法效率相差不大，但对于大的数组，用以上的方法进行排序对有好的效率。 
最坏情况的时间复杂度为O(n^2)，最好情况时间复杂度为O(nlogn)。 

它的基本思想是： 
1、通过一躺排序将要排序的数据分割成独立的两部分，其中一部分的所有数据都比另外一部分的所有数据都要小 
2、然后再按次方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列。 
另外 java没指针概念 可以认为是句柄 
假设要排序的数组是A[0]……A[N-1]，首先任意选取一个数据（通常选用第一个数据）作为关键数据，然后将所有比它的数都放到它前面，所有比它大的数都放到它后面，这个过程称为一躺快速排序。一趟快速排序的算法是： 
  1）设置两个变量I、J，排序开始的时候I：=0，J：=N； 
  2）以第一个数组元素作为关键数据，赋值给X，即X：=A[0]； 
  3）从J开始向前搜索，即由后开始向前搜索（J：=J-1），找到第一个小于X的值，两者交换； 
  4）从I开始向后搜索，即由前开始向后搜索（I：=I+1），找到第一个大于X的值，两者交换； 
  5）重复第3、4步，直到I=J；

例如：升序（前小后大）

待排序的数组A的值分别是：（初始关键数据X：=49(将数组分为两部分之前，x值不变)） 
                  A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6]： 
                  49       38      65      97      76      13       27 
开始：x = 49; 
i = 0;从前往后搜索用变量i 
n = 7;数组长度 
j = n;从后往返前搜索用变量J 

1、进行如上所说的第三步：由后向前搜索   j= j-1=6,也就是用x=49与A[6]比较， 
A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6]： 
49       38      65      97      76      13       27 
 X                                               j=j-1=6 
x大于A[6]，交换位置 
进行第一次交换后：  27       38      65      97      76      13       49 

2、进行如上所说的第四步：由前向后搜索  i=i+1=1,也就是用x=49与A[1]比较， 
A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6] 
27       38      65      97      76      13       49 
        i=i+1                                      x 
A[1]大于x,所以不变，所以继续由前向后搜索 i= i+1=2,也就是x=49与A[2]比较， 
A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6] 
27       38      65      97      76      13       49 
i=i+1                                     x 
A[2]大于x，交换位置 
进行第二次交换后：  27       38      49      97      76      13       65 

3、进行如上所说的第三步：由后向前搜索   j= j-1=5,也就是用x=49与A[5]比较， 
A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6]： 
27       38      49      97      76      13       65 
                 X                       j=j-1=5 
x大于A[5]，交换 
进行第三次交换后：  27       38      13      97      76      49       65 

4、进行如上所说的第四步：由前向后搜索i=i+1=3,也就是用x=49与A[3]比较， 
A[0]    A[1]    A[2]    A[3]    A[4]     A[5]    A[6]： 
27       38      13      97      76      49       65 
                        i=i+1=3           x 
A[5]>x,交换 
进行第四次交换后：  27       38      13      49      76      97       65 

5、之后，i=j=4 
此时再执行第三步的时候就发现I=J，从而结束一躺快速排序，那么经过一躺快速排序之后的结果是： 
27       38      13      49      76      97       65，即所以大于49的数全部在49的后面，所以小于49的数全部在49的前面。 
        快速排序就是递归调用此过程——在以49为中点分割这个数据序列，分别对前面一部分和后面一部分进行类似 
的快速排序，从而完成全部数据序列的快速排序，最后把此数据序列变成一个有序的序列，根据这种思想对于上述
数组A的快速排序的全过程如下所示： 
初始状态                       【49    38    65    97    76    13    27】   
进行一次快速排序之后划分为       【27    38    13】   49   【76    97    65】 
分别对前后两部分进行快速排序     【13】   27   【38】 
                             【65】   76   【97】 
                              结束 

我们下面看看通过JAVA代码是如何实现的？

public class Sort
{
    public static void main(String[] args)
    {
        int[] arr = { 49, 38, 65, 97, 76, 13, 27 };
        arrayPrint(arr);
        quickSort(arr, 0, arr.length - 1);
        arrayPrint(arr);
    }

    /**
     * 快速排序逻辑部分
     * @param arr
     * @param low
     * @param high
     */
    public static void quickSort(int[] arr , int low , int high)
    {
        int i = low; //相当于i，左 
        int j = high; //相当于j, 右 

        if (i >= j) // 判断是否到中间了 
            return;

        //确定指针方向的逻辑变量，也就是从左搜索还是向右搜索 
        boolean transfer = true;

        while (i != j)
        {
            if (arr[i] > arr[j])
            {
                //交换数字 
                int temp = arr[i];
                arr[i] = arr[j];
                arr[j] = temp;
                //决定下标移动，还是上标移动 
                transfer = (transfer == true) ? false : true;
            }

            //将指针向前或者向后移动 
            if (transfer)
                j--;
            else
                i++;

            //显示每一次指针移动的数组数字的变化 
            for (int x = 0; x < arr.length; ++x)
            {
                System.out.print(arr[x] + ",");
            }
            System.out.print(" (i,j) = " + "(" + i + "," + j + ")");
            System.out.println("");
        }

        //将数组分开两半，确定每个数字的正确位置 
        i--;
        j++;
        quickSort(arr, low, i);
        quickSort(arr, high, j);
    }

    /**
     * 打印数组
     * @param arr
     */
    public static void arrayPrint(int[] arr)
    {
        System.out.print("[");
        for (int i = 0; i < arr.length; i++)
        {
            if (i != arr.length - 1)
                System.out.print(arr[i] + ",");
            else
                System.out.println(arr[i] + "]");
        }
    }
}