Java快速排序

快排

快速排序（Quicksort）是对冒泡排序的一种改进。由 东尼·霍尔(C. A. R. Hoare) 在1962年提出。

在平均状况下，排序 n 个项目要 Ο(n log n) 次比较。在最坏状况下需要 Ο(n2) 次比较(不常见)

特点

通常明显比其他 Ο(n log n) 算法更快，因为它的内部循环（inner loop）可以在大部分的架构上很有效率地被实现出来。快速排序使用分治法（Divide and conquer）策略来把一个串行（list）分为两个子串行（sub-lists），其中一子串的所有数据都比另外一子串的所有数据都要小，然后再按此方法对这两部分数据分别进行快速排序，整个排序过程可以递归进行，以此达到整个数据变成有序序列

思路

1、 从数列中挑出一个元素，称为 “基准”（pivot）
2 、重新排序数列，所有元素比 pivot 值小的摆放在基准前，所有元素比基准值大的摆在基准的后（相同的数可以到任一边）。在这个分区退出之后，该 pivot 就处于数列的中间位置。该部称为分区（partition）操作。
3、 递归地（recursive）把小于 pivot 值元素的子数列和大于 pivot 值元素的子数列排序。 

递归的最底部情形，是数列的大小是零或一，也就是永远都已经被排序好了。虽然一直递归下去，但是这个算法总会退出，因为在每次的迭代（iteration）中，它至少会把一个元素摆到它最后的位置去。

递归方式

static void quicksort(int n[], int left, int right) {

    int dp;

    if (left < right) {

        dp = partition(n, left, right);

        quicksort(n, left, dp - 1);
        quicksort(n, dp + 1, right);
    }
}

static int partition(int n[], int left, int right) {

    int pivot = n[left];

    while (left < right) {

        while (left < right && n[right] >= pivot)

            right--;

        if (left < right)

            n[left++] = n[right];

        while (left < right && n[left] <= pivot)

            left++;

        if (left < right)

            n[right--] = n[left];
    }
    n[left] = pivot;

    return left;
}

static void quicksort(int n[], int left, int right) {

    int dp;

    if (left < right) {

        dp = partition(n, left, right);

        quicksort(n, left, dp - 1);
        quicksort(n, dp + 1, right);
    }
}

static int partition(int n[], int left, int right) {

    int pivot = n[left];

    while (left < right) {

        while (left < right && n[right] >= pivot)

            right--;

        if (left < right)

            n[left++] = n[right];

        while (left < right && n[left] <= pivot)

            left++;

        if (left < right)

            n[right--] = n[left];
    }
    n[left] = pivot;

    return left;
}

非递归方式

// 利用系统的栈stack

public class QuickSortNonRecursion {

 public static void main(String[] args) {

        QuickSortNonRecursion qsnr = new QuickSortNonRecursion();
        int[] array = {0, 2, 11, 121, 18, 99, 3, 5, 101, 22, 9, 100};

        qsnr.quicksort(array);

         for (int i : array) {
              System.out.print(i + "  ");
         }
       }

       public void quicksort(int[] array) {

              if (array == null || array.length == 1) return;

              // 用来存放开始与结束索引
              Stack<Integer> s = new Stack<Integer>();

              // 压栈      
              s.push(0);
              s.push(array.length - 1);

              // 利用循环实现
              while (!s.empty()) {

                     int right = s.pop();
                     int left = s.pop();

                     // 如果最大索引小于等于左边索引，说明结束了
                     if (right <= left) continue;

                     int i = partition(array, left, right);

                     if (left < i - 1) {
                            s.push(left);
                            s.push(i - 1);
                     }

                     if (i + 1 < right) {
                            s.push(i+1);
                            s.push(right);
                     }
              }
       }

       // 找到轴心，进行交换
       public int partition (int[] data, int first, int end) {

              int temp;
              int i=first,j=end;

              if(first < end) {

                     temp=data[i];

                     // 当i = j的时候，则说明扫描完成了
                     while(i < j) {

                            // 从右边向左边扫描找到一个小于temp的元素
                            while(j > i && data[j] > temp) j--;

                            if(i<j) {
                                   // 将该元素赋值给temp
                                   data[i]=data[j];

                                   // 赋值后就应该将i+1指向下一个序号
                                   i++;
                            }       

                            // 然后从左边向右边开始扫描，找到一个大于temp的元素
                            while(i < j && temp > data[i]) i++;

                            if(i < j) {
                                   // 将该元素赋值给temp
                                   data[j] = data[i];

                                   // 赋值后就应该将j-1指向前一个序号
                                   j--;
                            }
                     }
                     // 将轴数据放在i位置中
                     data[i] = temp;
              }
              return i;
       }
}