王道数据结构第三章笔记

最新推荐文章于 2024-07-03 11:58:00 发布
原创 最新推荐文章于 2024-07-03 11:58:00 发布 · 330 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#数据结构 #队列 #栈

这篇笔记详细介绍了栈和队列的概念及其各种实现方式，包括顺序栈、链栈、共享栈、顺序队列、链队列和双端队列。还探讨了括号匹配和表达式求值问题，以及二维数组的存储结构，如特殊矩阵的压缩存储。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

第三章

栈与队列

栈的定义

（线性表的具有相同数据类型的n个数据元素的有序有限序列，其中n为表长，当n=0时，线性表为空表）

栈 是只允许一端插入或删除的 线性表

n个不同元素进栈，出栈元素不同排列个数为:

1n+1\dfrac{1}{n+1}n+11​*C(22n)C\binom{2}{2n}C(2n2​)

顺序栈
定义

（用顺序存储方式实现的栈）

#define MaxSize 10
typedef struct {
    Elemtype data[MaxSize];
    int top;//栈顶指针，存放栈顶元素的下标
}SqStack;
初始化操作
//第一种初始化S.top = -1;
#define MaxSize 10
typedef struct {
    Elemtype data[MaxSize];
    int top;//栈顶指针，存放栈顶元素的下标
}SqStack;
void InitStack(SqStack &S) {
    S.top = -1;//初始化栈顶指针
}

//第二种初始化S.top = 0;
#define MaxSize 10
typedef struct {
    Elemtype data[MaxSize];
    int top;//栈顶指针，存放栈顶元素的下标
}SqStack;
void InitStack(SqStack &S) {
    S.top = 0;//初始化栈顶指针
}
进栈
//第一种的进栈
bool Push(Sqtack &S, Elemtype x) {
    if(S.top == MaxSize - 1) {
        return false;
    }
    S.top = S.top + 1;
    S.data[S.top] = x;
    return true;
}

//第二种的进栈
bool Push(Sqtack &S, Elemtype x) {
    if(S.top == MaxSize - 1) {
        return false;
    }
    S.data[S.top] = x;
    S.top = S.top + 1;
    return true;
}
出栈
//第一种的出栈
bool Pop(Sqtack &S, Elemtype &x) {
    if(S.top == -1) {
        return false;
    }
    x = S.data[S.top];
    S.top = S.top - 1;
    return true;
}

//第二种的出栈
bool Pop(Sqtack &S, Elemtype &x) {
    if(S.top == 0) {
        return false;
    }
    x = S.data[S.top-1];
    S.top = S.top - 1;
    return true;
}
读栈顶元素
//第一种读栈顶元素
bool GetTop(SqStack &S, Elemtype &x) {
    if(S.top == -1) {
        return false;
    }
    x = S.data[top];
    return true;
}

//第二种读栈顶元素
bool GetTop(SqStack &S, Elemtype &x) {
    if(S.top == 0) {
        return false;
    }
    x = S.data[top-1];
    return true;
}
共享栈

两个栈共享一个存储空间，有两个栈顶指针，分别存放顺序表的第一个元素前一个的下标比如-1，和存放顺序表最后一个元素下标的后一个比如MaxSize

定义
#define MaxSize 10
typedef struct {
    Elemtype data[MaxSize];
    int top0;//0号栈顶指针，存放栈顶元素的下标
    int top1;//1号栈顶指针，存放栈顶元素的下标
}ShqStack;
初始化操作
#define MaxSize 10
typedef struct {
    Elemtype data[MaxSize];
    int top0;//0号栈顶指针，存放栈顶元素的下标
    int top1;//1号栈顶指针，存放栈顶元素的下标
}ShqStack;

void InitShStack(ShStack &S) {
    S.top0 = -1;
    S.top1 = Maxsize;
}

栈满的条件：

top0 + 1 == top1
链栈
定义

用链式存储方式实现的栈

image-20210515155139825

创建（初始化）
//不带带头结点的
typedef struct LSNode {
    Elemtyoe data;
    struct LSNode *next;
}LSNode, *LinkStack;
bool InitLStack(LinkStack &LS) {
    LS = NULL;//空表，暂时没有任何节点，防止脏数据
    return true;
}
void test() {
    LinkStack LS;
    initLStack(L);
}

