//stack.h
#define STACK_INIT_SIZE 100 //存储空间初始量
#define STACK_INCREMENT 10//存储空间初始增量
typedef struct
{
 int r;
 int c;
}PostType;//坐标位置  迷宫的r行c列
typedef struct
{
 int ord;//通道块在路径上的序号
 PostType seat;//通道块的当前坐标位置
 int di;//通道块指向下一通道块的方向
}SElemType;//栈元素的类型
typedef struct
{
 SElemType *base;//栈底指针
 SElemType *top;//栈顶指针
 int stacksize;//栈的最大容量
}Stack;//栈的类型

Status InitStack(Stack &S)//初始化栈
{
 S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
 if(!S.base)
  exit(OVERFLOW);//存储分配失败;
 S.top=S.base;
 S.stacksize=STACK_INIT_SIZE;
 return OK;
}//InitStack

Status StackEmpty(Stack S)
//判断栈是否为空,如果为空返回TRUE,否则返回FALSE
{
 if(S.top==S.base)
  return TRUE;
  return FALSE;
}//StackEmpty

Status Push(Stack &S,SElemType e)
//插入元素为e的栈顶元素
{
 if(S.top-S.base>=S.stacksize)
 {
  S.base=(SElemType*)realloc(S.base,(S.stacksize+STACK_INCREMENT)*sizeof(SElemType));
       if(!S.base)
       exit(OVERFLOW);
    S.top=S.base+S.stacksize;
    S.stacksize+=STACK_INCREMENT;
 }
 *S.top++=e;
 return OK;
}//Push

Status Pop(Stack &S,SElemType &e)
//删除栈顶元素存入e
{
 if(S.top==S.base)
  return ERROR;
 e=*--S.top;
 return OK;
}//Pop

Status DestroyStack(Stack &S)
//销毁栈
{
 free(S.base);
 S.top=S.base;
 return OK;
}//DestroyStack

//maze.cpp
#define MAXLEN 20//迷宫包括外墙最大行列数目
typedef struct{
         int r;
         int c;
         char adr[MAXLEN][MAXLEN];//可取' ''*' '@' '#'
}MazeType;   //迷宫类型

Status InitMaze(MazeType &maze){
//初始化迷宫若成功返回TRUE,否则返回FALSE
         int m,n,i,j,k=1;
         printf("输入迷口的行数和列数: ");
         scanf("%d%d",&maze.r,&maze.c); //迷宫行和列数
         for(i=0;i<=maze.c+1;i++){//迷宫行外墙
                   maze.adr[0][i]='#';
                   maze.adr[maze.r+1][i]='#';
         }//for
         for(i=0;i<=maze.r+1;i++){//迷宫列外墙
                  maze.adr[i][0]='#';
                   maze.adr[i][maze.c+1]='#';
         }
         for(i=1;i<=maze.r;i++)
                   for(j=1;j<=maze.c;j++)
                            maze.adr[i][j]=' ';//初始化迷宫
         printf("输入障碍物%d的坐标(以坐标(0,0)结束输入): ",k);
         scanf("%d%d",&m,&n);//接收障碍的坐标
   k++;
       while(m!=0)
    {
                   if(m>maze.r || n>maze.c)//越界
                        exit(ERROR);
                   maze.adr[m][n]='#';//迷宫障碍用'#'标记
                   printf("输入障碍物%d的坐标(以坐标(0,0)结束输入): ",k);
                   scanf("%d%d",&m,&n);
       k++;
        }
         return OK;
}//InitMaze        

Status Pass(MazeType maze,PostType curpos){
//当前位置可通则返回TURE,否则返回FALSE
         if(maze.adr[curpos.r][curpos.c]==' ')//可通
                   return TRUE;
         else
                   return FALSE;
}//Pass

Status FootPrint(MazeType &maze,PostType curpos){
//若走过并且可通返回TRUE,否则返回FALSE
//在返回之前销毁栈S
         maze.adr[curpos.r][curpos.c]='*';//"*"表示可通
         return OK;
}//FootPrint

PostType NextPos(PostType &curpos,int i){
//指示并返回下一位置的坐标
         PostType cpos;
         cpos=curpos;
         switch(i){        //1.2.3.4分别表示东,南,西,北方向
                   case 1 : cpos.c+=1; break;
                   case 2 : cpos.r+=1; break;
                   case 3 : cpos.c-=1; break;
                   case 4 : cpos.r-=1; break;
                   default: exit(ERROR); 
         }
         return cpos;
}//Nextpos

