Question

我想计算该函数的复杂度。以下代码从有序列表中消除了冗余元素。

我对其复杂性的回答是，第一个O(n²) = O(n*n)为while“ n”，第二个while为“ n”。

我的答案正确吗？如果没有，如何正确计算复杂度？

liste redondance(liste l){
liste red,p,prev;
if(l==NULL)
   return l;
red=l;
while(red!=NULL){
   p=red->suivant;
   prev=red;
   while(p!=NULL){
       if(p->val==red->val){
           prev->suivant=p->suivant;
           free(p);
           p=prev->suivant;
       }
       else{
           p=p->suivant;
           prev=prev->suivant;
       }
   }
   red=red->suivant;
   }
  return(l);
}

谢谢。

Answer 1

是的，没错。

外循环遍历所有元素，而内循环遍历所有元素，在之后是外循环。

平均而言，内部循环会遍历一半的元素，但这对复杂度没有影响，仍然是O（n²）。

Answer 2

void undup(struct llist* ll)
{
for( ;ll; ll=ll->next) {        //walk the chain
        struct llist **pp,*del;
        for(pp = &ll->next; del = *pp;) {
                // since the list is sorted, duplicates MUST be adjecent.
                // if the next node has a different value, there are no more dups
                // (wrt ll->val) in the rest of the chain
                if (del->val != ll->val) break;
                *pp = del->next;
                free(del);
                }
        }
return;
}

显然，复杂度为O（n）。（内部循环会缩短链，或仅执行一次）

链表的复杂性消除了多余的元素

2 个答案: