Question

当我阅读合并排序的空间复杂性时，我得到的空间复杂度为O(n+logn)。当我们考虑递归过程的堆栈帧大小时，计算O(logn)。

但是heapsort也使用递归过程，这是heapify过程。为什么heapsort的空间复杂度为O(1)？

我正在阅读的代码是

```的java

public class HeapSort {
public void buildheap(int array[]){
    int length = array.length;
    int heapsize = length;
    int nonleaf = length / 2 - 1;
    for(int i = nonleaf; i>=0;i--){
        heapify(array,i,heapsize);
    }
}

public void heapify(int array[], int i,int heapsize){
    int smallest = i;
    int left = 2*i+1;
    int right = 2*i+2;
    if(left<heapsize){
        if(array[i]>array[left]){
            smallest = left;
        }
        else smallest = i;
    }
    if(right<heapsize){
        if(array[smallest]>array[right]){
            smallest = right;
        }
    }
    if(smallest != i){
        int temp;
        temp = array[i];
        array[i] = array[smallest];
        array[smallest] = temp;
        heapify(array,smallest,heapsize);
    }
}

public void heapsort(int array[]){
    int heapsize = array.length;
    buildheap(array);

    for(int i=0;i<array.length-1;i++){
        // swap the first and the last
        int temp;
        temp = array[0];
        array[0] = array[heapsize-1];
        array[heapsize-1] = temp;
        // heapify the array
        heapsize = heapsize - 1;
        heapify(array,0,heapsize);
    }   
}

```

Answer 1

您发布的Java代码的空间复杂性不是O(1)，因为它会消耗非常大量的堆栈空间。

然而，这不是实施heapsort的常用方法。 heapify方法中的递归很容易被简单的while循环替换（不引入任何额外的数据结构，如堆栈）。如果这样做，它将在O（1）空间中运行。

Answer 2

heapify()函数可以通过尾递归方式实现。许多函数语言保证尾递归函数使用恒定的堆栈空间。

为什么heapsort的空间复杂性是带有递归堆化过程的“O（1）”？

2 个答案: