[算法入门]快速排序非递归方法（Java实现），大家一起来找茬啊～

基础

总结一下，快速排序的步骤：

1、找到一个key值（就是数组第一个值），先从右到左找，找到一个比它小的值，记录下标。

2、然后从左往右找，找到一个比它大的值，记录下标。

3、交换找到的两个数字。

4、继续，直到从右往左找的数字和从左往右找的数字下标重合。交换key值和重合值。

5、这时key值左边就全是比它小的数字，key值右边全是比它大的数字。

6、以key值为基准，将数组分为两段，左边和右边重新进行以上5步。

所以在程序中每次循环我们需要记录的值有：

1、从右往左找时，比key值大的下标

2、从左往右找时，比key值小的下标

3、key值

4、将数组分段后，每段的最小下标和最大下标。

对于第4点，因为java中有现在堆栈这种数据结构，好了，不选了，就用它来存储。下面直接贴上源代码。

public int[] quickSort_not_recursion(int[] result) {
int i;
int j;
int min;    // Every loop's max index
int max;    // Every loop's minus index
int key;

Stack<Integer> conditions = new Stack<Integer>();   // Record the minus index and the max index
conditions.push(0);
conditions.push(result.length-1);
int temp;

// In every loop will get a left index and right index.
while(!conditions.empty()){
max = conditions.pop();
min = conditions.pop();
key = result[min];
i = min+1;
j = max;

// With this step, the numbers can be divided to 2 sections,
// the left side is smaller than the key value,
// the right side is bigger than the key value.
while(i<j) {
// Get the number's index which is smaller than key
while (key < result[j] && i<j) {
j--;
}

// Get the number's index which is bigger than key
while (key > result[i] && i<j) {
i++;
}

// Swap
temp = result[j];
result[j] = result[i];
result[i] = temp;
}

// Swap the key and i(or j)
if(key>result[i]){
temp = result[min];
result[min] = result[j];
result[j] = temp;
}

// Store the left side minus index and the max index
if(min<i-1){
conditions.push(min);
conditions.push(i-1);
}

// Store the right side minus index and the max index
if(max>i+1){
conditions.push(i+1);
conditions.push(max);
}
}

return result;
}