时间复杂度

Q.front=(Q.front+1)% MAX_QUEUE_SIZE ; return OK ;
O(1)
链队列
入队
{p=(QNode *)malloc(sizeof(QNode)) ;
if (!p) return ERROR;
p->data=e ; p->next=NULL ;
Q.rear->next=p ; Q.rear=p ;
return OK;
O(1)
出队
p=Q.front->next ;
*x=p->data ; Q.front->next=p->next ;
if (p==Q.rear) Q.rear=Q.front ; free(p) ;
O(1)
撤销队列
Q.rear=Q.front->next;
free(Q.front);
该算法的时间复杂度为O(n*m)，其中n、m分别是主串和模式串的长度。通常情况下，实际运行过程中，该算法的执行时间近似于O(n+m)。&(j<t.length
{ if ((j==-1)|| (s. str[k]==t.str[j])) { k++ ; j++ ; }
O(cn+tn)；在M的非零元的个数tu和mu*nu等数量级时，其时间复杂度为O（mu*nu）
行逻辑连接的顺序表（稀疏矩阵的压缩存储）
十字链表（稀疏矩阵的压缩存储）
遍历二叉树
先序
if (T) {
VisitElement(T->data);
PreOrderTraverse (T->lchild);
return OK ;
O(n)
链栈
进栈
p=(Stack_Node *)malloc(sizeof(Stack_Node)) ;
if (!p) return ERROR;
p->data=e ; p->next=top->next ;
top->next=p ; /*钩链*/
return OK;
O(1)
出栈
O(n)
合并有序表
Lc=La ; pc=La ; pa=La->next ; pb=Lb->next ;
while (pa!=NULL&& pb!=NULL)
{if(pa->data<pb->data)
{ pc->next=pa ; pc=pa ; pa=pa->next ; }
if(pa->data>pb->data)
Q.ront=Q.rear;
O(n)
串的定长顺序存储
复制
for(i=0;i<=S[0];i++)
T[i]=S[i];
O(n)
S（n）
判空
if(S[0]==0) return TRUE;
else return FALSE;
O(1)
串联接
if (S1[0]+S2[0] <= MAXSTRLEN) { //未截断
（2）{ p–>next=q–>next; free(q); }
O(n)
按值删除
LNode *p=L, *q=L–>next;
while ( q!=NULL&& q–>data!=key)
{ p=q; q=q–>next; }
if (q–>data==key)
{ p->next=q->next; free(q);
if (! S.bottom) return ERROR;
S.top=S.bottom+S. stacksize ;
S. stacksize+=STACKINCREMENT ; *S.top=e; S.top++ ;
O(n)
出栈
if ( S.top== S.bottom )
return ERROR ; S.top-- ; e=*S. top ;
{ col=a.data[p].col ; q=cpot[col] ;
b.data[q].row=a.data[p].col ;
b.data[q].col=a.data[p].row ; b.data[q].value=a.data[p].value ;
++cpot[col] ; /*至关重要!!当本列中*/ }
p ->prior = s;
与表长成正比
结点删除
p->prior->next=p->next;
p->next->prior=p->prior;
free(p);
与表长无关
顺序栈
进栈
S.bottom=(ElemType *)realloc((S. STACKINCREMENT+STACK_SIZE) *sizeof(ElemType)); /*栈满，追加存储空间*/
（2）
q=(LNode )malloc(sizeof(LNode));
q–>data=e;
q–>next=p–>next;p–>next=q;
O(n)
按序号删除
（1）p=L; q=L->next;
while ( p->next!=NULL&& j<i)
{ p=q; q=q–>next; j++; }
return uncut;
O(n)
求子串
if(pos<1||pos>S[0]||len<0||len>S[0]-pos+1)
return ERROR;
for(i=1;i<=len;i++)
Sub[i]=S[pos+i-1]; Sub[0]=len; return OK;
O(n)
串堆分配存储
串联接
for (j=0 ; j<s->length; j++) T->ch[j]=s1->ch[j] ; for (k=s1->length, j=0 ; j<s2->length; k++, j++) T->ch[j]=s1->ch[j] ; free(s1->ch) ;
return ERROR;
Q.Queue_array[Q.rear]=e ;
Q.rear=(Q.rear+1)% MAX_QUEUE_SIZE ; return OK;
O(1)
出队
if (Q.front+1== Q.rear)
return ERROR ;
*x=Q.Queue_array[Q.front] ;
if (L->Elem_array[i]!=x ) i++ ;
else { for ( k=i+1; k< L->length; k++) L->Elem_array[k-1]=L->Elem_array[k];
L->length--; break ; }}
Ecompare=∑pi*i=(n+1)/2；Edelete=∑pi*(n-i)=(n-1)/2；Ecompare+Edelete=n。
if (top->next==NULL )
return ERROR ; p=top->next ; e=p->data ; top->next=p->next ;
free(p) ; return OK ;
O(1)
循环队列
入队
if ((Q.rear+1)%MAX_QUEUE_SIZE== Q.front)
free(s2->ch) ;
O(n)
串的块链存储和线性表存储结构相类似，也可采用链表方式存储串值
串的定位函数（又称为串的模式匹配）
Brute-Force模式匹配（定位）
while(i<=S[0]&&j<=T[0]) if(S[i]==T[j])
{ ++i; ++j; } else { i=i-j+2; j=1; } if(j>T[0]) return i-T[0]; else return 0;
else j=next[j] ;
}
if (j>= t.length) return(k-t.length) ;
else return(-1) ;
O(n+m)
next函数
while (k<t.length)
{ if ((j==0)|| (t.str[k]==t.str[j]))
{ k++ ; j++ ;
{ pc->next=pb ; pc=pb ; pb=pb->next ; }
if(pa->data==pb->data)
{ pc->next=pa ; pc=pa ; pa=pa->next ;
ptr=pb ; pb=pb->next ; free(ptr) ; }
O(m+n)
循环链表：除链表的合并外，其它的操作和单线性链表基本上一致，仅仅需要在单线性链表操作算法基础上作以下简单修改：⑴判断是否是空链表：head->next==head ;⑵判断是否是表尾结点：p->next==head ;