栈和队列

最新推荐文章于 2024-07-22 09:43:39 发布

afuhanxiaozhu

最新推荐文章于 2024-07-22 09:43:39 发布

阅读量464

点赞数 1

本文链接：https://blog.csdn.net/afuhanxiaozhu/article/details/8928281

版权

关于栈和队列是两种特殊的线性表

一．栈：是一种先进后出的线性表。

1.以下是顺序表表示的方法及相关的定义：

具体的结构如下：

typedef struct {

       ElemType *base;

       ElemType *top;

       int stacksize;

       }Sqstack;

构造一个空栈

int initstack(Sqstack &L){

       L.base = (ElemType*)malloc(INIT_SIZE*sizeof（ElemType))；

       if(!L.base)exit(OVERFLOW);

       L.top = L.base;

       L.stacksize = INIT_SIZE;

 return OK;

       }

其它操作如push，pop，traverse等操作均为一些简单的操作，在此就不再贴出相关代码

2.以下是链式表示的方法及相关的定义：

具体结构如下：

typedef structnode {

              ElemType data;

struct node*next;

       }stacknode;

构造一个空栈此时就是一个逆序建立一个链表的过程其中栈底不带元素由此可以看出就是一种链表所以回归到栈就是一种线性表的主题了

intcreatestack(stacknode &L){

       L =(stacknode*)malloc(sizeof(stacknode));

       L->next = null;

for(i=n;i>0;i--){

       p =(stacknode*)malloc(sizeof(stacknode));

       scanf(“%d”,p->data);

       p->next = L->next;

       L->next = p;

           }
}

二.队列：是种后进后出的线性表

第一种表示方法类似于链表

typedef struct QNode {
      QElemType data; 
      struct QNode *next;
}QNode, *QueuePtr;

typedef struct {
     QueuePtr front;        //队头指针
     QueuePtr rear;         //队尾指针
}LinkQueue;

第二种表示方法

顺序存储结构的类型定义

#define MAXQSIZE 100

typedefstruct{

       QElemType*base;      //初始化的存储空间

       int front;                      //头指针

       int rear;                       //尾指针

}SqQueue;

循环队列的基本特点有：

无法动态地分配空间只能用固定长度的数组表示

入队： sq[rear]=x;

rear=(rear+1)%M;

出队： x=sq[front];

front=(front+1)%M;

队列初始化：front = rear = 0;

队空条件：front == rear

队满条件：front = (rear+1)%maxsize

初始化一个队列

       void initQueue(SqQueue &q){

                     Q.base =(ElemType*)malloc(MAXSIZE*sizeof(ElemType));

              if(!Q.base) exit(ERROR);

Q.front = Q.rear=0;

}

 

求队列的长度

intQueueLength(SqQueue Q)

{

  return (Q.rear – Q.front +MAXQSIZE)%MAXQSIZE;

}

入队

StatusEnQueue(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; }

出队

StatusDeQueue(SqQueue &Q, QElemType &e)

{

  if(Q.front == Q.rear)    return ERROR;

  e = Q.base[Q.front];

  Q.front = (Q.front+1) % MAXQSIZE;

  return OK; }

综上两种特点在选择队列的时候如果出现长度无法估计就用链队列！