Lintcode 快排递归与非递归实现 464. 整数排序 II java

https://blog.csdn.net/morewindows/article/details/6684558 这个链接是快排讲解很好
以下是AC代码
题目链接：https://www.lintcode.com/problem/sort-integers-ii/description

public class Solution {
    /**
     * @param A: an integer array
     * @return: nothing
     */
    public void sortIntegers2(int[] A) {
        // write your code here
        quicksort(A,0,A.length-1);
    }
    public void quicksort(int[] A,int begin,int end)
    {
        int i = begin;
        int j = end;
        if(i >= j)
        {
            return;
        }
        int keng = A[i];
        while(i < j)
        {
            while(i<j && A[j] > keng)
            {
                j--;
            }
            if(i<j && A[j] <= keng)
            {
                A[i] = A[j];
                i++;
            }
            while(i<j && A[i] < keng)
            {
                i++;
            }
            if(i<j && A[i] >= keng)
            {
                A[j] = A[i];
                j--;
            }
        }
        A[i] = keng;
        quicksort(A,begin,i-1);
        quicksort(A,i+1,end);
    }
}

在AC前出错了几次，1。第一次，递归的时候想当然把begin当成0，end,当成A.length-1,这是错误的，因为在第一次递归进行时候，主函数的end已经不是A.length-1了，已经是quicksort得到的分界点处的索引减1了，所以错误。
2。第二次出错没整明白，附上出错代码，感觉和上面代码没啥差别啊，，， 今天终于搞懂了，对于[5,4,3,2]来说，a[0] = 5 而 a[3] = 2 < keng=5 但是由于循环判断条件 无法执行这个交换的操作，

public class Solution {
    /**
     * @param A: an integer array
     * @return: nothing
     */
    public void sortIntegers2(int[] A) {
        // write your code here
        quicksort(A,0,A.length-1);
    }
    public void quicksort(int[] A,int begin,int end)
    {
        int i = begin;
        int j = end;
        if(i >= j)
        {
            return;
        }
        int keng = A[i];
        while(i < j)
        {
            while(i<j && A[j] > keng)
            {
                j--;
                if(i<j && A[j] <= keng)
                {
                    A[i] = A[j];
                    i++;
                    break;
                }
            }
            while(i<j && A[i] < keng)
            {
                i++;
                if(i<j && A[i] >= keng)
                {
                    A[j] = A[i];
                    j--;
                    break;
                }
            }
        }
        A[i] = keng;
        quicksort(A,begin,i-1);
        quicksort(A,i+1,end-1);
    }
}

---

非递归

以下为AC代码，思路就是将递归实现的代码用栈来实现，这里是用的java的LinkedList来代替栈，用offerFirst方法代替栈的压栈操作（这里我以为offer方法就是压栈操作，其实是不是的，无法AC掉），java的Stack已经弃用，partion过程是一趟快排，得到分界点处的索引值，然后每次讲索引值与左右端点讲数组分成左右两个部分，也就是[left,k-1]和[k+1,right]这两个部分，然后将将这两个数组的端点依次入栈，这样就会一直重复进行这个过程，直到左右两边排好序，那么栈肯定也已经为空，完成排序。

import java.util.*;
public class Solution {
    /**
     * @param A: an integer array
     * @return: nothing
     */
    public void sortIntegers2(int[] A) {
        quicksort(A,0,A.length-1);
    }
    public int partion(int[] A,int low,int high)
    {
        int hole = A[low];
        int i = low;
        int j = high;
        if(low < high)
        {

            while(i < j)
            {
                while(i < j && A[j] >= hole)
                    j--;
                if(i < j && A[j] < hole)
                {
                    A[i] = A[j];
                    i++;
                }
                while(i < j && A[i] <= hole)
                    i++;
                if(i < j && A[i] > hole)
                {
                    A[j] = A[i];
                    j--;
                }
            }
            A[i] = hole;
            return i;
        }
        return -1;
    }
    public void quicksort(int[] A,int low,int high)
    {
        LinkedList<Integer> stack = new LinkedList<>();
        int k = -1;
        if(low < high)
        {
            stack.offerFirst(low);
            stack.offerFirst(high);
            while(stack.size() != 0)
            {
                int right = (int)stack.poll();
                int left = (int)stack.poll();
                k = partion(A,left,right);
                if(k-1 > left)
                {
                    stack.offerFirst(left);
                    stack.offerFirst(k-1);
                }
                if(k+1 < right)
                {
                    stack.offerFirst(k+1);
                    stack.offerFirst(right);
                }
            }
        }
    }
}