//带头结点的
typedef struct LSNode {
    Elemtyoe data;
    struct LSNode *next;
}LSNode, *LinkStack;
bool InitLStack(LinkStack &LS) {
    LS = (LSNode *)malloc(sizeof(LSNode));//分配一个头结点
    if(LS == NULL) {//内存分配不足，分配失败
        return false;
    }
    LS = NULL;//空表，暂时没有任何节点，防止脏数据
    return true;
}
void test() {
    LinkStack LS;
    initLStack(L);
}
增（进栈）

这里可以用到头插法

//带头结点的
bool pop(LinkStack &LS,Elemtype e) {//将值为e的节点插入栈中
    LSNode s = (LSNode *)malloc(sizeof(LSNode));
    LSNode *p = LS;//p用于指向头结点
    s->data = e;
    s->next = p = next;
    p->next = s;
    return true;
}

//不带头结点
bool pop(LinkStack &LS,Elemtype e) {//将值为e的节点插入栈中
    LSNode s = (LSNode *)malloc(sizeof(LSNode));
    LSNode *p = LS;
    s->data = e;
    if(LS == NULL) {//空表的时后直接往里头加就行
        LS = s;
    }else {
        s->next = p->next;
        p->next = s;
    }
    return true;
}
删（出栈）
//带头结点的
bool push(LinkStack &LS,Elemtype &e) {//将出栈的元素值放入e中
    if(LS->next == NULL) {//判断表空
        return false;
    }
    LSNode *p = LS;//p指向栈头结点
    LSNode *q = p->next;//q指向头结点的下一个结点，也就是要出栈的栈顶元素
   	e = p->next->data;//将栈顶的值放入e中
    p->next = q->next;
    free(q);
    return true;
}

//不带头结点的
bool push(LinkStack &LS,Elemtype &e) {//将出栈的元素值放入e中
    if(LS == NULL) {//判断表空
        return false;
    }
    LSNode *p = LS;//指向栈顶结点，就是栈顶元素
    e = p->data;
    LS = LS->next;//栈顶指针直接指向下一个元素
    free(p);//释放之前栈顶的结点
    return true;
}
查（获取栈顶元素）
//带头结点的
bool Top(LinkStack &LS,Elemtype &e) {//将出栈的元素值放入e中
    if(LS->next == NULL) {//判断表空
        return false;
    }
    LSNode *p = LS;//p指向栈头结点
    e = p->next->data;//将栈顶元素的值存放在e中
    return true;
}

//不带头结点的
int Top(LinkStack &LS,Elemtype &e) {//将出栈的元素值放入e中
    if(LS == NULL) {//判断表空
        return false;
    }
    LSNode *p = LS;//p指向栈头结点
    e = p->data;//将栈顶元素的值存放在e中
    return true;
}
判断表空
//带头结点的
bool juiceEmpty(LinkStack &LS) {
    if(LS->next == NULL) {
        return true;
    }
}

//不带头结点的
bool juiceEmpty(LinkStack &LS) {
    if(LS == NULL) {
        return true;
    }
}
队列
定义

只允许在一端进行插入，在另一端进行删除的 线性表，先进先出

（线性表时具有相同数据类型的n（n>=0)个数据元素的有限序列，其中n为表长，但n=0时相信表为一个空表。

image-20210515173905617

image-20210515174049269

image-20210515174221614

顺序队列
#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];//用静态数组存放
    int front, rear;//队头指针和队尾指针
}SqQueue;
初始化操作

（队尾指针指向队尾元素后一个元素）

#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];//用静态数组存放
    int front, rear;//队头指针和队尾指针
}SqQueue;
void InitQueue(SqQueue &Q) {
    Q.rear = Q.front = 0;//初始化队头指针指向0
}
void testQueue() {
    //申明一个顺序队列
    SqQueue Q;
    InitQueue(Q);
    //...后续操作...
}

（队尾指针指向队尾元素）

#define MaxSize 10
typedef struct{
    ElemType data[MaxSize];//用静态数组存放
    int front, rear;//队头指针和队尾指针
}SqQueue;
void InitQueue(SqQueue &Q) {
    Q.front = 0;//初始化队头指针指向0
    Q.rear = MaxSize - 1;
}
void testQueue() {
    //申明一个顺序队列
    SqQueue Q;
    InitQueue(Q);
    //...后续操作...
}
入队

（队尾指针指向队尾元素后一个元素）

bool EnQueue(SqQueue &Q,ElemType x) {
    if((Q.rear+1)%MaxSize == Q.front){//判断队满,这时牺牲一个出差空间来进行判断队满
        return false;
    }
    Q.data[Q.rear] = x;//将x插入队列
    Q.rear = (Q.rear+1)%MaxSize;//队尾指针往后移，并取模
}

