数据结构复习——第三章：栈和队列

1.栈是限制仅在表的一端进行插入和删除运算的线性表又称为后进先出表（LIFO表）。插入、删除端称为栈顶，另一端称栈底。表中无元素称空栈。

 

2.栈的基本运算有：

   1） initstack(s),构造一个空栈；

   2） stackempty(s),判栈空；

   3） stackfull(s),判栈满；

   4） push(s,x),进栈；

   5） pop (s),退栈；

   6） stacktop(s)，取栈顶元素。

 

3.顺序栈：栈的顺序存储结构称顺序栈。

 

4.当栈满时，做进栈运算必定产生空间溢出，称“上溢”。 当栈空时，做退栈运算必定产生空间溢出，称“下溢”。上溢是一种错误应设法避免，下溢常用作程序控制转移的条件。

 

5.在顺序栈上的基本运算：

  1）顺序栈初始化

Status InitStack(SqStack &S){S.base = new SElemType[MAXSIZE]；if (!S.base) return OVERFLOW;S.top = S.base;S.stackSize = MAXSIZE;return OK;}

  2)判栈空

bool StackEmpty(SqStack S){if (S.top == S.base) return true;else return false;}

  3）求顺序栈的长度

int StackLength( SqStack S ){return S.top – S.base;}

  4）清空顺序栈

<span style="font-size:10px;">Status ClearStack(SqStack S){if (S.base) S.top = S.base;return OK;}</span>

  5）销毁顺序栈

<span style="font-family:SimSun;font-size:10px;">Status DestroyStack( SqStack &S ){if( S.base ){delete S.base ;S.stacksize = 0;S.base = S.top = NULL;}  return OK;}</span><strong style="font-size:18px; font-family: KaiTi_GB2312;"></strong>

  6)进栈

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

  7)退栈

Status Pop( SqStack &S, SElemType &e)  {if( S.top == S.base ) // 栈空        return ERROR; e＝ *--S.top;return OK;}

  8)取栈顶元素。

Status GetTop( SqStack S, SElemType &e)  {if( S.top == S.base ) return ERROR; // 栈空e = *( S.top – 1 );return OK;}

6.链栈：栈的链式存储结构称链栈。栈顶指针是链表的头指针。

 

7.链栈上的基本运算：

  1）初始化

void InitStack(LinkStack &S ){S=NULL;   return OK;}

  2)判栈空。

Status StackEmpty(LinkStack S){ if (S == NULL) return TRUE;   else return FALSE; }

  3) 进栈。

Status Push(LinkStack &S, SElemType e){p = new StackNode;      //生成新结点p   if (!p) exit(OVERFLOW);  p->data=e; p->next=S; S=p; return OK;}

4) 退栈

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

5) 取栈顶元素。

SElemType GetTop(LinkStack S){if (S == NULL) exit(1)；   else return S–>data;}

8.队列是一种运算受限的线性表，允许删除的一端称队首，允许插入的一端称队尾。队列又称为先进先出线性表，FIFO表。

 

9.队列的基本运算：

  1） initqueue(q),置空队；

  2） queueempty(q),判队空；

  3） queuefull(q),判队满；

  4） enqueue(q,x),入队；

  5） dequeue(q),出队；

  6） queuefront(q),返回队头元素。

 

10.顺序队列：队列的顺序存储结构称顺序队列。设置front和rear指针表示队头和队尾元素在向量空间的位置。

 

11.顺序队列中存在“假上溢”现象，由于入队和出队操作使头尾指针只增不减导致被删元素的空间无法利用，队尾指针超过向量空间的上界而不能入队。

 

12.为克服“假上溢”现象，将向量空间想象为首尾相连的循环向量，存储在其中的队列称循环队列。i=(i+1)%queuesize

 

13.循环队列的边界条件处理：由于无法用front==rear来判断队列的“空”和“满”。

解决的方法有：

  1） 另设一个布尔变量以区别队列的空和满；

  2） 少用一个元素，在入队前测试rear在循环意义下加1是否等于front；

  3） 使用一个记数器记录元素总数。

 

14.循环队列的基本运算：

  1) 置队空。

Status InitQueue(SqQueue &Q) {// 构造一个空队列QQ.base = (ElemType *)malloc(MAXQSIZE *sizeof(ElemType));//Q.base =new QElemType[MAXQSIZE] if (!Q.base) exit(OVERFLOW);     // 存储分配失败Q.front = Q.rear = 0;return OK;}

  2) 入队。

Status EnQueue(SqQueue &Q, ElemType e) {   // 插入元素e为Q的新的队尾元素if ((Q.rear + 1) % MAXQSIZE == Q.front)return ERROR; //队列满Q.base[Q.rear] = e;Q.rear = (Q.rear + 1) % MAXQSIZE;return OK;}

  3) 出队。

Status DeQueue(SqQueue &Q, ElemType &e) {  // 若队列不空，则删除Q的队头元素，// 用e返回其值，并返回OK;  否则返回ERRORif (Q.front == Q.rear)  return ERROR;e = Q.base[Q.front];Q.front = (Q.front + 1) % MAXQSIZE;return OK;}

15.顺序队列：队列的顺序存储结构，用一组连续的存储单元依次存放队列中的元素

16.链队列：队列的链式存储结构称链队列，链队列由一个头指针和一个尾指针唯一确定。

 

17.链队列的基本运算：

1) 建空队。

Status InitQueue(LinkQueue &Q) {// 构造一个空队列QQ.front = Q.rear =(QueuePtr)malloc(sizeof(QNode));//Q.front=Q.rear=new QNode;if (!Q.front) exit(OVERFLOW);//存储分配失败Q.front->next = NULL;return OK;}

  2) 判队空。

bool QueueEmpty(LinkQueue &Q){if (Q.front == NULL && Q.rear == NULL)return true;elsereturn false;}

  3) 入队。

Status EnQueue(LinkQueue &Q,QElemType e) {// 插入元素e为Q的新的队尾元素p = (QueuePtr)malloc(sizeof(QNode));//p=new QNode;if (!p)  exit(OVERFLOW);   //存储分配失败p->data = e;     p->next = NULL;Q.rear->next = p;    Q.rear = p;return OK;}

  4) 出队。

Status DeQueue(LinkQueue &Q,QElemType &e) {// 若队列不空，则删除Q的队头元素，//用 e 返回其值，并返回OK；否则返回ERRORif (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;}

  5) 取队头元素。

Status QueueFront(LinkQueue &Q){if (QueueEmpty(Q))cout<<"queue is empty";elsereturn Q.front->data;}

18.顺序队列与链式队列的比较

顺序队列：

  1）固定的存储空间

  2）方便访问队列元素

链式队列：

  1）可以满足浪涌大小无法估计的情况

 2）访问队列内部元素不方便