2019王道《数据结构》(C语言版)——栈和队列

​

2019王道《数据结构》——栈和队列

重点

栈（出入栈的过程、出栈序列的合法性）和队列的操作及其特征是重中之重。均是线性表的应用和推广

一、栈的基本操作

​ 提示：如果看不懂，可以结合下面的代码来看

InitStack(&S): 初始化一个栈

StackEmpty(S): 判断一个栈是否为空，若栈S为空返回True，否则返回false

Push(&S,x): 进栈，若栈S未满，将x加入使之成为新栈顶

Pop(&S,&x): 弹出栈，返回x

GetTop(S,&x): 读栈顶元素，若栈S非空，用x返回栈顶元素

ClearStack(&S): 销毁栈， 并释放S占用的存储空间

符号“&”是C++所特有的，表示引用（别名），在c语言中可以用*代替

二、栈的顺序存储结构

1）顺序栈的实现

​ 栈的顺序存储

//栈的顺序存储结构
#define MaxSize 50           //定义栈的存储量
typedef int ElemType;     //定义栈里面存储的元素的数据类型
typedef struct{    //定义栈
    ElemType data[MaxSize];   //定义一个data数组用来存“栈里面的各个元素结点的数据”
    int top;      //栈顶指针
}SqStack;

说明：S代表栈

进栈指针：S.top（初始时设置S.top=-1;栈顶元素:S.data[S.top]）

进栈操作：栈不满时，栈顶指针先加1（解释：这就是为什么初始时栈顶指针S.top=-1,因为我们第一次向栈里面加元素的时候，把S.top++，这个时候S.top就等于0了，正好我们的数组位置是从0开始的），再送值到栈顶元素。

出栈操作： 栈非空时，先取栈顶元素值，再将栈顶指针减1

栈空条件：S.top = -1; 栈满条件：S.top==MaxSize-1; 栈长：S.top+1（数组位置是从0开始的）;

由于顺序栈的入栈操作受数组上界的约束，当对栈的最大使用空间估计不足时，有可能发生栈上溢。

2） 顺序栈的基本运算

#include <cstdlib>
#include <cstdio>
 
using namespace std;
 
//栈的顺序存储结构
#define MaxSize 50           //定义栈的存储容量
typedef int ElemType;       //定义栈中存储的元素的数据类型
typedef struct{     //定义栈
    ElemType data[MaxSize];   //存放一个data数组用来存储栈中元素
    int top;      //栈顶指针
}SqStack;
 
void InitStack(SqStack &S) {   
    S.top = -1;
}
 
bool StackEmpty(SqStack S) {
    return S.top == -1;  //如果S.top == -1，就返回true,否则返回false
}
 
bool Push(SqStack &S, ElemType x) {
    if (S.top == MaxSize - 1) //如果栈已经满了，就返回false
        return false;
    S.data[++S.top] = x;  //先把S.top指针加1，然后再将x加入使之成为新栈顶
    return true;
}
 //弹出栈顶的第一个元素
bool Pop(SqStack &S, ElemType &x) {
    if (!(StackEmpty(S))) { //如果栈不空
        x = S.data[S.top--]; //先把栈顶元素弹出去，然后再把S.top指针减1
        return true;
    }
    return false; //如果栈为空，则直接返回false
}
 //得到栈顶第一个元素的值，但是并不将栈顶元素弹出去
bool Gertop(SqStack S, ElemType &x) {
    if (S.top == -1) //如果S.top==-1，说明栈已经空了
        return false;
    x = S.data[S.top]; //得到栈顶元素
    return true;
}
 
bool ClearStack(SqStack &S) { //清空栈
    if (S.top == -1) //如果S.top==-1，说明栈已经空了
        return false;
    
    S.top = -1;   //直接将S.top栈顶指针的值赋值为-1，意思就是“清空栈”
    return true;
}
 
void prinStack(SqStack S) {  //打印栈里面的元素值
    
    ElemType x; 
    
    while (!StackEmpty(S)) {//如果栈不为空，则执行while循环
        Pop(S, x);   //弹出栈顶元素
        printf("%d ", x);  //这里的x已经Pop(S, x)里面赋值了
    }
}
 