Status MarkPrint(MazeType &maze,PostType curpos){
//曾走过但不是通路标记并返回OK
         maze.adr[curpos.r][curpos.c]='@';//"@"表示曾走过但不通
         return OK;
}//MarkPrint

void PrintMaze(MazeType &maze)
//将最后标记好的迷宫输出
{
 int i,j;
 printf("\n输出迷宫的路径:\n");
 for(i=0;i<=maze.c+1;i++)
  printf("%4d",i);//输出列数
 printf("\n");
 for(i=0;i<=maze.r+1;i++)
 {
  printf("%d",i);//输出行数
  for(j=0;j<=maze.c+1;j++)
   printf("%4c",maze.adr[i][j]);//输出迷宫
  printf("\n");
 }
}//PrintMaze

Status MazePath(MazeType &maze,PostType start,PostType end)
//若迷宫从入口start到end的通道则求得一条存放在栈中
{
 Stack S;//初始化栈
 PostType curpos;
 int curstep;
 SElemType e;
 InitStack(S);
 curpos=start;
 curstep=1;
 do
 {
  if(Pass(maze,curpos))//当前位置可通过而未曾走过留下足迹
  {
   FootPrint(maze,curpos);
   e.ord=curstep;e.seat=curpos;e.di=1;
   Push(S,e);//加入栈路径中
     if(curpos.r==end.r && curpos.c==end.c)//到达出口返回TRUE
    {
    if(!DestroyStack(S))
    exit(OVERFLOW);
       else return TRUE;
    }
     else
      {
    curpos=NextPos(curpos,1);//下一位置是当前位置
    curstep++;//探索下一步
     }
  }//if
  else//当前位置不能通过
  {
   if(!StackEmpty(S))
   {
    Pop(S,e);//提取前一位置
    while (e.di==4 && !StackEmpty(S))//4个方向都不能通过则留下记号@  提取前一个位置进行判断是否是能通过
    {
     MarkPrint(maze,e.seat);
     Pop(S,e);
    }
    if(e.di<4)//换下一个方向探索  设定当前位置为该新方向上的邻位 
    {
     e.di++;
     Push(S,e);
     curpos=NextPos(e.seat,e.di);
    }
   }//if
  }
 }while(!StackEmpty(S));
 if(!DestroyStack(S))
  exit(ERROR);
 else return FALSE;
}//MazePath

void main()
{
 MazeType maze;
 PostType start,end;
 char c;
 do
 {
  printf("----------找一条迷宫的路径-------------\n");
  if(!InitMaze(maze))
  {
   printf("\n 初始化迷宫失败!!!");
   exit(ERROR);
  }
  do
  {
   printf("\n请输入入口的坐标:");
    scanf("%d%d",&start.r,&start.c);//输入入口坐标
   if(start.r>maze.r || start.c>maze.c)
    printf("\n输入错误,请重新输入入口的坐标!!\n");
   continue;
  }
  while (start.r>maze.r || start.c>maze.c);
  do
  {
   printf("\n请输入出口的坐标:");//输入出口的坐标
   scanf("%d%d",&end.r,&end.c);
   if(end.r>maze.r || end.c>maze.c)
    printf("\n输入错误,请重新输入出口坐标!!\n");
   continue;
  }
  while (end.r>maze.r || end.c>maze.c);
  if(!MazePath(maze,start,end))
   printf("\n不能找到一条路径!!!\n");
  else PrintMaze(maze);//输出迷宫
  printf("是否要继续?(y/n):");
  scanf("%s",&c);
 }
 while (c=='y' || c=='Y');
}//main

#include<stdlib.h>
#include<stdio.h>
#include<malloc.h>
#include<conio.h>
#define ERROR 0
#define OK 1
typedef struct{
  int OccurTime;
  int NType;
}Event;
typedef struct{
 int ArrivalTime;
 int Duration;
}QElemType;
struct LNODE
{
  Event data;
  struct LNODE *next;
};
typedef struct LNODE LNode;
typedef struct LNODE *LinkList;
typedef struct LNODE *EvenList;
typedef struct QNode{
 QElemType elem;
 struct QNode *next;
}QNode,*QueuePtr;
typedef struct
{ QueuePtr front;
  QueuePtr rear;
}LinkQueue;
EvenList ev;
Event en;
LinkQueue q[5];
QElemType customer;
int TotalTime,CustomerNum,CloseTime;