image-20210515180431227

（队尾指针指向队尾元素）

bool EnQueue(SqQueue &Q,ElemType x) {
    if((Q.rear+2)%MaxSize == Q.front){//判断队满,这时牺牲一个出差空间来进行判断队满
        return false;
    }  
    Q.rear = (Q.rear+1) % MaxSize;//队尾指针往后移，并取模
    Q.data[Q.rear] = x;//将x插入队列
}
出队

（队尾指针指向队尾元素后一个元素）

//删除一个队头元素，并用x返回
bool DeQueue(SqQueue &Q,ElemType &x) {
    if(Q.rear == Q.front) {//判断队空
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front+1)%MaxSize;//队头指针往后移动，并取模
    return true;
}

（队尾指针指向队尾元素）

//删除一个队头元素，并用x返回
bool DeQueue(SqQueue &Q,ElemType &x) {
    if((Q.rear+1)%MaxSize == Q.front) {//判断队空
        return false;
    }
    x = Q.data[Q.front];
    Q.front = (Q.front+1)%MaxSize;//队头指针往后移动，并取模
    return true;
}
查

（获得队头元素）

（队尾指针指向队尾元素后一个元素）

bool GetHead(SqQueue Q,ElemType &x) {
    if(Q.rear == Q.front){//判断队空
        return false;
    }
    x = Q.data[Q.front];
    return true;
}

（队尾指针指向队尾元素）

bool GetHead(SqQueue Q,ElemType &x) {
    if((Q.rear+1)%MaxSize == Q.front){//判断队空
        return false;
    }
    x = Q.data[Q.front];
    return true;
}
队中元素数量
(rear+MaxSize-front) % MaxSize//稍微修改也可以进行判断空与满
判断队满/空方案二

（不浪费任何元素）

#define MaxSize 10
typedef struct {
    ElemType data[MaxSize];
    int front,rear;
    int size；//队列当前长度
}SqQueue;

image-20210515182538635

(rear+MaxSize-front) % MaxSize//稍微修改也可以进行判断空与满
判断队满/空方案三
#define MaxSize 10
typedef struct {
    ElemType data[MaxSize];
    int front,rear;
    int tag；//最近进行的时删除/插入
}SqQueue;

image-20210515182703302

链队列
定义
typedef struct LinkNode{//链式队列结点
    ElemType data;
    struct LinkNode *next;
}LinkNode;
typedef struct{//链式队列
    LinkNode *front,*rear;//队列的头指针和尾指针
}LinkQueue;
初始化
//带头结点的
void InitQueue(LinkQueue &Q) {
    //初始化front,rear都指向头结点
    Q.front = Q.rear = (LinkNode *)malloc(sizeof(LinkNode));//申请一个头结点
    Q.front->next = NULL;
}
void testLinkQueue() {
    LinkQueue Q;//声明一个队列
    InitQueue(Q);//初始化队列
    //...后续操作...
}

//不带头结点
void InitQueue(LinkQueue &Q) {
    //初始时front,rear都指向NULL
    Q.front = NULL;
    Q.rear = NULL;
}
判空
//带头结点的
bool IsEmpty(LinkQueue Q) {
    if(Q.front == Q.rear) {
        return true;
    }else {
        return false;
    }
}

//不带头结点的
bool IsEmpty(LinkQueue Q) {
    if(Q.front == NULL) {
        return true;
    }else {
        return false;
    }
}
入队
//带头结点的
void EnQueue(LinkQueue &Q,ElemType x) {
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next = NULL;//不要忘了
    Q.rear->next = s;//新结点插入到rear之后
    Q.rear = s;//修改表尾指针
}

//不带头结点的
void EnQueue(LinkQueue &Q,ElemType x) {
    LinkNode *s = (LinkNode *)malloc(sizeof(LinkNode));
    s->data = x;
    s->next = NULL;
    if(Q.front == NULL) {//在空队列中插入第一个元素
        Q.front = s;//修改队头指针
        Q.rear = s;//修改队尾指针
    }else {
        Q.rear->next = s;//新结点插入到rear之后
    	Q.rear = s;//修改表尾指针
    } 
}
出队

image-20210515193819902

//带头结点的
bool DeQueue(LinkQueue &Q,Elemtype &x) {
    if(Q.front == Q.rear) {//表空判断
        return false;
    }
    LinkNode *p = Q.front->next;
    x = p->data;
    if(Q.rear == p){//此次时最后一个结点出队
        Q.rear = Q.front;//修改rear的指针
    }
    free(p);//释放空间
    return true;       
}

