Warning: file_get_contents(/data/phpspider/zhask/data//catemap/4/algorithm/11.json): failed to open stream: No such file or directory in /data/phpspider/zhask/libs/function.php on line 167

Warning: Invalid argument supplied for foreach() in /data/phpspider/zhask/libs/tag.function.php on line 1116

Notice: Undefined index: in /data/phpspider/zhask/libs/function.php on line 180

Warning: array_chunk() expects parameter 1 to be array, null given in /data/phpspider/zhask/libs/function.php on line 181
Algorithm 最坏情况快速排序空间复杂性解释_Algorithm_Sorting_Quicksort - Fatal编程技术网

Algorithm 最坏情况快速排序空间复杂性解释

Algorithm 最坏情况快速排序空间复杂性解释,algorithm,sorting,quicksort,Algorithm,Sorting,Quicksort,我想展示快速排序空间复杂性的最坏情况 我在想,Quicksort不使用辅助数组,它只是在分区子程序上创建一些辅助变量,但它只是处理数组中的项。显然,我的结论是,它使用了O(n)空间 但在互联网上搜索时,我发现最坏情况下快速排序的空间复杂度为O(logn) 我只是不明白为什么在最坏的情况下,它比输入阵列占用更少的空间 附言:我在看《算法导论》一书 我已经尝试过的是计算算法上的所有变量声明 QUICKSORT(A, p, r) if p < r q = partitio

我想展示快速排序空间复杂性的最坏情况

我在想,Quicksort不使用辅助数组,它只是在分区子程序上创建一些辅助变量,但它只是处理数组中的项。显然,我的结论是,它使用了O(n)空间

但在互联网上搜索时,我发现最坏情况下快速排序的空间复杂度为O(logn)

我只是不明白为什么在最坏的情况下,它比输入阵列占用更少的空间

附言:我在看《算法导论》一书

我已经尝试过的是计算算法上的所有变量声明

QUICKSORT(A, p, r)
    if p < r
        q = partition(A, p, r)
        QUICKSORT(A, p, q - 1)
        QUICKSORT(A, q + 1, r)


PARTITION(A, p, r)
    x = A[r] // pivot
    i = p - 1
    for j = p to r - 1
        if A[j] <= x
            i = i + 1
            exchange A[i] with A[j]
    exchange A[i + 1] with A[r]
    return i + 1
快速排序(A、p、r) 如果p如果在评估空间复杂度时使用[j],则不计算输入存储,而是计算堆栈深度

在直接快速排序中,分区每次都非常不利,并且只能将子数组减少一个元素。因此,空间复杂度为O(n)!(通常是灾难)


因此,首先在最小的子数组上递归并使用尾部递归是很重要的。这会将最坏情况降低到O(logn)。

如果您实现这样的快速排序,那么最坏情况下的空间复杂度为O(n):

快速排序(A、p、r) 如果p 但真正的快速排序实现从来都不是这样写的。它们是这样写的:

QUICKSORT(A, p, r)
    while p < r
        q = partition(A, p, r)
        if (q-p <= r-q)
            QUICKSORT(A, p, q - 1)
            p = q+1
        else
            QUICKSORT(A, q + 1, r)
            r = q-1
快速排序(A、p、r) p如果(q-p在最坏的情况下,空间复杂度是O(n),而不是O(logn),那就是分区总是不平衡的;例如,一个分区总是大小为k,另一个分区总是大小为n-k,其中k是常数(例如1、2或3),n是每轮递归中要分区的数组的大小


换句话说,在最坏的情况下,在每一轮递归中,总是有一个大小相同的分区,让我看看是否正确。快速排序是O(n lg n),第一个n来自分区子例程,但递归有一个O(lg n)堆栈,这就是为什么它的空间复杂度是O(lg n)由于分区不是递归的,它不会增加堆栈和空间的复杂性?我不知道,听起来我错了。递归需要O(n lgn)时间(n来自分区,lgn来自递归本身),但为什么堆栈是O(lgn)还有?听起来所有算法的空间复杂度都和时间复杂度一样。@LeonardoBenicio:我说过最坏情况下的空间复杂度是O(n)。时间复杂度不能小于空间复杂度,但可以超过空间复杂度。“在较小的部分递归很重要”。我们如何使一个部分变小,另一个部分变大?如何实现分区功能来实现这一点?在实际实现中。不,正如我写的实现中所述,您只需检查哪一部分更小,然后在循环执行另一部分之前在该部分上递归。@cassandrad想象您的输入数组是
[7,1,7,1,7,7]
。您的pivot元素将是
7
1
,因此您将始终得到一个包含2个元素的分区和一个包含5个元素的分区。分区方法并不总是创建(几乎从不创建)两个大小相等的分区。是的,我知道这不是真实世界的快速排序,但我遵循“算法简介”的书(Thomas h.Cormem)。这是我的问题,我认为在这个实现中它会使用O(n)空间,但我在互联网上看到了O(n lg n)。我认为问题是我看到了真正的快速排序的空间消耗,而不是书中的。这就是为什么我无法证明它只使用了O(log n)编辑:看看你的算法,它几乎是一样的。你的算法和我的if是一样的,因为它是一个递归
QUICKSORT(A, p, r)
    while p < r
        q = partition(A, p, r)
        if (q-p <= r-q)
            QUICKSORT(A, p, q - 1)
            p = q+1
        else
            QUICKSORT(A, q + 1, r)
            r = q-1