int InitList(EvenList *L)
{
  *L=(LNode *)malloc(sizeof(LNode));
  if(!(*L))   exit(ERROR);
  (*L)->next=NULL;
  return OK;
}
int DelFirst(EvenList *L,Event *e)
{ LNode *pc,*q;
  pc=*L;q=pc->next;
 pc->next=q->next;*e=q->data;return OK;}
int ListEmpty(LNode L)
{LNode *p;
 int j=0;
 p=L.next;
 while(p)
   {j++;break;}
 if(j==0) return 1;
 else return 0;
}
int compare(Event a,Event b)
{ if(a.OccurTime>b.OccurTime) return 1;
  else if(a.OccurTime==b.OccurTime) return 0;
  else return -1;
}
int OrderInsert(EvenList *L,Event e,int (* cmp)(Event ,Event ))
{ LNode *p,*pc;/*把事件插入链表*/
 p=(LNode *)malloc(sizeof(LNode));/*分配空间*/
 if(!p) { printf("not"); return(0);}
 if(ListEmpty(**L))
 { p->data=e;p->next=(*L)->next;(*L)->next=p;}
 else {
   switch(cmp(((*L)->next)->data,e))
  {case -1:pc=(*L)->next;
   while(pc->next!=NULL)
   {
    if((pc->next)->data.OccurTime<=e.OccurTime)
        pc=pc->next;
    else break;
   }
       p->data=e;p->next=pc->next;/*把它接在比它大的前*/
       pc->next=p;break;
     case 0:pc=(*L)->next;/*相等时，接在相等的后面*/
     p->data=e;p->next=pc->next;
     pc->next=p;break;
     case 1:p->data=e;p->next=(*L)->next;
        (*L)->next=p;break;/*小于时，接在最前面*/
 }}
 return 1;
}
void DestroyList(EvenList *L)/*销毁表*/
{LNode *p;
 while(*L)
   {p=(*L)->next;free(*L);*L=p;}
}
int InitQueue(LinkQueue *Q)/*初始化队列*/
{ Q->front=Q->rear=(QueuePtr)malloc(sizeof(QNode));
 if(!Q->front) exit(0);
 (Q->front)->next=NULL;
 return OK;
}
int DestroyQueue(LinkQueue *Q)/*销毁队列*/
{ while(Q->front)
    { Q->rear=Q->front->next;
     free(Q->front);
     Q->front=Q->rear;
    }
 return OK;
}
int EnQueue(LinkQueue *Q,QElemType e)/*插在队最后*/
{QueuePtr p;
 p=(QueuePtr)malloc(sizeof(QNode));
 if(!p) exit(0);
 p->elem=e;p->next=NULL;
 (Q->rear)->next=p;
 Q->rear=p;/*重新设置队尾*/
 return OK;
}
int QueueEmpty(LinkQueue Q)
{ if(Q.front==Q.rear) return OK;
 else return 0;}