image-20210515195225087

//不带头结点的
bool DeQueue(LinkQueue &Q,Elemtype &x) {
    if(Q.front == NULL) {//表空判断
        return false;
    }
    LinkNode *p = Q.front;
    x = p->data;
    if(Q.rear == Q.front){//此次时最后一个结点出队
        Q.rear = Q.front = NULL;//修改front和rear的指针
    }
    Q.front = p->next;
    free(p);//释放空间
    return true;       
}
双端队列

image-20210516185523377

考点：判断元素输出序列合法性（eg：4个有序序列）

  • 双端队列：image-20210516191337563

  • 栈的出栈序列：image-20210516191509701

  • 输入受限制的双端队列：

image-20210516191637242

  • 输出受限的双端队列：

image-20210516210801879

括号匹配问题

image-20210529101715429

bool bracketCheck(char str[], int length) {
    SqStack S;
    InitStack(S);//初始化一个栈
    for(int i = 0;i < length; i++) {//左括号入栈
        if(str[i] == '(' || str[i] == '[' || str[i] == '{') {
            push(S, str[i]);
        }else {
            if(StackEmpty(S)){//扫描右括号，且当前栈空
                renturn fasle;//匹配失败
            }
            char topElem;
            Pop(S, topElem);//栈顶元素弹出
            if(str[i] == ')' && topElem != '('){
                return false;
            }
            if(str[i] == ']' && topElem != '['){
                return false;
            }
             if(str[i] == '}' && topElem != '{'){
                return false;
            }
        }
    }
    return StackEmpty(S);//检索全部括号后，栈空说明匹配成功
}
表达式求值问题

image-20210529104419597

  • 后缀表达式

    左优先原则

    注意：操作数是有左右顺序

    image-20210529102807892

    转化为算法主要思想：

    image-20210529104744033

  • 前缀表达式

    右优先原则

    注意：操作数是有左右顺序

image-20210529104039994

image-20210529104222008

二维数组的存储结构
  • 行优先

image-20210529112037801

  • 列优先

    image-20210529112137872

  • 对称矩阵

    image-20210529112401339

  • 三角矩阵

image-20210529113019979

  • 对角矩阵的压缩存储

image-20210529113353063

image-20210529122815954

image-20210529122917028

  • 稀疏矩阵

image-20210529123047476

image-20210529123127305

特殊矩阵总结：

