简述Java实现快速排序非递归实现 ？

快速排序的非递归实现通常使用栈（Stack）来模拟递归过程。以下是使用Java实现快速排序的非递归版本的基本步骤：

1. 选择一个基准元素（pivot）。
2. 把数组分为两部分，使得左边的元素都比基准元素小，右边的元素都比基准元素大。
3. 对左边和右边的子数组重复以上步骤，直到所有的子数组都被排序。

以下是一个非递归实现的示例代码：

import java.util.Stack;

public class QuickSortNonRecursive {

    public static void quickSort(int[] arr) {
        if (arr == null || arr.length <= 1) {
            return;
        }

        Stack<int[]> stack = new Stack<>();
        int low = 0;
        int high = arr.length - 1;
        stack.push(new int[]{low, high});

        while (!stack.isEmpty()) {
            int[] range = stack.pop();
            low = range[0];
            high = range[1];

            int pivotIndex = partition(arr, low, high);

            if (pivotIndex - 1 > low) {
                stack.push(new int[]{low, pivotIndex - 1});
            }

            if (pivotIndex + 1 < high) {
                stack.push(new int[]{pivotIndex + 1, high});
            }
        }
    }

    private static int partition(int[] arr, int low, int high) {
        int pivot = arr[high];
        int i = low - 1;

        for (int j = low; j < high; j++) {
            if (arr[j] < pivot) {
                i++;
                swap(arr, i, j);
            }
        }

        swap(arr, i + 1, high);
        return i + 1;
    }

    private static void swap(int[] arr, int i, int j) {
        int temp = arr[i];
        arr[i] = arr[j];
        arr[j] = temp;
    }

    public static void main(String[] args) {
        int[] arr = {5, 3, 8, 4, 2};
        quickSort(arr);
        for (int num : arr) {
            System.out.print(num + " ");
        }
    }
}

在这个示例中，我们使用一个栈来存储待处理的子数组范围。开始时，我们把整个数组的范围推入栈中。在每次迭代中，我们从栈中弹出一个范围，对其进行分区操作，然后把得到的两个子数组范围推入栈中。当栈为空时，排序完成。

注意，这个实现使用了Lomuto分区方案。你也可以选择使用Hoare分区方案，但需要对partition方法进行相应的修改。