[数据结构] 2.栈与队列

最新推荐文章于 2024-09-14 22:38:49 发布
最新推荐文章于 2024-09-14 22:38:49 发布
阅读量253 收藏
点赞数
分类专栏： 初级数据结构 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44506866/article/details/110264214
版权

目录

1.栈

1.1定义

  • 性质：FILO、LIFO

  • 栈顶指针 top 记录栈顶元素的位置，栈空top = -1

  • 弹栈：代表栈顶元素的栈顶指针向下移动一位，逻辑上完成一次出栈操作（类比于Vector删除）

  • 一对 () 可以等价为一个完整事件，(()) 可以看作事件与事件的完全包含关系

  • () 问题是分治思想，可以采用递归实现

  • 递归实现借助的结构是系统栈，栈可以处理具有完全包含关系的问题

  • 栈和队列的应用

1.2顺序栈

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct Stack {
    int *data, size, top;
} Stack;

Stack *initStack(int n) {
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->data = (int *)malloc(sizeof(int) * n);
    s->size = n;
    s->top = -1;
    return s;
}

//freeStack()置栈区s==NULL
void freeStack(Stack **saddr) { //saddr指向Stack*
    if (!(*saddr)) return ;
    free((*saddr)->data);
    free(*saddr);
    *saddr = NULL; //置NULL
    return ;
}

int expand(Stack *s) {
    int expsize = s->size;
    int *temp;
    while (expsize) {
        temp = (int *)realloc(s->data, sizeof(int) * (s->size + expsize));
        if (temp) break;
        expsize >>= 1;
    }
    if (!temp) return 0;
    s->data = temp;
    s->size += expsize;
    printf("expand successfully, new size is %d\n", s->size);
    return 1;
}

int push(Stack *s, int val) {
    if (!s) return 0;
    if (s->top + 1 == s->size) {
        if (!expand(s))
            return 0;
    }
    s->data[++s->top] = val;
    return 1;
}

//isEmpty()和pop()独立封装，配合调用
int isEmpty(Stack *s) {
    return !(s && s->top != -1); // return s || s->top == -1; 互为逆反
}

int pop(Stack *s) {
    return s->data[s->top--];
}

void showStack(Stack *s) {
    //if (isEmpty(s)) return ; ---> !s/栈空不输出
    if (!s) return ;
    printf("Stack: [");
    for (int i = 0; i <= s->top; i++) {
        i && printf(",");
        printf("%d", s->data[i]);
    }
    printf("]\n");
    return ;
}

int main() {
    srand(time(0));
    Stack *s = initStack(2);
    int cnt = 10;
    while (cnt--) {
        int val = rand() % 100;
        int opt = rand() % 4;
        switch (opt) {
            case 0:
            case 1:
            case 2:
                printf("push %d, res = %s\n", val, push(s, val) ? "SUC" : "ERR");
                break;
            case 3:
                //配合调用
                isEmpty(s) ? printf("pop nothing~\n") : printf("pop %d\n", pop(s));
                break;
        }
        showStack(s);
    }
    freeStack(&s);
    printf("s = %p\n", s); 
    return 0;
}
  1. 理解指针看到什么？去掉一个*

1.3链式栈

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct Node {
    int val;
    struct Node *next;
} Node;

typedef struct Stack {
    Node *head;
} Stack;

Node *initNode(int val) {
    Node *n = (Node *)malloc(sizeof(Node));
    //if (!n) return NULL;
    n->val = val;
    n->next = NULL;
    return n;
}

void freeNode(Node *p) {
    if (p) free(p);
    return ;
}

Stack *initStack() {
    Stack *s = (Stack *)malloc(sizeof(Stack));
    s->head = NULL;
    return s;
}

void freeStack(Stack *s) {
    if (!s) return ;
    Node *p = s->head, *k;
    while (p) {
        k = p;
        p = p->next;
        freeNode(k);
    }
    free(s);
    return ;
}

// 对于链栈,插入使用头插法,head始终指向栈顶元素
int push(Stack *s, int val) {
    if (!s) return 0;
    Node *n = initNode(val);
    //if (!n) return 0;
    n->next = s->head; // 头插
    s->head = n;
    return 1;
}

int isEmpty(Stack *s) {
    return !s || s->head == NULL;
}

int pop(Stack *s) {
    Node *k = s->head;
    int tmp = k->val;
    s->head = k->next;
    freeNode(k);
    return tmp;
}

void showStack(Stack *s) {
    if (!s) return ;
    printf("Stack: [");
    Node *p = s->head;
    while (p) {
        printf("%d->", p->val);
        p = p->next;
    }
    printf("NULL]\n");
    return ;
}