int DelQueue(LinkQueue *Q,QElemType *e)/*删除队的第一个元素*/
{QueuePtr p;
 if(QueueEmpty(*Q)) return ERROR;
 p=(Q->front)->next;
 *e=p->elem;
 (Q->front)->next=p->next;
 if(Q->rear==p) Q->rear=Q->front;
 free(p);
 return OK;
}
void GetHead(LinkQueue Q,QElemType *a)
{QNode *p;
 if(Q.front==Q.rear) exit(0);
 p=(Q.front)->next;
 *a=p->elem;
}
int QueueLength(LinkQueue Q)/*队的长度*/
{ int i=0;
 QNode *pc;
 if(Q.front==Q.rear) return 0;
 pc=Q.front;
 while(pc->next)
 {i++;pc=pc->next;}
 return i;
}
int Mininum(LinkQueue *Q)/*求长度最短的队*/
{ int a[4],e,j,i;
  for(i=1;i<=4;i++)
      a[i-1]=QueueLength(Q[i]);
  e=a[0];j=1;
  for(i=1;i<=3;i++)
      if(e>a[i]) {e=a[i];j=i+1;}
  return j;
}
void OpenForDay()/*初始化操作*/
{ int i;
  TotalTime=0;CustomerNum=0;/*初始化累计时间和客户数*/
  InitList(&ev);
  en.OccurTime=0;en.NType=0;/*设定第一个客户到达事件*/
  OrderInsert(&ev,en,compare);/*把它插入事件表*/
  for(i=1;i<=4;i++) InitQueue(&q[i]);/*置空队列*/
}
void Random(int *a,int *b)/*生成随机数，a为每个客户办理时间在30分钟内，
                           b 为两相隔客户到达的间隔时间不超过5分钟*/
{ *a=0+rand()%30;*b=0+rand()%5;}
void CustomerArrived()/*处理客户到达事件*/
{int durtime,intertime,t,i,b;
 ++CustomerNum;/*记录客户数*/
 Random(&durtime,&intertime);
 b=en.OccurTime;
 t=en.OccurTime+intertime;/*下一客户到达时刻*/
 if(t<CloseTime)
    {en.OccurTime=t;en.NType=0; 
     OrderInsert(&ev,en,compare);
    }
 i=Mininum(q);/*求队列最短*/
 customer.ArrivalTime=b;customer.Duration=durtime;/*为要插入队的客户设置到达时间和办理所需时间*/
 EnQueue(&q[i],customer);
 if(QueueLength(q[i])==1)
     {en.OccurTime=b+durtime;en.NType=i;
      OrderInsert(&ev,en,compare);/*设定第i 个离开事件并插入事件表*/
      }
}
void CustomerDeparture()/*处理客户离开事件*/
{int i;
 i=en.NType;DelQueue(&q[i],&customer);/*删除第i队列的排头客户*/
 TotalTime+=en.OccurTime-customer.ArrivalTime;/*累计客户逗留时间*/
 if(!QueueEmpty(q[i]))/*设定第i队列的一个将要离开事件并插入事件表*/
    { GetHead(q[i],&customer);/*得到它的资料*/
     en.OccurTime+=customer.Duration;en.NType=i;
     OrderInsert(&ev,en,compare);
     }
}
void Bank_Simulation()
{
 OpenForDay();/*初始化*/
 while(!ListEmpty(*ev))/*非空时，删掉表里的第一个*/
   { DelFirst(&ev,&en);
     if(en.NType==0)
  CustomerArrived();/*是客户还没办理的，就处理到达事件*/
     else CustomerDeparture();/*否则处理离开事件*/
   }
 printf("The Average Time is %.2f\n",(float)TotalTime/CustomerNum);
}
void main()
{scanf("%d",&CloseTime);/*输入关门时间*/
 Bank_Simulation();
 getch();
}

以下是栈的一些基本操作：

#define STACK_INIT_SIZE 10

#define STACKINCREMENT 2

typedef struct

{

  SElemType *base;

  SElemType *top;

  int stacksize;

} Sqstack;

int InitStack(Sqstack &S)

{

  if(!(S.base=(SElemType*)malloc(STACK_INIT_SIZE*sizeof(SElemType))))

         exit(OVERFLOW);

  S.top=S.base;

  S.stacksize=STACK_INIT_SIZE;

  return OK;

}

int DestroyStack(Sqstack &S)

{

  free(S.base);

  S.base=NULL;

  S.top=NULL;

  S.stacksize=0;

  return OK;

}

int ClearStack(Sqstack &S)

{

  S.top=S.base;

  return OK;

}

int StackEmpty(Sqstack S)

{

  if(S.top==S.base)

  return TRUE;

  else

  return FALSE;

}

int StackLength(Sqstack S)

{

  return S.top-S.base;

}

int GetTop(Sqstack S,SElemType &e)

{

  if(S.top>S.base)

  {

    e=*(S.top-1);

    return OK;

  }

  else

  return ERROR;

}

int Push(Sqstack &S,SElemType e)

{

  if(S.top-S.base>=S.stacksize)

  {

    S.base=(SElemType*)realloc(S.base,(S.stacksize+STACKINCREMENT)*sizeof(SElemType));

    if(!S.base)

    exit(OVERFLOW);

    S.top=S.base+S.stacksize;

    S.stacksize+=STACKINCREMENT;

  }

  *(S.top)++=e;

  return OK;

}

int Pop(Sqstack &S,SElemType &e)

{

  if(S.top==S.base)

  return FALSE;

  e=*--S.top;

  return OK;

}

int StackTraverse(Sqstack &S,SElemType (*visit)(SElemType))

{

  while(S.top>S.base)

    visit(*S.base++);

    return OK;

}

1．数制转换:

将一个十进制转换成八，十六进制数。

