为什么创建堆数组的时间复杂度不是O（log（n！））而不是O（nlogn）？

Question

通过插入函数“ insert（A，n）”在堆中插入新元素需要O（log n）时间（其中n是数组“ A”中的元素数）。插入函数如下：

void insert(int A[], int n)
{
   int temp,i=n;
   cout<<"Enter the element you want to insert";
   cin>>A[n];
   temp=A[n];
   while(i>0 && temp>A[(i-1)/2])
   {
      A[i]=A[(i-1)/2];
      i=(i-1)/2;
   }
   A[i]=temp;
}

insert函数的时间复杂度为O（log n）。

将数组转换为堆数组的函数为：

void create_heap()
{
   int A[50]={10,20,30,25,5,6,7};
   //I have not taken input in array A from user for simplicity.
   int i;
   for(i=1;i<7;i++)
   {
      insert(A,i);
   }
}

假定该函数的时间复杂度为O（nlogn）。

->但是插入函数在每个调用中最多有一个要比较的元素“ i”。也就是说，每次调用的循环运行时间复杂度为O（log i）。

->所以首先是log1，然后是log2，然后是log3，依此类推，直到log6。

->因此，对于数组的n个元素，总时间复杂度为 log2 + log3 + log4 + .... logn

->这将是log（2x3x4x ... xn）= log（n！）

那为什么时间复杂度不是O（log（n！））而是O（nlogn）？

Answer 1

Log（n！）由日志规则的n * logn限制为log（n ^ n）

1*2*3*4*....*n = n!
n*n*n*n*....*n = n^n

显然是n！

那么，当O(nlogn)限制更严格时，为什么要使用O(logn!)？因为nlogn受log（n！）限制，令人惊讶的是，不是吗？

log(1*2*3*4*....*n) = log(1) + log(2) + ... + log(n) 

我们扔掉上半场

log(1*2*3*4*....*n) > log(n/2) + log((n/2) + 1) + log((n/2)+2) + ... + log(n) 
                    > log(n/2) + log(n/2) + ... + log(n/2) 
                    = n/2*log(n/2) = O(nlogn)