bo3-01~09.cpp 栈和队列算法

最新推荐文章于 2023-01-30 18:41:44 发布

dfreng

最新推荐文章于 2023-01-30 18:41:44 发布

阅读量528

点赞数

分类专栏： Data Structure And Algorithms 文章标签：算法存储 c null

本文链接：https://blog.csdn.net/dfreng/article/details/3098895

版权

Data Structure And Algorithms 专栏收录该内容

26 篇文章 0 订阅

订阅专栏

 
  // bo3-9.cpp 顺序非循环队列(存储结构由c3-4.h定义)的基本操作(4个) 
 int QueueLength(SqQueue2 Q)
 { // 返回Q的元素个数，即队列的长度 
   return(Q.rear-Q.front);
 }
 void EnQueue(SqQueue2 &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素 
   if(Q.rear==Q.queuesize)
   { // 队列满，增加存储单元 
     Q.base=(QElemType *)realloc(Q.base,(Q.queuesize+QUEUE_INCREMENT)*sizeof(QElemType));
     if(!Q.base) // 增加单元失败 
       exit(ERROR);
   }
   Q.base[Q.rear++]=e;
 }
 Status DeQueue(SqQueue2 &Q,QElemType &e)
 { // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR 
   if(Q.front==Q.rear) // 队列空 
     return ERROR;
   e=Q.base[Q.front++];
   return OK;
 }
 void QueueTraverse(SqQueue2 Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi() 
   int i=Q.front;
   while(i!=Q.rear)
     vi(Q.base[i++]);
   printf("/n");
 }
 

 
  // bo3-1.cpp 顺序栈(存储结构由c3-1.h定义)的基本操作(9个) 
 void InitStack(SqStack &S)
 { // 构造一个空栈S 
   if(!(S.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType))))
     exit(OVERFLOW); // 存储分配失败 
   S.top=S.base;
   S.stacksize=STACK_INIT_SIZE;
 }
 void DestroyStack(SqStack &S)
 { // 销毁栈S，S不再存在 
   free(S.base);
   S.base=NULL;
   S.top=NULL;
   S.stacksize=0;
 }
 void ClearStack(SqStack &S)
 { // 把S置为空栈 
   S.top=S.base;
 }
 Status StackEmpty(SqStack S)
 { // 若栈S为空栈，则返回TRUE，否则返回FALSE 
   if(S.top==S.base)
     return TRUE;
   else
     return FALSE;
 }
 int StackLength(SqStack S)
 { // 返回S的元素个数，即栈的长度 
   return S.top-S.base;
 }
 Status GetTop(SqStack S,SElemType &e)
 { // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR 
   if(S.top>S.base)
   {
     e=*(S.top-1);
     return OK;
   }
   else
     return ERROR;
 }
 void Push(SqStack &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;
 }
 Status Pop(SqStack &S,SElemType &e)
 { // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR 
   if(S.top==S.base)
     return ERROR;
   e=*--S.top;
   return OK;
 }
 void StackTraverse(SqStack S,void(*visit)(SElemType))
 { // 从栈底到栈顶依次对栈中每个元素调用函数visit() 
   while(S.top>S.base)
     visit(*S.base++);
   printf("/n");
 }
 

 
  // bo3-2.cpp 链队列(存储结构由c3-2.h定义)的基本操作(9个) 
 void InitQueue(LinkQueue &Q)
 { // 构造一个空队列Q 
   if(!(Q.front=Q.rear=(QueuePtr)malloc(sizeof(QNode))))
     exit(OVERFLOW);
   Q.front->next=NULL;
 }
 void DestroyQueue(LinkQueue &Q)
 { // 销毁队列Q(无论空否均可) 
   while(Q.front)
   {
     Q.rear=Q.front->next;
     free(Q.front);
     Q.front=Q.rear;
   }
 }
 void ClearQueue(LinkQueue &Q)
 { // 将Q清为空队列 
   QueuePtr p,q;
   Q.rear=Q.front;
   p=Q.front->next;
   Q.front->next=NULL;
   while(p)
   {
     q=p;
     p=p->next;
     free(q);
   }
 }
 Status QueueEmpty(LinkQueue Q)
 { // 若Q为空队列，则返回TRUE，否则返回FALSE 
   if(Q.front->next==NULL)
     return TRUE;
   else
     return FALSE;
 }
 int QueueLength(LinkQueue Q)
 { // 求队列的长度 
   int i=0;
   QueuePtr p;
   p=Q.front;
   while(Q.rear!=p)
   {
     i++;
     p=p->next;
   }
   return i;
 }
 Status GetHead(LinkQueue Q,QElemType &e)
 { // 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR 
   QueuePtr p;
   if(Q.front==Q.rear)
     return ERROR;
   p=Q.front->next;
   e=p->data;
   return OK;
 }
 void EnQueue(LinkQueue &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素 
   QueuePtr p;
   if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败 
     exit(OVERFLOW);
   p->data=e;
   p->next=NULL;
   Q.rear->next=p;
   Q.rear=p;
 }
 Status DeQueue(LinkQueue &Q,QElemType &e)
 { // 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR 
   QueuePtr p;
   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;
   free(p);
   return OK;
 }
 void QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi() 
   QueuePtr p;
   p=Q.front->next;
   while(p)
   {
     vi(p->data);
     p=p->next;
   }
   printf("/n");
 }
 

 
  // bo3-3.cpp 循环队列(存储结构由c3-3.h定义)的基本操作(9个) 
 void InitQueue(SqQueue &Q)
 { // 构造一个空队列Q 
   Q.base=(QElemType *)malloc(MAX_QSIZE*sizeof(QElemType));
   if(!Q.base) // 存储分配失败 
     exit(OVERFLOW);
   Q.front=Q.rear=0;
 }
 void DestroyQueue(SqQueue &Q)
 { // 销毁队列Q，Q不再存在 
   if(Q.base)
     free(Q.base);
   Q.base=NULL;
   Q.front=Q.rear=0;
 }
 void ClearQueue(SqQueue &Q)
 { // 将Q清为空队列 
   Q.front=Q.rear=0;
 }
 Status QueueEmpty(SqQueue Q)
 { // 若队列Q为空队列，则返回TRUE；否则返回FALSE 
   if(Q.front==Q.rear) // 队列空的标志 
     return TRUE;
   else
     return FALSE;
 }
 int QueueLength(SqQueue Q)
 { // 返回Q的元素个数，即队列的长度 
   return(Q.rear-Q.front+MAX_QSIZE)%MAX_QSIZE;
 }
 Status GetHead(SqQueue Q,QElemType &e)
 { // 若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR 
   if(Q.front==Q.rear) // 队列空 
     return ERROR;
   e=Q.base[Q.front];
   return OK;
 }
 Status EnQueue(SqQueue &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素 
   if((Q.rear+1)%MAX_QSIZE==Q.front) // 队列满 
     return ERROR;
   Q.base[Q.rear]=e;
   Q.rear=(Q.rear+1)%MAX_QSIZE;
   return OK;
 }
 Status DeQueue(SqQueue &Q,QElemType &e)
 { // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR 
   if(Q.front==Q.rear) // 队列空 
     return ERROR;
   e=Q.base[Q.front];
   Q.front=(Q.front+1)%MAX_QSIZE;
   return OK;
 }
 void QueueTraverse(SqQueue Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi() 
   int i;
   i=Q.front;
   while(i!=Q.rear)
   {
     vi(Q.base[i]);
     i=(i+1)%MAX_QSIZE;
   }
   printf("/n");
 }
 

 
   // bo3-5.cpp 链栈(存储结构由c2-2.h定义)的基本操作(4个) 
 // 部分基本操作是由bo2-8.cpp中的函数改名得来 
 // 另一部分基本操作是由调用bo2-8.cpp中的函数(取特例)得来 
 typedef SElemType ElemType; // 栈结点类型和链表结点类型一致 
 #include"c2-2.h" // 单链表存储结构 
 typedef LinkList LinkStack; // LinkStack是指向栈结点的指针类型 
 #define InitStack InitList // InitStack()与InitList()作用相同，下同 
 #define DestroyStack DestroyList 
 #define ClearStack ClearList 
 #define StackEmpty ListEmpty 
 #define StackLength ListLength 
 #include"bo2-8.cpp" // 无头结点单链表的基本操作 
 Status GetTop(LinkStack S,SElemType &e)
 { // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR 
   return GetElem(S,1,e);
 }
 Status Push(LinkStack &S,SElemType e)
 { // 插入元素e为新的栈顶元素 
   return ListInsert(S,1,e);
 }
 Status Pop(LinkStack &S,SElemType &e)
 { // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR 
   return ListDelete(S,1,e);
 }
 void StackTraverse(LinkStack S,void(*visit)(SElemType))
 { // 从栈底到栈顶依次对栈中每个元素调用函数visit() 
   LinkStack temp,p=S; // p指向栈顶元素 
   InitStack(temp); // 初始化临时栈temp 
   while(p)
   {
     Push(temp,p->data); // 由S栈顶到栈底，依次将栈元素入栈到temp栈 
     p=p->next;
   }
   ListTraverse(temp,visit); // 遍历temp线性表 
 }
 
 

 
   // bo3-5.cpp 链栈(存储结构由c2-2.h定义)的基本操作(4个) 
 // 部分基本操作是由bo2-8.cpp中的函数改名得来 
 // 另一部分基本操作是由调用bo2-8.cpp中的函数(取特例)得来 
 typedef SElemType ElemType; // 栈结点类型和链表结点类型一致 
 #include"c2-2.h" // 单链表存储结构 
 typedef LinkList LinkStack; // LinkStack是指向栈结点的指针类型 
 #define InitStack InitList // InitStack()与InitList()作用相同，下同 
 #define DestroyStack DestroyList 
 #define ClearStack ClearList 
 #define StackEmpty ListEmpty 
 #define StackLength ListLength 
 #include"bo2-8.cpp" // 无头结点单链表的基本操作 
 Status GetTop(LinkStack S,SElemType &e)
 { // 若栈不空，则用e返回S的栈顶元素，并返回OK；否则返回ERROR 
   return GetElem(S,1,e);
 }
 Status Push(LinkStack &S,SElemType e)
 { // 插入元素e为新的栈顶元素 
   return ListInsert(S,1,e);
 }
 Status Pop(LinkStack &S,SElemType &e)
 { // 若栈不空，则删除S的栈顶元素，用e返回其值，并返回OK；否则返回ERROR 
   return ListDelete(S,1,e);
 }
 void StackTraverse(LinkStack S,void(*visit)(SElemType))
 { // 从栈底到栈顶依次对栈中每个元素调用函数visit() 
   LinkStack temp,p=S; // p指向栈顶元素 
   InitStack(temp); // 初始化临时栈temp 
   while(p)
   {
     Push(temp,p->data); // 由S栈顶到栈底，依次将栈元素入栈到temp栈 
     p=p->next;
   }
   ListTraverse(temp,visit); // 遍历temp线性表 
 }
 
 

 
   // bo3-6.cpp 用单链表的基本操作实现链队列(存储结构由c3-2.h定义)的基本操作(9个) 
 typedef QElemType ElemType; 
 #define LinkList QueuePtr // 定义单链表的类型与相应的链队列的类型相同 
 #define LNode QNode 
 #include"bo2-2.cpp" // 单链表的基本操作 
 void InitQueue(LinkQueue &Q)
 { // 构造一个空队列Q 
   InitList(Q.front); // 调用单链表的基本操作 
   Q.rear=Q.front;
 }
 void DestroyQueue(LinkQueue &Q)
 { // 销毁队列Q(无论空否均可) 
   DestroyList(Q.front);
   Q.rear=Q.front;
 }
 void ClearQueue(LinkQueue &Q)
 { // 将Q清为空队列 
   ClearList(Q.front);
   Q.rear=Q.front;
 }
 Status QueueEmpty(LinkQueue Q)
 { // 若Q为空队列，则返回TRUE，否则返回FALSE 
   return ListEmpty(Q.front);
 }
 int QueueLength(LinkQueue Q)
 { // 求队列的长度 
   return ListLength(Q.front);
 }
 Status GetHead(LinkQueue Q,QElemType &e)
 { // 若队列不空，则用e返回Q的队头元素，并返回OK，否则返回ERROR 
   return GetElem(Q.front,1,e);
 }
 void EnQueue(LinkQueue &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素 
   QueuePtr p;
   if(!(p=(QueuePtr)malloc(sizeof(QNode)))) // 存储分配失败 
     exit(OVERFLOW);
   p->data=e;
   p->next=NULL;
   Q.rear->next=p;
   Q.rear=p;
 }
 Status DeQueue(LinkQueue &Q,QElemType &e)
 { // 若队列不空，删除Q的队头元素，用e返回其值，并返回OK，否则返回ERROR 
   if(Q.front->next==Q.rear) // 队列仅有1个元素(删除的也是队尾元素) 
     Q.rear=Q.front; // 令队尾指针指向头结点 
   return ListDelete(Q.front,1,e);
 }
 void QueueTraverse(LinkQueue Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi() 
   ListTraverse(Q.front,vi);
 }
 
 

 
   // bo3-7.cpp 顺序非循环队列(存储结构由c3-5.h定义)的基本操作(9个) 
 void InitQueue(SqQueue1 &Q)
 { // 构造一个空队列Q 
   if(!(Q.base=(QElemType*)malloc(QUEUE_INIT_SIZE*sizeof(QElemType))))
     exit(ERROR); // 存储分配失败 
   Q.rear=0; // 空队列，尾指针为0 
   Q.queuesize=QUEUE_INIT_SIZE; // 初始存储容量 
 }
 void DestroyQueue(SqQueue1 &Q)
 { // 销毁队列Q，Q不再存在 
   free(Q.base); // 释放存储空间 
   Q.base=NULL;
   Q.rear=Q.queuesize=0;
 }
 void ClearQueue(SqQueue1 &Q)
 { // 将Q清为空队列 
   Q.rear=0;
 }
 Status QueueEmpty(SqQueue1 Q)
 { // 若队列Q为空队列，则返回TRUE；否则返回FALSE 
   if(Q.rear==0)
     return TRUE;
   else
     return FALSE;
 }
 int QueueLength(SqQueue1 Q)
 { // 返回Q的元素个数，即队列的长度 
   return Q.rear;
 }
 Status GetHead(SqQueue1 Q,QElemType &e)
 { // 若队列不空，则用e返回Q的队头元素，并返回OK；否则返回ERROR 
   if(Q.rear)
   {
     e=*Q.base;
     return OK;
   }
   else
     return ERROR;
 }
 void EnQueue(SqQueue1 &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素 
   if(Q.rear==Q.queuesize) // 当前存储空间已满 
   { // 增加分配 
     Q.base=(QElemType*)realloc(Q.base,(Q.queuesize+QUEUE_INCREMENT)*sizeof(QElemType));
     if(!Q.base) // 分配失败 
       exit(ERROR);
     Q.queuesize+=QUEUE_INCREMENT; // 增加存储容量 
   }
   Q.base[Q.rear++]=e; // 入队新元素，队尾指针+1 
 }
 Status DeQueue(SqQueue1 &Q,QElemType &e)
 { // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR 
   int i;
   if(Q.rear) // 队列不空 
   {
     e=*Q.base;
     for(i=1;i<Q.rear;i++)
       Q.base[i-1]=Q.base[i]; // 依次前移队列元素 
     Q.rear--; // 尾指针前移 
     return OK;
   }
   else
     return ERROR;
 }
 void QueueTraverse(SqQueue1 Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi() 
   int i;
   for(i=0;i<Q.rear;i++)
     vi(Q.base[i]);
   printf("/n");
 }
 
 

 
   // bo3-8.cpp 循环队列(存储结构由c3-4.h定义)的基本操作(4个) 
 int QueueLength(SqQueue2 Q)
 { // 返回Q的元素个数，即队列的长度 
   return(Q.rear-Q.front+Q.queuesize)%Q.queuesize;
 }
 void EnQueue(SqQueue2 &Q,QElemType e)
 { // 插入元素e为Q的新的队尾元素 
   int i;
   if((Q.rear+1)%Q.queuesize==Q.front)
   { // 队列满，增加存储单元 
     Q.base=(QElemType *)realloc(Q.base,(Q.queuesize+QUEUE_INCREMENT)*sizeof(QElemType));
     if(!Q.base) // 增加单元失败 
       exit(ERROR);
     if(Q.front>Q.rear) // 形成循环 
     {
       for(i=Q.queuesize-1;i>=Q.front;i--)
         Q.base[i+QUEUE_INCREMENT]=Q.base[i]; // 移动高端元素到新的高端 
       Q.front+=QUEUE_INCREMENT; // 移动队头指针 
     }
     Q.queuesize+=QUEUE_INCREMENT; // 增加队列长度 
   }
   Q.base[Q.rear]=e; // 将e插入队尾 
   Q.rear=++Q.rear%Q.queuesize; // 移动队尾指针 
 }
 Status DeQueue(SqQueue2 &Q,QElemType &e)
 { // 若队列不空，则删除Q的队头元素，用e返回其值，并返回OK；否则返回ERROR 
   if(Q.front==Q.rear) // 队列空 
     return ERROR;
   e=Q.base[Q.front]; // 用e返回队头元素 
   Q.front=++Q.front%Q.queuesize; // 移动队头指针 
   return OK;
 }
 void QueueTraverse(SqQueue2 Q,void(*vi)(QElemType))
 { // 从队头到队尾依次对队列Q中每个元素调用函数vi() 
   int i=Q.front; // i指向队头 
   while(i!=Q.rear) // 没到队尾 
   {
     vi(Q.base[i]); // 调用函数vi() 
     i=++i%Q.queuesize; // 向后移动i指针 
   }
   printf("/n");
 }
 
 