typedef int SElemType; // 定义栈元素类型为整型

 #include"c1.h"

 //#include"c3-1.h" // 采用顺序栈

 #include"c2.cpp" // 利用顺序栈的基本操作

 /*void conversion()

 { // 对于输入的任意一个非负10进制整数，打印输出与其等值的16进制数

   SqStack s;

   unsigned n; // 非负整数

   SElemType e;

   InitStack(s); // 初始化栈

   printf("n(>=0)=");

   scanf("%u",&n); // 输入非负十进制整数n

   while(n) // 当n不等于0

   {

     Push(s,n%16); // 入栈n除以16的余数(16进制的低位)

     n=n/16;

   }

   while(!StackEmpty(s)) // 当栈不空

   {

     Pop(s,e); // 弹出栈顶元素且赋值给e

     if(e<=9)

       printf("%d",e);

     else

       printf("%c",e+55);

   }

   printf("\n");

 }*/

 void conversion()

{

  Sqstack S;

  unsigned N;

  SElemType e;

  InitStack(S);

  scanf("%u",&N);

  while(N)

  {

    Push(S,N%8);

    N=N/8;

  }

  while(!StackEmpty(S))

  {

    Pop(S,e);

    printf("%d",e);

  }

}

 void main()

 {

   conversion();

 }

2.括号配对的检验:

typedef char SElemType;

#include"c1.h"

#include"c2.cpp"

void matching()

{

  Sqstack S;

  InitStack(S);

  char *p,a[100],e;

  int state;

  printf("请输入一组符号(仅只能含有三种{},(),[]):");

  gets(a);

  p=a;

  state=1;

  while(*p && state)

  {

         if(!(*p=='{' || *p=='}' || *p=='[' || *p==']' || *p=='(' || *p==')'))

         {

                printf("输入不正确!");

                exit(ERROR);

         }

    switch (*p)

       {

       case '(':

          case '{':

       case '[':{

          Push(S,*p++);

             break;

                            }

       case ')':{

                GetTop(S,e);

          if(!StackEmpty(S) && e=='(')

                {

               Pop(S,e);

                     p++;

                }

               else

                   state=0;

             break;

                            }

       case ']':{

                 GetTop(S,e);

          if(!StackEmpty(S) && e=='[')

                {

                Pop(S,e);

                   p++;

                }

             else

                state=0;

            break;

                            }

                 case '}':{

                 GetTop(S,e);

          if(!StackEmpty(S) && e=='{')

                {

                Pop(S,e);

                   p++;

                }

             else

                state=0;

            break;

                            }

       }

  }

  if(StackEmpty(S) && state)

         printf("输入的括号相符合!");

  else

        printf("输入的括号不符合!");

}

/*void check()

 { // 对于输入的任意一个字符串，检验括号是否配对

   Sqstack s;

   SElemType ch[80],*p,e;

   if(InitStack(s)) // 初始化栈成功

   {

     printf("请输入表达式\n");

     gets(ch);

     p=ch;

     while(*p) // 没到串尾

       switch(*p)

       {

         case '(':

         case '[':Push(s,*p++);

                  break; // 左括号入栈，且p++

         case ')':

         case ']':if(!StackEmpty(s)) // 栈不空

                  {

                    Pop(s,e); // 弹出栈顶元素

                    if(*p==')'&&e!='('||*p==']'&&e!='[') // 弹出的栈顶元素与*p不配对

                    {

                      printf("左右括号不配对\n");

                      exit(ERROR);

                    }

                    else

                    {

                      p++;

                      break; // 跳出switch语句

                    }

                  }

                  else // 栈空

                  {

                    printf("缺乏左括号\n");

                    exit(ERROR);

                  }

         default: p++; // 其它字符不处理，指针向后移

       }

     if(StackEmpty(s)) // 字符串结束时栈空

       printf("括号匹配\n");

     else

       printf("缺乏右括号\n");

   }

 }*/

void main()

