迭代式快速排序Java程序

迭代式快速排序是一种排序算法，其时间复杂度为O(nlogn)。与递归式快速排序相比，迭代式快速排序的空间复杂度更低，因为它不需要使用函数调用栈。在大多数情况下，迭代式快速排序比递归式快速排序更快，因为避免了函数调用的开销。

算法步骤

1. 选择一个主元素，将数组分成两部分：小于主元素的部分和大于主元素的部分。
2. 将两部分分别排序，再按顺序合并它们。

代码实现

public static void quickSort(int[] arr, int low, int high) {
    if (arr == null || arr.length == 0) {
        return;
    }

    Stack<Integer> stack = new Stack<>();
    stack.push(low);
    stack.push(high);

    while (!stack.isEmpty()) {
        int end = stack.pop();
        int start = stack.pop();

        int pivotIndex = partition(arr, start, end);

        if (pivotIndex - 1 > start) {
            stack.push(start);
            stack.push(pivotIndex - 1);
        }

        if (pivotIndex + 1 < end) {
            stack.push(pivotIndex + 1);
            stack.push(end);
        }
    }
}

public static int partition(int[] arr, int low, int high) {
    int pivot = arr[low];
    int i = low + 1;
    int j = high;

    while (i <= j) {
        if (arr[i] < pivot) {
            i++;
        } else if (arr[j] > pivot) {
            j--;
        } else if (i <= j) {
            int temp = arr[i];
            arr[i] = arr[j];
            arr[j] = temp;
            i++;
            j--;
        }
    }

    arr[low] = arr[j];
    arr[j] = pivot;

    return j;
}

代码解释

• quickSort()方法是迭代式快速排序的入口，low表示待排序数组的起始位置，high表示待排序数组的结束位置。
• 通过使用一个栈，使算法将递归转换成迭代实现。
• partition()方法实际上实现了快速排序的一部分，即重新排列数组，以便将小于主元素的所有元素移到它的左边，将大于主元素的所有元素移到它的右边，返回主元素的索引。

总结

迭代式快速排序是常见的排序算法之一，它的优点是具有O(nlogn)的时间复杂度和低的空间复杂度。通过使用栈来避免递归调用带来的开销，实现了更高效的算法。