順序表

初始化
Status InitList(SqList &L)
{
  L.elem=new ElemType[MAXSIZE];
  if(!L.elem) exit(OVERFLOW);
  L.length=0;
  return 0;
}

取值
Status GetElem(SqList L,int i,ElemType &e)
{
  if(i<1 || i>L.length)  return ERROR;
  e=L.elem[i-1];
  return OK;
}

查詢(按值查詢返回序號)
int LocateElem(SqList L,ElemType e)
{
  for
 
(i=0;i<L.length;i++)
    if(L.elem[i]==e)  return i+1;
  return 0;
}

插入
Status ListInsert(SqList &L,int i,ElemType e)
{
  if((i<1)||(i>L.length+1))  return ERROR;
  if(L.length==MAXSIZE)  return ERROR;
  for(j=L.length-1; j>=i-1 ;j++)
     L.elem[j+1]=L.elem[j];
   L.elem[i-1]=e;
   ++L.length
 
;
   return OK;
}

刪除
Status ListDelete(SqList &L,int i)
{
  if((i<1) ||(i>L.length))  return ERROR;
  for(j=i;j<=L.length-1;j++)
    L.elem[j-1]=L.elem[j];
   --L.length;
   return OK;
}

單鏈表

初始化
Status InitList(LinkList &L)
{
  L=new LNode;
  L->next=NULL;
  return OK;
}

取值
Status GetElem(LinkList L,int i,ElemType &
 
e)
{ 
  p=L->next;j=1;
  while(p&&j<i)
  {
   p=p->next;
   ++j;
   }
   if(!p||j>i)return ERROR;
   e=p->data;
   return OK;
}

依值查詢
int *LocateElem(LinkList L,ElemType e)
{
  p=L->next;
  while(p&&p->data!=e)
    p=p->next;
  return p;
}

插入
Status ListInsert(LinkList &L,int i,ElemType e)
{
  p=L;j=0;
  while(p&&(j<i-1))
   { p=p->next;++j;}
  if(!p||j>i-1)  return ERROR;
  s=new LNode;
  s->data=e;
  s->next=p->next;
  p->next=s;
  return OK;
}

刪除
Status ListDelete(LinkList &L,int i)
{ 
  p=L;j=0;
  while((p->next)&&(j<i-1))
    { p=p->next;++j;}
  if(!(p->next) || (j>i-1)) return ERROR;
  q=p->next;
  p->next=q->next;
  delete q;
  return OK;
}

順序棧

初始化
Status InitStack(SqStack &S)
{
  S.base=new SElemType[MAXSIZE];
  if(!S.base) exit(OVERFLOW);
  S.top=S.base;
  S.stacksize=MAXSIZE;
  return OK;
}

入棧
Status Push(SqStack &S,SElemType e)
{
  if(S.top-S.base==S.stacksize) return ERROR;
  *S.top++=e;
  return OK;
}

出棧
Status Pop(SqStack &S,SElemType &e)
{
  if(Stop==S.base) return ERROR;
  e=*--S.top;
  return OK;
}

取棧頂元素
SElemType GetTop(SqStack S)
{
  if(S.top!=S.base)
   return *(S.top-1);
}

鏈棧

初始化
Status InitStack(LinkStack &S)
{
  S=NULL;
  return OK;
}

入棧
Status Push(LinkStack &S,SELemType e)
{
  p=new StackNode;
  p->data=e;
  p->neat=S;
  S=p;
  return OK;
}

出棧
Status Pop(LinkStack &S,SElemType &e)
{
  if(S==NULL) return ERROR;
  e=S->data;
  p=S;
  S=S->next;
  delete p;
  return OK;
}

取棧頂元素
SElemType GetTop(LinkStack S)
{
  if(S!=NULL)
    return S->data;
}

迴圈順序佇列

初始化
Status InitQueue(SqQueue &Q)
{
  Q.base=new QElemType[MAXQSIZE];
  if(!Q.base) exit(OVERFLOW);
  Q.front=Q.rear=0;
  return OK;
}

求迴圈佇列的長度
int QueueLength(SqQueue Q)
{
  return(Q.rear-Q.front+MAXQSIZE)%MAXQSIZE;
}

入隊
Status EnQueue(SqQueue &Q,QElemType e)
{
  if((Q.rear+1)%MAXQSIZE==Q.front)
    return ERROR;
  Q.base[Q.rear]=e;
  Q.rear=(Q.rear+1)%MAXQSIZE;
  return OK;
}

出隊
Status DeQueue(SqQueue &Q,QElemType &e)
{
  if(Q.front==Q.rear) return ERROR;
  e=Q.base[Q.front];
  Q.front=(Q.front+1)%MAXQSIZE;
  return OK;
}

取隊頭元素
SElemType GetHead(SqQueue Q)
{ 
   if(Q.front!=Q.rear)
     return Q.base[Q.front];
}

鏈隊

初始化
Status InitQueue(LinkQueue &Q)
{
  Q.front=Q.rear=new QNode;
  Q.front->next=NULL;
  return OK;
}

入隊
Status EnQueue(LinkQueue &Q,QElemType e)
{
  p=new QNode;
  p->data=e;
  p->next=NULL; 
  Q.rear->next=p;
  Q.rear=p;
  return OK;
}

出隊
Status DeQueue(LinkQueue &Q,QElemType &e)
{
  if(Q.front==Q.rear)  return ERROR;
  p=Q.front->next;
  e=p->data;
  Q.front->next=p->next;
  if(Q.rear==p)  Q.rear=Q.front;
  delete p;
  return OK;
}

取隊頭元素
SElemType GetHead(LinkQueue Q)
{
  if(Q.front!=Q.rear)
    return Q.front->next->data;
}