{

       //char a[]={[(]])]};

       matching();

   //check();

}

 Status DestroyList(DuLinkList &L)
 { // 操作结果：销毁双向循环链表L
   DuLinkList q,p=L->next; // p指向第一个结点
   while(p!=L) // p没到表头
   {
     q=p->next;
     free(p);
     p=q;
   }
   free(L);
   L=NULL;
   return OK;
 }

 Status ClearList(DuLinkList L) // 不改变L
 { // 初始条件：L已存在。操作结果：将L重置为空表
   DuLinkList q,p=L->next; // p指向第一个结点
   while(p!=L) // p没到表头
   {
     q=p->next;
     free(p);
     p=q;
   }
   L->next=L->prior=L; // 头结点的两个指针域均指向自身
   return OK;
 }

 Status ListEmpty(DuLinkList L)
 { // 初始条件：线性表L已存在。操作结果：若L为空表，则返回TRUE，否则返回FALSE
   if(L->next==L&&L->prior==L)
     return TRUE;
   else
     return FALSE;
 }

 int ListLength(DuLinkList L)
 { // 初始条件：L已存在。操作结果：返回L中数据元素个数
   int i=0;
   DuLinkList p=L->next; // p指向第一个结点
   while(p!=L) // p没到表头
   {
     i++;
     p=p->next;
   }
   return i;
 }

 Status GetElem(DuLinkList L,int i,ElemType &e)
 { // 当第i个元素存在时,其值赋给e并返回OK,否则返回ERROR
   int j=1; // j为计数器
   DuLinkList p=L->next; // p指向第一个结点
   while(p!=L&&j<i) // 顺指针向后查找,直到p指向第i个元素或p指向头结点
   {
     p=p->next;
     j++;
   }
   if(p==L||j>i) // 第i个元素不存在
     return ERROR;
   e=p->data; // 取第i个元素
   return OK;
 }

 int LocateElem(DuLinkList L,ElemType e,Status(*compare)(ElemType,ElemType))
 { // 初始条件：L已存在，compare()是数据元素判定函数
   // 操作结果：返回L中第1个与e满足关系compare()的数据元素的位序。
   //           若这样的数据元素不存在，则返回值为0
   int i=0;
   DuLinkList p=L->next; // p指向第1个元素
   while(p!=L)
   {
     i++;
     if(compare(p->data,e)) // 找到这样的数据元素
       return i;
     p=p->next;
   }
   return 0;
 }

 Status PriorElem(DuLinkList L,ElemType cur_e,ElemType &pre_e)
 { // 操作结果：若cur_e是L的数据元素，且不是第一个，则用pre_e返回它的前驱，
   //           前驱，否则操作失败，pre_e无定义
   DuLinkList p=L->next->next; // p指向第2个元素
   while(p!=L) // p没到表头
   {
     if(p->data==cur_e)
     {
       pre_e=p->prior->data;
       return TRUE;
     }
     p=p->next;
   }
   return FALSE;
 }

 Status NextElem(DuLinkList L,ElemType cur_e,ElemType &next_e)
 { // 操作结果：若cur_e是L的数据元素，且不是最后一个，则用next_e返回它的后继，
   //           否则操作失败，next_e无定义
   DuLinkList p=L->next->next; // p指向第2个元素
   while(p!=L) // p没到表头
   {
     if(p->prior->data==cur_e)
     {
       next_e=p->data;
       return TRUE;
     }
     p=p->next;
   }
   return FALSE;
 }

 DuLinkList GetElemP(DuLinkList L,int i) // 另加
 { // 在双向链表L中返回第i个元素的位置指针(算法2.18、2.19要调用的函数)
   int j;
   DuLinkList p=L;
   for(j=1;j<=i;j++)
     p=p->next;
   return p;
 }

 Status ListInsert(DuLinkList L,int i,ElemType e) // 改进算法2.18
 { // 在带头结点的双链循环线性表L中第i个位置之前插入元素e，i的合法值为1≤i≤表长+1
   DuLinkList p,s;
   if(i<1||i>ListLength(L)+1) // i值不合法
     return ERROR;
   p=GetElemP(L,i-1); // 在L中确定第i-1个元素的位置指针p
   if(!p) // p=NULL,即第i-1个元素不存在
     return ERROR;
   s=(DuLinkList)malloc(sizeof(DuLNode));
   if(!s)
     return OVERFLOW;
   s->data=e; // 在第i-1个元素之后插入
   s->prior=p;
   s->next=p->next;
   p->next->prior=s;
   p->next=s;
   return OK;
 }

 Status ListDelete(DuLinkList L,int i,ElemType &e) // 算法2.19
 { // 删除带头结点的双链循环线性表L的第i个元素,i的合法值为1≤i≤表长+1
   DuLinkList p;
   if(i<1||i>ListLength(L)) // i值不合法
     return ERROR;
   p=GetElemP(L,i);  // 在L中确定第i个元素的位置指针p
   if(!p) // p=NULL,即第i个元素不存在
     return ERROR;
   e=p->data;
   p->prior->next=p->next;
   p->next->prior=p->prior;
   free(p);
   return OK;
 }

 void ListTraverse(DuLinkList L,void(*visit)(ElemType))
 { // 由双链循环线性表L的头结点出发,正序对每个数据元素调用函数visit()
   DuLinkList p=L->next; // p指向头结点
   while(p!=L)
   {
     visit(p->data);
     p=p->next;
   }
   printf("\n");
 }

 void ListTraverseBack(DuLinkList L,void(*visit)(ElemType))
 { // 由双链循环线性表L的头结点出发,逆序对每个数据元素调用函数visit()。另加
   DuLinkList p=L->prior; // p指向尾结点
   while(p!=L)
   {
     visit(p->data);
     p=p->prior;
   }
   printf("\n");
 }

  int InitList(LinkList &L)  //初始化一个链表
  {
    L=(LinkList)malloc(sizeof(Lnode));
    if(!L)
     exit(OVERFLOW);
     L->next=NULL;
     return OK;
  }

  int DestroyList(LinkList &L)  //销毁链表
  {
    LinkList q;
    while(L)
    {
      q=L->next;
      free(L);
      L=q;
    }
    return OK;
  }

  int ClearList(LinkList L)  //清零操作
  {
    LinkList p,q;
    q=L->next;
    while(q)
    {
      p=q->next;
      free(q);
      q=p;
    }
    L->next=NULL;
    return OK;
  }

  int ListEmpty(LinkList L)  //判空操作
  {
    if(L->next==NULL)
    return TRUE;
    else
    return FALSE;
  }

  int ListLength(LinkList L)  //计算链表的长度
  {
    LinkList p;
    int i=0;
    p=L->next;
    while(p)
    {
      ++i;
      p=p->next;
    }
    return i;
  }

  int GetElem(LinkList L,int i,ElemType e)  //得到第i个元素的数据域
  {
    LinkList p;
    int j=0;
    p=L->next;
    while(p && j<i-1)
    {
      p=p->next;
      ++j;
    }
    if(j>i || !p)
    return ERROR;
    else
    e=p->data;
    return OK;
  }

  int LocateElem(LinkList L,ElemType e,int (*compare)(ElemType,ElemType))
  {                       //找到第一个对于E满足函数的数据元素的位置
    LinkList p;
    int i=0;
    p=L->next;
    while(p)
    {
      ++i;
      if(compare(p->data,e))
      return i;
      p=p->next;
    }
    return 0;
  }

  int InsertList(LinkList L,int i,ElemType e)  //在第i个数据元素上插入一个元素
  {
    LinkList p,s;
    int j=0;
    p=L;
    while(p && j<i-1)
    {
      p=p->next;
      ++j;
    }
    if(!p || j>i)
    return ERROR;
    s=(LinkList)malloc(sizeof(Lnode));
    s->data=e;
    s->next=p->next;
    p->next=s;
    return OK;
  }

  int DeleteList(LinkList &L,int i,ElemType e) //删除第i个元素
  {
    LinkList p,q;
    int j;
    j=0;
    p=L;
    while(p->next && j<i-1)
    {
     p=p->next;
     ++j;
    }
    if(!p->next || j>i)
    return ERROR;
    q=p->next;
    p->next=q->next;
    e=q->data;
    free(q);
    return OK;
  }

  int ListTraverse(LinkList L,int (*vi)(ElemType))
  //对所有链表中的元素进行函数vi操作
  {
    LinkList p;
    p=L->next;
    while(p)
    {
      vi(p->data);
      p=p->next;
    }
    return OK;
  }

  void MergeList(LinkList La,LinkList Lb,LinkList &Lc)
  {                              //合并二个非递减的La和Lb得到一个非递减的Lc
    LinkList pa,pb,pc;
    pa=La->next;
    pb=Lb->next;
    Lc=pc=La;
    while(pa && pb)
    {
      if(pa->data <= pb->data)
      {
        pc->next=pa;
 pc=pa;
 pa=pa->next;
      }
      else{
        pc->next=pb;
 pc=pb;
 pb=pb->next;
      }
    }
    pc->next=pa?pa:pb;
    free(Lb);
 Lb=NULL;
  }