int main() {
 
    int i = 10;
    SqStack s;  //定义一个栈S
    InitStack(s); //初始化栈
    while (i--) {  
        ElemType e;
        scanf("%d", &e);
        Push(s, e); //往栈里面存数据
    }
 
    prinStack(s); //打印栈里面的数据
 
    return 0;
}

3）共享栈

利用栈底位置相对不变的特性，可以让两个顺序栈共享一个一维数据空间，将两个栈的栈底分别设置在共享空间的两端，两个栈顶向共享空间的中间延伸。

三、栈的链式存储结构

不存在栈满上溢的情况，通常用单链表实现，规定所有的操作都是在单链表的表头进行的

//栈的链式存储结构,头插法
typedef struct Linknode{
    ElemType data;
    struct Linknode *next;   //指针域,这个指针指向该节点的下一个节点
}*LinkStack;    //栈里面的节点类型定义

试题精选

1）基本操作是指该结构最核心、最基本的运算，其他较复杂的操作可以通过基本操作来实现。

2）栈和队列都是限制存取点的线性结构

3）对于n个不同元素出栈，出栈序列的个数为： （提示：下面有该公式的举例讲解，不要直观地以为是全排列，其实不是！！！）

此公式为卡特兰数， 排列组合公式

​

讲解：我们把n个元素的出栈个数的记为f(n), 那么对于1,2,3, 我们很容易得出：

​ f(1) = 1 //即 1

​ f(2) = 2 //即 12、21

​ f(3) = 5 //即 123、132、213、321、231

123： 1入栈，再出栈，然后2入栈，再出栈，然后3入栈，再出栈

132： 1入栈，再出栈，然后2，3顺序入栈，3出栈，2出栈

…

​ 对于f(3)里面为什么没有312，原因很简单，如果是312的出栈顺序的话，那就是说3第一个出来，但是因为1和2是顺序进去的，所以出来应该是2，1

4）设单链表的表头指针为h，节点结构由data和next两个域组成，其中data域为字符型，试设计算法判断该链表前n个字符是否中心对称

bool dc( LinkedList L, int n) {  
 
    if (n <= 1)        //n的值不合法，n必须大于会等于2才考虑对称性
        return false;
 
    LNode *p = L->next; //把链表的头指针赋给p
    char arr[MaxSize];       //字符数组，用于存储栈里面的元素数据
    int top = -1;           //初始时，让top指针指向-1位置
    while (p != NULL && top < (n / 2 - 1)) {  //如果p不为空，且top指针没有超过该单链表的一半长度
        arr[++top] = p->data;//先把top指针的位置加1，然后把p指针指向的节点数据加到arr数组里面去
        p = p->next; //把p指针的下一个节点赋给p，就相当于把p指针往后面移动
    }
if (p == NULL)    //链表总长度<=n/2,不满足条件（因为上面的n是dc( LinkedList L, int n)的形参，是我们自己随意指定的，有可能我们指定的n值太大了，然后才出现这种情况）
        return false;
 
    if (n & 1)           //n为奇数，比如3=11，则11&01=true，再比如5=101,则101&001=true
        p = p->next;    //因为经过上面的while循环操作以后，p已经指向了(n+1)/2位置的节点，因为这里的n是奇数，所以我们判断对称的话需要忽略中间节点，所以我们让 p = p->next;指向下一个节点，从而直接跳过中间位置的节点
    while (p != NULL && top > -1) {
        if (p->data != arr[top--]) //这个时候p已经指向到(n+1)/2+1位置的节点了，然后把该位置节点的数据与arr栈顶的数据做对比，看是否相等
            return false;
        p = p->next;
    }
 
    if (top > -1)     //栈未被清空，说明字符总数不到n个，比如我们的字符总数为7，n为10，那上面的程序就是判断字符序列的前5个与后5个是否对应相等。但是显然我们的字符总数才7个，所以应该是前半部分是5个，后半部分是2个，所以才会出现这里的top>-1的情况
        return false;
    else
        return true;
    
}

    if (top > -1)     //栈未被清空，说明字符总数不到n个，比如我们的字符总数为7，n为10，那上面的程序就是判断字符序列的前5个与后5个是否对应相等。但是显然我们的字符总数才7个，所以应该是前半部分是5个，后半部分是2个，所以才会出现这里的top>-1的情况
        return false;
    else
        return true;
    
}