王道数据结构第三章习题笔记
艾
07-26 487
遇事不决可问春风春风不语即随本心我若本心能定怎会遇事不决春风亦有春风愁不劳春风为我忧。自此春风盈满袖，只为一解平安愁。httpshttpshttps。
【专栏必读】王道考研408数据结构+算法设计与分析万字笔记使用说明及章节导航
快乐江湖的博客
11-23 5万+
各位老铁思维导图在我整理完笔记后会放上去的，我需要根据王道的思维导图重新再做一遍 文章目录一：有关注意事项二：关于专栏三：学习建议四：各专栏导航（各位老铁别催，质量优先）（1）第一章：绪论（2）第二章：线性表（3）第三章：栈和队列第四章：串第五章：二叉树第六章：图 首先感谢王道大大（手动比心），很用心在做了，大家可以看其中两节是否符合胃口 (王道408考研数据结构)第五章树-第三节1：二叉树遍历（先序、中序和后序） (王道408考研数据结构)第五章树-第四节2：平衡二叉树(AVL)及其旋转 一：有.
《2020王道》| 数据结构 | 学习笔记 | 第三章 | 栈和队列
Wu Y H的博客
07-11 800
《2020年王道数据结构》考研复习学习笔记重要知识点摘录，本来应该算是转载性质，因为我只是把重要知识点摘抄出来，并不是我自己的想法和经验，但是转载需要原文链接，王道官网并没有给出整本书的详细内容链接，所以暂且选择原创。我在这里申明，该博客只用于个人学习记录。
数据结构笔记（王道考研） 第三章：栈和队列
zimuzi2019的博客
08-09 2980
数据结构笔记（王道考研） 第三章：栈和队列
王道数据结构第三章
qq_42712462的博客
03-15 299
//链栈操作实现——创增删查 typedef struct Lnode { Elemtype data; struct LNode *next; }stack; void add(stack *l,Elemtype x)//入栈 { LNode *h=l,*p; p->data=x; p->next=l->next; l->next=p; } bool St...
王道考研408 数据结构 第三章 栈、队列与数组
weixin_46524058的博客
10-04 723
太长不看
【王道数据结构】第三章 | 栈和队列
强哥的微博
02-04 978
初始化一个栈，用于保存暂时还不能确定运算顺序的运算符。从左往右扫描，每遇到一个运算符，就让运算符前面最近的两个操作数执行对应的运算，合体为一个操作数。定义：将循环队列臆造为一个环状的空间，即把存储队列元素的表从逻辑上视为一个环，称为循环队列。“左优先”原则: 只要左边的运算符能先计算，就优先算左边的 (保证运算顺序唯一)；用栈实现后缀表达式的计算（栈用来存放当前暂时不能确定运算次序的操作数）适合用“递归”算法解决：可以把原始问题转换为属性相同，但规模较小的问题。缺点：太多层递归可能回导致栈溢出；
王道考研数据结构笔记
weixin_45016439的博客
04-15 2万+
2022年4月16日 整理了这篇博客的pdf版本，但是缺的部分可能没法补上啦，把毕业的事忙完了可能！可以！对着书把笔记再整理一遍！所以所以，如果有需要pdf版本的可以私信我(有偿，奶茶钱这样)。 大家加油！一定会成功的！ 王道考研数据结构笔记 第二章 线性表 2.1 线性表的定义和基本操作 要点： 线性表的基本操作——创销、增删、改查 传入参数时，何时要用引用 & 2.2 线性表的顺序表示 2.2.1 顺序表的定义 顺序表的实现———静态分配 #include <stdio.h>
王道数据结构第三章（栈和队列）笔记
最新发布
Java程序员十六的博客
07-03 1843
采用顺序存储的栈成为顺序栈。
数据结构（王道计算机考研笔记）
weixin_49393290的博客
09-13 9298
数据结构
数据结构王道教材2018年版本
01-04
数据结构王道教材2018年版本数据结构王道教材2018年版本
【王道数据结构】第三章 栈和队列
weixin_48434658的博客
08-22 1289
【王道数据结构】第三章 栈和队列
王道数据结构第三章：栈与队列
weixin_74776795的博客
09-19 350
本文主要实现考研王道数据结构第三章 栈与队列的内容
数据结构王道第三章（上）
wing的博客
01-24 108
3.1.1 栈的基本概念 栈：只允许在一端进行插入或者删除操作的线性表 3.1.2 栈的顺序存储实现 //顺序栈的定义 #define MaxSize 10 //定义栈中元素的最大个数 typedef struct{ Elemtype data[MaxSize]; //静态数组存放栈中元素 int top; //栈顶指针（存放栈顶元素的数组下标） }SqStack; void testStack(){ SqStack S; //声明一个顺序栈（分配空间） //。。。 }
2023王道考研数据结构第三章---栈
weixin_52572034的博客
08-30 1246
2023王道考研数据结构第三章---栈
《王道》数据结构笔记整理2022
热门推荐
池鱼
08-21 24万+
数据结构第一章绪论1.1数据结构的基本概念1.2数据结构的三要素1.3算法的基本概念1.4算法的时间复杂度1.5算法的空间复杂度 第一章绪论 1.1数据结构的基本概念 1.数据：数据是信息的载体，是描述客观事物属性的数、字符以及所有能输入到计算机中并被程序识别和处理的符号的集合。 2.数据元素：数据元素是数据的基本单位，通常作为一个整体进行考虑和处理。一个数据元素可由若干数据项组成，数据项是构成数据元素的不可分割的最小单位。例如，学生记录就是一个数据元素，它由学号、姓名、性别等数据项组成。 3.数据对象:数
王道数据结构课后习题 | P018
益达的小作坊
08-01 3878
3.长度为L的顺序表，编写一个时间复杂度为O(n)，空间复杂度为O(1)的算法，该算法删除线性表中所有值为x的元素。 一看就是典型的双指针问题，于是我写代码如下for(i=0,j=i+1;j<n;i++,j++){ if(a[j]==x){ while(a[j++]==x); a[++i]=a[j]; } else if(a[i]==x) a[
王道考研数据结构精华笔记：逻辑与存储结构解析
"王道计算机考研 数据结构 笔记（包括PPT内容和笔记内容）" 数据结构是计算机科学中的核心课程，对于准备计算机考研的学生来说尤为重要。本资源提供了全面的数据结构笔记，涵盖了从基本概念到高级主题的详细讲解。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值