#define LIST_INIT_SIZE 100    定义一个线性表类型

#define LISTINCREMENT 10

typedef struct

{

  ElemType *elem; 基址

  int length; 元素的长度

  int listsize;当前的存储容量

 }Sqlist;

 void InitList_Sq(Sqlist &L)  初始化操作

 {

   L.elem=(ElemType*)malloc(LIST_INIT_SIZE*sizeof(ElemType));

   if(!L.elem)

   return overflow;

   L.length=0;

   L.listsize=LIST_INIT_SIZE;

   return ok;

 }

 void DestroyList_Sq(Sqlist &L)  销毁线性表

 {

   free(L.elem);

   L.elem=NULL;

   L.length=0;

   L.listsize=0;

   return ok;

 }

void ClearList(Sqlist L)  清零操作

{

  L.length=0;

  return ok;

}

void ListEmpty(Sqlist L)  判空操作

{

  if(L.length=0)

   return True;

   else

   return False;

}

int ListLength(Sqlist L)  输出表的长度，数据元素个数

{

  return L.length;

}

void GetElem(Sqlist &L,int i,ElemType &e) 得到第I 个元素的数据元素的值

{

   if(i<1 || i>L.length)

   return error;

   e=*(L.elem+i-1);

   return ok;

}

int LocateElem(Sqlist &L,ElemType e,void (*compare)(ElemType,ElemType)) 查找与E相等的元素的位置