int main() {
    srand(time(0));
    Stack *s = initStack();
    int cnt = 10;
    while (cnt--) {
        int val = rand() % 100;
        int opt = rand() % 4;
        switch (opt) {
            case 0:
            case 1:
            case 2:
                printf("push %d, res = %s\n", val, push(s, val) ? "SUC" : "ERR");
                break;
            case 3:
                isEmpty(s) ? printf("pop nothings~\n") : printf("pop %d\n", pop(s));
                break;
        }
        showStack(s);
    }
    freeStack(s);
    return 0;
}
  1. 链栈使用头插法，栈顶指针 head 指向链表头节点，方便入栈、出栈

2.队列

2.1定义

  1. head指向队首，tail指向队尾+1

  2. 循环队列实际容量q->size - 1，为了避免队满时，与队空条件q->head == q->tail冲突

  3. 循环队列
    取余运算%实现循环，解决普通队列假溢出问题

  4. 2个基本操作：push、pop

  5. 出队判空&入队判满
    初始化q->head = q->tail = 0
    队空 q->head == q->tail
    队满(q->tail + 1) % q->size == q->head

  6. 为什么tail指向队尾的后一个元素？
    判断队空还是队满的问题导致的
    head指向队首，tail指向队尾
    初始：head = tail = -1（初始值为0有歧义，元素为0个还是1个？）
    队空： h e a d = = t a i l head == tail head==tail
    出队到只剩1个元素时， h e a d = = t a i l head==tail head==tail发生了歧义

2.2顺序队列（循环队列）

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct Queue {
    int *data, size, head, tail;
} Queue;

Queue *initQueue(int n) {
    Queue *q = (Queue *)malloc(sizeof(Queue));
    q->data = (int *)malloc(sizeof(int) * n);
    q->size = n; //实际容量n-1
    q->head = q->tail = 0; //初始化-1无法判断队满
    return q;
}

void freeQueue(Queue *q) {
    if (!q) return ;
    free(q->data);
    free(q);
    return ;
}

int expand(Queue *q) {
    int expsize = q->size;
    int *tmp;
    while (expsize) { 
        tmp = (int *)malloc(sizeof(int) * (q->size + expsize));
        if (tmp) break;
        expsize >>= 1;
    }
    if (!tmp) return 0;
    int i, j;
    for (i=q->head, j=0; i!=q->tail; i=(i+1)%q->size, j++) {
        tmp[j] = q->data[i];
    }
    free(q->data);
    q->data = tmp;
    q->head = 0, q->tail = j; //tail利用循环变量j赋值
    q->size += expsize;
    printf("expand successfully~, new size is %d\n", q->size);
    return 1;
}

//head->队首 tail->队尾+1
int push(Queue *q, int val) {
    if (!q) return 0;
    if ((q->tail + 1) % q->size == q->head) { //队满
        if (!expand(q))
            return 0;
    }
    q->data[q->tail] = val;
    q->tail = (q->tail + 1) % q->size;
    return 1;
}

int isEmpty(Queue *q) {
    return !q || q->head == q->tail; //队空
}

int pop(Queue *q) {
    int tmp = q->data[q->head];
    q->head = (q->head + 1) % q->size;
    return tmp;
}

void showQueue(Queue *q) {
    if (!q) return ;
    printf("Queue: [");
    for (int i = q->head; i != q->tail; i = (i + 1) % q->size) {
        i != q->head && printf(",");
        printf("%d", q->data[i]);
    }
    printf("]\n");
    return ;
}

int main() {
    srand(time(0));
    Queue *q = initQueue(1); //容量0，队满
    int cnt = 10;
    while(cnt--) {
        int val = rand() % 100;
        int opt = rand() % 4;
        switch(opt) {
            case 0:
            case 1:
            case 2:
                printf("push %d, res = %s\n", val, push(q, val) ? "SUC" : "ERR");
                break;
            case 3:
                isEmpty(q) ? printf("pop nothings~\n") : printf("pop %d\n", pop(q));
                break;
        }
        showQueue(q);
    }
    freeQueue(q);
    return 0;
}

2.3链式队列

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

typedef struct Node {
    int val;
    struct Node *next;
} Node;

typedef struct Queue {
    Node *head, *tail; //链队尾插头删,因为删除需要尾节点前一个节点的地址,tail无法满足
} Queue;

Node *initNode(int val) {
    Node *n = (Node *)malloc(sizeof(Node));
    n->val = val;
    n->next = NULL;
    return n;
}

void freeNode(Node *p) {
    if (p) free(p);
    return ;
}

Queue *initQueue() {
    Queue *q = (Queue *)malloc(sizeof(Queue));
    q->head = q->tail = NULL;
    return q;
}

