快速排序实现之递归与非递归

1、算法思想：

• 快速排序是C.R.A.Hoare于1962年提出的一种划分交换排序。它采用了一种分治的策略，一般称其为分治法(Divide-and-ConquerMethod)。
• 设当前待排序的无序区为R[low..high]，利用分治法可将快速排序的基本思想描述为：
  • 在R[low..high]中任选一个记录做为基准(Pivot)，以此基准将当前无序区划分为左、右两个较小的子区间R[low..pivotpos-1)和R[pivotpos+1..high]，
  • 并使左边子区间中全部记录的关键字均小于等于基准记录(不妨记为pivot)的关键字pivot.key，右边的子区间中全部记录的关键字均大于等于pivot.key，而基准记录pivot则位于正确的位置(pivotpos)上。
  • 经过递归调用快速排序对左、右子区间R[low..pivotpos-1]和R[pivotpos+1..high]快速排序。

---

2、算法实现：

递归实现：

private static void rec_quickSort(int[] a, int start, int end) {
    int index = 0;
    if(start < end) {
        index = partition(a,start,end);
        rec_quickSort(a,start,index-1);
        rec_quickSort(a,index+1,end);
    }
}

private static int partition(int[] a, int start, int end) {
    int pivot = a[start];
    while(start < end) {
        while(start < end && a[end] >= pivot)
            end--;
        a[start] = a[end];
        while(start < end && a[start] <= pivot)
            start++;
        a[end] = a[start];
    }
    a[start] = pivot;
    return start;
}

非递归实现：

private static void nonRec_quickSort(int[] a,int start,int end) {
    LinkedList<Integer> stack = new LinkedList<Integer>();  //用栈模拟
    if(start < end) {
        stack.push(end);
        stack.push(start);
        while(!stack.isEmpty()) {
            int l = stack.pop();
            int r = stack.pop();
            int index = partition(a, l, r);
            if(l < index - 1) {
                stack.push(index-1);
                stack.push(l);
            }
            if(r > index + 1) {
                stack.push(r);
                stack.push(index+1);
            }
        }
    }
}

private static int partition(int[] a, int start, int end) {
    int pivot = a[start];
    while(start < end) {
        while(start < end && a[end] >= pivot)
            end--;
        a[start] = a[end];
        while(start < end && a[start] <= pivot)
            start++;
        a[end] = a[start];
    }
    a[start] = pivot;
    return start;
}

---

3、算法分析：

• 快速排序的时间主要耗费在划分操做上，对长度为k的区间进行划分，共需k-1次关键字的比较。

最坏时间复杂度

• 最坏状况是每次划分选取的基准都是当前无序区中关键字最小(或最大)的记录，划分的结果是基准左边的子区间为空(或右边的子区间为空)，而划分所得的另外一个非空的子区间中记录数目，仅仅比划分前的无序区中记录个数减小一个。
• 所以，快速排序必须作n-1次划分，第i次划分开始时区间长度为n-i+1，所需的比较次数为n-i(1≤i≤n-1)，故总的比较次数达到最大值：Cmax= n(n-1)/2=O(n2)

最好时间复杂度

• 在最好状况下，每次划分所取的基准都是当前无序区的"中值"记录，划分的结果是基准的左、右两个无序子区间的长度大体相等。总的关键字比较次数：0(nlgn)
• 注意：用递归树来分析最好状况下的比较次数更简单。由于每次划分后左、右子区间长度大体相等，故递归树的高度为O(lgn)，而递归树每一层上各结点所对应的划分过程当中所须要的关键字比较次数总和不超过n，故整个排序过程所须要的关键字比较总次数C(n)=O(nlgn)。
• 由于快速排序的记录移动次数不大于比较的次数，因此快速排序的最坏时间复杂度应为0(n2)，最好时间复杂度为O(nlgn)。

空间复杂度

• 快速排序在系统内部须要一个栈来实现递归。若每次划分较为均匀，则其递归树的高度为O(lgn)，故递归后需栈空间为O(lgn)。
• 最坏状况下，递归树的高度为O(n)，所需的栈空间为O(n)。

稳定性

• 快速排序是非稳定的。