{

  ElemType *p;

  i=1;

  while(i<=L.length && !compare(*p++,e))

  ++i;

  if(i<=L.length)

  return i;

  else

  return 0;

}

void PriorElem(Sqlist L,ElemType cur_e,ElemType pre_e)  得到给出的数的前一个元素值

{

  int i=2;

  ElemType *p;

  p=L.elem+1;

  while(i<=L.length && !(*p++==cur_e))

  ++i;

  if(i>L.length)

  return INFEASIBLE;

  else

  {

    pre_e=*--p;

    return OK;

  }

}

void NextElem(Sqlist L,ElemType pre_e,ElemType cur_e)  得到后一个元素的值

{

  int i=1;

  ElemType *p

  p=L.elem;

  while(i<L.length && !(*p++==pre_e))

  ++i;

  if(i>=L.length)

  return INFEASIBLE;

  else

  {

    cur_e=*++p;

    return OK;

  }

}

void InsertElem(Sqlist &L,int i,ElemType e)  在第I个元素中插入一个值为E的元素

{

  if(i<1 || i>=length+1)

  return ERROR;

  if(L.length>=L.listsize)

  {

 if(!newbase=(ElemType *)realloc(L.elem,(L.listsize+LISTINCREMENT)

    *sizeof(ElemType))))

    return OVERFLOW;

    L.elem=newbase;

    L.listsize+=LISTINCREMENT;

  }

  p=L.elem+L.length-1;

  q=L.elem+i-1;

  for(p;p>=q;--p)

  *(p+1)=*p;

  *q=e;

  ++L.length;

  return ok;

}

void DeleteElem(Sqlist &L,int i,ElemType e)  删除第I个元素

{

  if(i<1 || i>=L.length)

  return FALSE;

  p=L.elem+i-1;

  q=L.elem+L.length-1;

  e=*p;

  for(p;p<=q;++p)

  *p=*(p+1);

  --L.length;

  return OK;

}

void ListTraverse(Sqlist &L,void (*vi)(ElemType))  对线性表进行VI的操作

{

  int i;

  ElemType *p;

  p=L.elem;

  for(i=1;i<=L.length;++i)

  vi(*p++);

  return OK;

}

以上是线性表的一些常用的原操作. 

例：

1．求一个新的集合A=A U B。

void union(Sqlist &LA,Sqlist LB)

{

  la_len=LA.length;

  lb_len=LB.length;

  for(i=1;i<=lb_len;++i)

  {

   GetElem(LB,i,e);

   if(!Locate(LA,e,compare()))

   InsertList(LA,++la_len,e);

  }

  return OK;

}

2.将二个非递减的LA表和LB表归并为一个新的非递减的LC表

void MergeList(Sqlist LA,Sqlist LB,Sqlist &LC)

{

  i=j=1;k=0;

  InitList(LC);

  while(i<=LA.length && j<=LB.length)

  {

   GetElem(LA,i,ai);

   GetElem(LB,j,bj);

   if(ai<=bj)

   {

     InsertList(LC,++k,ai);

     ++i;

   }

   else

   {

     InsertList(LC,++k,bj);

     ++j;

   }

  }

  while(i<=LA.length)

  {

    GetElem(LA,i,ai);

    InsertList(LC,++k,ai);

    ++i;

  }

  while(j<=LB.length)

  {

    GetElem(LB,i,bj);

    InsertList(LC,++k,bj);

    ++j;

  }

  return OK;

}