void freeQueue(Queue *q) {
    if (!q) return ;
    Node *p = q->head, *k;
    while (p) {
        k = p;
        p = p->next;
        freeNode(k);
    }
    free(q);
    return ;
}

int push(Queue *q, int val) {
    if (!q) return 0;
    Node *n = initNode(val);
    //空栈与否
    if (q->tail) {
        q->tail->next = n;
        q->tail = n;
    } else {
        q->head = n;
        q->tail = n;
    }
    return 1;
}

int isEmpty(Queue *q) {
    return !(q && q->head);
}

int pop(Queue *q) {
    Node *k = q->head;
    int tmp = k->val;
    q->head = k->next;
    freeNode(k);
    if (!q->head) q->tail = NULL; // freeNode后队空
    return tmp;
}

void showQueue(Queue *q) {
    if (!q) return ;
    printf("Queue: [");
    Node *p = q->head;
    while (p) {
        printf("%d->", p->val);
        p = p->next;
    }
    printf("NULL]\n");
    return ;
}

int main() {
    srand(time(0));
    Queue *q = initQueue();
    int cnt = 10;
    while (cnt--) {
        int val = rand() % 100;
        int opt = rand() % 4;
        switch (opt) {
            case 0:
            case 1:
            case 2:
                printf("push %d, res = %s\n", val, push(q, val) ? "SUC" : "ERR");
                break;
            case 3:
                isEmpty(q) ? printf("pop nothings~\n") : printf("pop %d\n", pop(q));
                break;
        }
        showQueue(q);
        putchar(10);
    }
    freeQueue(q);
    return 0;
}
savior_xzh
关注
专栏目录
C++数据结构实验二：栈与队列的应用
03-31
2．掌握在两种存储结构上对栈和队列所施加的入栈、出栈、入队和出队的实现。 3.掌握栈和队列的逻辑结构特点、顺序存储结构、链式存储结构、顺序栈和链栈的结构体类型定义、循环队列和链队列的结构体类型定义、栈和...
数据结构栈和队列试题及答案
11-26
### 数据结构之栈和队列知识点详解 #### 一、选择题知识点解析 1. **栈的操作原则** 栈是一种特殊的线性表，它只允许在一端进行插入和删除操作，这一端称为栈顶(top)。另一端称为栈底(bottom)，不允许在其上进行...
数据结构--栈与队列.cpp
03-08
数据结构--栈与队列.cpp
数据结构-栈与队列
01-07
数据结构-栈与队列一、顺序栈1.顺序栈的定义2：入栈二、顺序队列1：顺序栈的定义2：入队3：出队三、链队列1：链队列的定义：2：入队3：出队 一、顺序栈 1.顺序栈的定义 #define MaxSize 64 /* const int MaxSize =64...
数据结构-栈与队列.zip
10-21
在这个"数据结构-栈与队列.zip"的压缩包中，包含了几个关键的知识点，它们都是基于两个基本的数据结构——栈（Stack）和队列（Queue）来展开的。下面将对每个主题进行详细的解释。 1. 栈：栈是一种具有“后进先出”...
从零开始学数据结构系列之第六章《希尔排序》
铁匠匠匠的博客
09-14 565
​ 希尔排序是对插入排序的优化，基本思路是先选定一个整数作为增量，把待排序文件中的所有数据分组，以每个距离的等差数列为一组，对每一组进行排序，然后将增量缩小，继续分组排序，重复上述动作，直到增量缩小为1时，排序完正好有序。​ 我们发现，当被排序的对象越接近有序时，插入排序的效率越高，那我们是否有办法将数组变成接近有序后再用插入排序，此时希尔大佬就发现了这个排序算法，并命名为希尔排序。逆序有序的数组排序时，时间复杂度为O ( n 2 ) O(n^2)O(n 2)，此时效率最低。如果是最开始的分组方法的话。
数据结构 1
2401_83575662的博客
09-14 301
算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为 输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《程序员代码面试指南》。4.算法的效率衡量一个算法的好坏，要从它的程序的时间复杂度和空间复杂度两方面来分析。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。5.时间复杂度。
【JavaScript】数据结构之字典 & 哈希表
票票的博客
09-14 376
数据结构之字典和哈希表
C语言-数据结构 有向图拓扑排序TopologicalSort（邻接表存储）
BamBoo_Bean的博客
09-14 245
C语言-数据结构 有向图拓扑排序TopologicalSort（邻接表存储）
数据结构————栈的讲解(超详细！！！)
braveact的博客
09-11 857
栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出（先进后出）原则。特性与栈的结构有关。
数据结构(7.3_1)——二叉排序树
m0_65240792的博客
09-14 333
又称左子树结点值<根结点值<右子树结点值进行中序遍历，可以得到一个递增的有序序列二叉排序树可用于元素的有序组织，搜索。
树、二叉树、特殊的二叉树（堆）、霍夫曼树
qq_73643693的博客
09-14 843
数据结构与算法之树，该篇文章说明了树的一些用法和基本概念
从0开始的算法（数据结构和算法）基础（十）
Solidao的博客
09-12 799
分治的字面意思是分而治之，将问题进行分化，从而进行处理，最后将结果进行合并。尽量的将问题分的不可以再分，分到和操作系统里面的原语是一样的，用较为多空间进行多线程的并行，节省时间运行。递归调用可能会导致较大的递归开销，特别是在递归深度较大的情况下，可能会导致栈溢出。在某些情况下，分治方法可能会导致对同一子问题的重复计算，从而降低效率。例如，在动态规划问题中，使用简单的分治方法可能会导致大量重复计算。
MATLAB系列02：MATLAB基础
最新发布
lbm666666的博客
09-14 1240
MATLAB 用一种特殊的复杂形式来存储数据，包括了许许多多的细节，例如变量名和变量类型，数组的大小，以及所有变量值。数组中的单个数据是可以被访问的，访问的方法是数组名后带一个括号， 括号内是这个数据所对应行标和列标。在MATLAB中，是区分字母大小的，要小心使用。这个函数一般情况下返回输入向量中的最大值，但是它返回的第二个参数是输入向量中的最大值在向量中的位置。赋值语句有分号和没有分号的区别：如果赋值语句后面没有分号，变量值会自动显示在命令窗口，如果有分号，将会中止变量值在命令窗口的重复。
数据结构与算法 第12天（排序）
2301_79600945的博客
09-08 1341
内部排序：数据量不大、数据在内存，无需内外存交换数据外部排序：数据量较大、数据在外存(文件排序)将数据分批调入内存排序，结果放到外存串行排序：单处理机(同一时刻比较一对元素)并行排序：多处理机(同一时刻比较多对元素)比较排序：用比较的方法插入排序、交换排序、选择排序、归并排序基数排序：不比较元素的大小，仅仅根据元素本身的取值确定其有序位置原地排序：辅助空间用量为O(1)的排序方法。非原地排序：辅助空间用量超过O(1)的排序方法稳定排序：能够使任何数值相等的元素，排序以后相对次序不变。
一天一道算法题day02
m0_74004434的博客
09-06 1652
对于 mm 个数组对 (c[i],b)(c[i],b)，即 (c[1],b),(c[2],b),…,(c[m],b)(c[1],b),(c[2],b),…,(c[m],b) ，根据前面的问题要求，分别计算出它们的答案，最后，你要给出所有答案的总和。注意，数组 c[i]c[i] 是从 aa 数组转化而来的。现在，你需要找到最小的操作次数，使得对于所有的 1≤i≤k1≤i≤k ，都有 ai<biai​<bi​。对于每个测试样例，第一行包含两个整数 n,m，表示数组 a,b的大小，以及元素 a1值的上限。
详解数据结构中的链表结构
Zion__的博客
09-14 668
int data;} Node;// 创建新节点// 在链表头部插入节点// 遍历链表= NULL) {// 输出：1 -> 2 -> 3 -> NULLreturn 0;链表是数据结构中的重要部分，尤其在需要动态管理内存或频繁插入、删除操作的情况下，链表比数组具有更好的性能。链表的多种类型（如单向链表、双向链表、循环链表等）为不同的应用场景提供了灵活性，但也因为其随机访问能力较差、操作复杂性高等缺点，在某些场景下可能不如数组高效。
B站宋红康JAVA基础视频教程（chapter14数据结构与集合源码）
qq_61033357的博客
09-14 847
当要添加第11个元素的时候，底层的elementData数组已满，则需要扩容，默认扩容为原来长度的1.5倍，并将原有数组中的元素赋值到新数组中。当要添加第11个元素的时候，底层的elementData数组已满，则需要扩容，默认扩容为原来长度的1.5倍，并将原有数组中的元素赋值到新数组中。当要添加第11个元素的时候，底层的elementData数组已满，则需要扩容，默认扩容为原来长度的2倍，并将原有数组中的元素赋值到新数组中。所有的value是可重复，无序的。实现List接口，存储有序的，可以重复的数据。
数据结构：单链表
qq_43060884的博客
09-14 370
数组模拟单链表，是不是比结构体好玩？
数据结构精讲：栈与队列的应用解析
"该资源是关于数据结构中的栈与队列的讲解，主要涉及栈的后进先出特性、栈的应用如表达式求值和递归，以及队列的应用如打印杨辉三角形和优先级队列的概念。还提供了一个栈的抽象数据类型模板和顺序栈的具体实现，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值