第2章 栈和队列

• 头部引用
• 栈的定义
• 顺序结构定义
• 链式结构定义

• InitStack(&S)
• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构定义
• 链式结构定义

• InitQueue(&Q)
• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

• 顺序结构实现
• 链式结构实现

头部引用

#include<stdio.h>#include<stdlib.h>#define OK 1#define ERROR 0#define OVERFLOW -1#define TRUE 1#define FALSE 0#define SElemType int#define QElemType int

栈的定义

栈是限定仅在表尾进行插入或删除操作的线性表。
栈又称为后进先出（last in first out）的线性表（简称LIFO结构）。

顺序结构定义

#define STACK_INIT_SIZE 100#define STACKINCREMENT 10typedef struct{SElemType *base;SElemType *top;int stacksize;}SqStack;

链式结构定义

typedef struct SNode{SElemType data;struct SNode *next;}SNode, *LinkStack;

栈的基本操作

InitStack(&S)

操作结果：构造一个空栈S。

顺序结构实现

int InitStack_Sq(SqStack &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;}

链式结构实现

int InitStack_L(LinkStack &S){S = (LinkStack)malloc(sizeof(SNode));S->next = NULL;return OK;}

DestroyStack(&S)

初始条件：栈S已存在。
操作结果：栈S被销毁。

顺序结构实现

void DestroyStack_Sq(SqStack &S){free(S.base);S.top = S.base;S.stacksize = 0;}

链式结构实现

void DestroyStack_L(LinkStack &S){SNode *p,*q;p = S;while(p->next){q = p->next;p->next = q->next;free(q);}free(p);}

ClearStack(&S)

初始条件：栈S已存在。
操作结果：将S清为空栈。

顺序结构实现

void ClearStack_Sq(SqStack &S){S.top = S.base;}

链式结构实现

void ClearStack_L(LinkStack &S){SNode *p,*q;p = S;while(p->next){q = p->next;p->next = q->next;free(q);}}

StackEmpty(S)

初始条件：栈S已存在。
操作结果：若栈S为空栈，则返回TRUE，否则返回FALSE。

顺序结构实现

int StackEmpty_Sq(SqStack S){if(S.top == S.base)return TRUE;return FALSE;}

链式结构实现

int StackEmpty_L(LinkStack S){if(S->next == NULL)return TRUE;return FALSE;}

StackLength(S)

初始条件：栈S已存在。
操作结果：返回S的元素个数，即栈的长度。

顺序结构实现

int StackLength_Sq(SqStack S){return S.top - S.base;}

链式结构实现

int StackLength_L(LinkStack S){SNode *p = S->next;int k = 0;while(p){k++;p = p->next;}return k;}

GetTop(S, &e)

初始条件：栈S已存在且非空。
操作结果：用e返回S的栈顶元素。

顺序结构实现

int GetTop_Sq(SqStack S, SElemType &e){if(S.top == S.base)return ERROR;e = *(S.top - 1);return OK;}

链式结构实现

int GetTop_L(LinkStack S, SElemType &e){if(S->next == NULL)return ERROR;SNode *p = S->next;e = p->data;return OK;}

Push(&S, e)

初始条件：栈S已存在。
操作结果：插入元素e为新的栈顶元素。

顺序结构实现

int Push_Sq(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 Push_L(LinkStack &S, SElemType e){SNode *p;p = (LinkStack)malloc(sizeof(SNode));p->data = e;p->next = S->next;S->next = p;return OK;}

Pop(&S, &e)

初始条件：栈S已存在且非空。
操作结果：删除S的栈顶元素，并且e返回其值。

顺序结构实现

int Pop_Sq(SqStack &S, SElemType &e){if(S.top == S.base)return ERROR;e = *--S.top;return OK;}

链式结构实现

int Pop_L(LinkStack &S, SElemType &e){if(StackEmpty_L(S))return ERROR;SNode *p;p = S->next;S->next = p->next;e = p->data;free(p);return OK;}

队列的定义

和栈相反，队列是一种先进先出（first in first out，缩写为FIFO）的线性表。
它只允许在表的一端进行插入，而在另一端删除元素。

顺序结构定义

链式结构定义

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

队列的基本操作

InitQueue(&Q)

操作结果：构造一个空队列Q。

顺序结构实现

链式结构实现

int InitQueue(LinkQueue &Q){Q.front = Q.rear = (QueuePtr)malloc(sizeof(QNode));if(!Q.front)exit(OVERFLOW);Q.front->next = NULL;return OK;}

DestroyQueue(&Q)

初始条件：队列Q已存在。
操作结果：队列Q被销毁，不再存在。

顺序结构实现

链式结构实现

int DestroyQueue(LinkQueue &Q){while(Q.front){Q.rear = Q.front->next;free(Q.front);Q.front = Q.rear;}return OK;}

ClearQueue(&Q)

初始条件：队列Q已存在。
操作结果：将Q清为空队列。

顺序结构实现

链式结构实现

int ClearQueue(LinkQueue &Q){QNode *p;while(Q.front != Q.rear){p = Q.front->next;free(Q.front);Q.front = p;}return OK;}

QueueEmpty(Q)

初始条件：队列Q已存在。
操作结果：若Q为空队列，则返回TRUE，否则返回FALSE。

顺序结构实现

链式结构实现

int QueueEmpty(LinkQueue Q){if(Q.front == Q.rear)return TRUE;return FALSE;}

QueueLength(Q)

初始条件：队列Q已存在。
操作结果：返回Q的元素个数，即队列的长度。

顺序结构实现

链式结构实现

int QueueLength(LinkQueue Q){QNode *p = Q.front->next;int k = 0;while(p){k++;p = p->next;}return k;}

GetHead(Q, &e)

初始条件：Q为非空队列。
操作结果：用e返回Q的队头元素。

顺序结构实现

链式结构实现

int GetHead(LinkQueue Q, QElemType e){QNode *p = Q.front->next;e = p->data;return OK;}

EnQueue(&Q, e)

初始条件：队列Q已存在。
操作结果：插入元素e为Q的新的队尾元素。

顺序结构实现

链式结构实现

int EnQueue(LinkQueue &Q, QElemType e){p = (QueuePtr)malloc(sizeof(QNode));if(!p)exit(OVERFLOW);p->data = e;p->next = NULL;Q.rear->next = p;Q.reat = p;return OK;}

DeQueue(&Q, &e)

初始条件：Q为非空队列。
操作结果：删除Q的队头元素，并且e返回其值。

顺序结构实现

链式结构实现

int 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;free(p);return OK;}

个人笔记，如有错误之处，请及时联系邮箱3218088317@qq.com

• 点赞
• 收藏
• 分享
• 文章举报