栈和队列-

最新推荐文章于 2024-08-28 19:22:50 发布
最新推荐文章于 2024-08-28 19:22:50 发布
阅读量874 收藏 17
点赞数 23
文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35621280/article/details/141555059
版权

栈

        栈（Stack）是一种常见的数据结构，遵循后进先出（LIFO，Last In First Out）的原则。这意味着最后进入栈的元素将被最先移除。栈可以比喻为一叠盘子，你只能在顶部放置或移除盘子。

栈的基本操作：

  1. 压栈（Push）：向栈顶插入一个元素。
  2. 出栈（Pop）：从栈顶移除一个元素。
  3. 查看栈顶元素（Peek）：查看栈顶的元素，但不对栈做出任何改变。

栈的特点：

  1. 后进先出（LIFO）：最后压入栈的元素会被最先弹出。
  2. 限制性操作：栈的插入和删除操作仅限制在栈顶。
  3. 内存管理：栈内存是有限的，过多的压栈操作可能导致栈溢出。
  4. 应用广泛：栈在计算机科学中有着广泛的应用，如函数调用、表达式求值、语法分析、撤销操作等。

栈的实现方式：

  1. 数组实现：使用数组来存储栈中的元素。通过维护一个栈顶指针来跟踪栈顶元素。
  2. 链表实现：使用链表来表示栈结构。每个节点包含数据和指向下一个节点的指针。

栈的应用场景：

  1. 函数调用：函数调用时会使用栈来保存调用信息。
  2. 表达式求值：中缀表达式转换为后缀表达式时会用到栈。
  3. 浏览器的后退按钮：浏览历史记录可以使用栈来管理。
  4. 逆序输出：逆序输出字符串或其他数据。
  5. 撤销操作：保存历史状态以便撤销操作。

栈是一种简单但非常有用的数据结构，能够解决许多算法和应用中的问题。

使用数组实现栈

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

#define MAX_SIZE 100

typedef struct {
    int items[MAX_SIZE];
    int top;
} Stack;

// 初始化栈
void initStack(Stack *stack) {
    stack->top = -1;
}

// 判断栈是否为空
int isEmpty(Stack *stack) {
    return stack->top == -1;
}

// 判断栈是否已满
int isFull(Stack *stack) {
    return stack->top == MAX_SIZE - 1;
}

// 入栈操作
void push(Stack *stack, int item) {
    if (!isFull(stack)) {
        stack->items[++stack->top] = item;
    } else {
        printf("Stack is full. Cannot push element.\n");
    }
}

// 出栈操作
int pop(Stack *stack) {
    if (!isEmpty(stack)) {
        return stack->items[stack->top--];
    } else {
        printf("Stack is empty. Cannot pop element.\n");
        return -1;
    }
}

// 查看栈顶元素
int peek(Stack *stack) {
    if (!isEmpty(stack)) {
        return stack->items[stack->top];
    } else {
        printf("Stack is empty. Cannot peek.\n");
        return -1;
    }
}

int main() {
    Stack stack;
    initStack(&stack);

    push(&stack, 1);
    push(&stack, 2);
    push(&stack, 3);

    printf("%d\n", pop(&stack));  // Output: 3
    printf("%d\n", peek(&stack)); // Output: 2

    return 0;
}

使用链表实现栈

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

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

typedef struct {
    Node *top;
} Stack;

// 初始化栈
void initStack(Stack *stack) {
    stack->top = NULL;
}

// 判断栈是否为空
int isEmpty(Stack *stack) {
    return stack->top == NULL;
}

// 入栈操作
void push(Stack *stack, int item) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = item;
    newNode->next = stack->top;
    stack->top = newNode;
}

// 出栈操作
int pop(Stack *stack) {
    if (!isEmpty(stack)) {
        Node *temp = stack->top;
        int item = temp->data;
        stack->top = temp->next;
        free(temp);
        return item;
    } else {
        printf("Stack is empty. Cannot pop element.\n");
        return -1;
    }
}

// 查看栈顶元素
int peek(Stack *stack) {
    if (!isEmpty(stack)) {
        return stack->top->data;
    } else {
        printf("Stack is empty. Cannot peek.\n");
        return -1;
    }
}

int main() {
    Stack stack;
    initStack(&stack);

    push(&stack, 1);
    push(&stack, 2);
    push(&stack, 3);

    printf("%d\n", pop(&stack));  // Output: 3
    printf("%d\n", peek(&stack)); // Output: 2

    return 0;
}

使用数组实现栈的优缺点：

优点：

  1. 简单直观： 数组实现栈相对简单直观，易于理解和实现。
  2. 随机访问： 数组支持随机访问，可以直接通过索引访问栈中的元素。
  3. 空间效率高： 数组在内存中是连续存储的，不需要额外的指针存储空间。

缺点：

  1. 固定大小： 数组实现的栈大小通常是固定的，无法动态扩展，可能会导致栈溢出。
  2. 复杂度高： 在数组实现中，插入和删除元素的操作可能需要移动大量元素，时间复杂度为 O(n)。
  3. 浪费空间： 如果栈大小预先设定过大，可能会浪费内存空间。

使用链表实现栈的优缺点：

优点：

  1. 动态大小： 链表实现的栈大小可以动态增长或缩小，更加灵活。
  2. 插入删除高效： 在链表中插入和删除元素的操作时间复杂度为 O(1)，不需要移动其他元素。
  3. 不会栈溢出： 链表实现的栈不会固定大小，不存在栈溢出的问题。

缺点：

  1. 额外空间开销： 链表实现需要额外的指针空间存储节点间的连接关系，占用更多的内存。
  2. 不支持随机访问： 链表不支持直接随机访问元素，需要从头节点开始遍历到目标节点。
  3. 复杂度较高： 链表的实现相对复杂一些，需要处理节点之间的链接关系。

        根据需要选择数组或链表实现栈，如果需要动态大小和高效的插入删除操作，链表实现可能更合适；如果栈大小固定且随机访问较为频繁，数组实现可能更适合。

队列

        队列是一种常用的数据结构，遵循先进先出（First In First Out，FIFO）的原则。在队列中，数据项按照其进入队列的顺序进行处理，即最先进入队列的元素最先被取出，类似于现实生活中排队等候的场景。

队列的基本概念：

  1. 入队（Enqueue）： 向队列的末尾添加元素的操作。
  2. 出队（Dequeue）： 从队列的头部移除元素的操作。
  3. 队首（Front）： 队列中的第一个元素。
  4. 队尾（Rear）： 队列中的最后一个元素。
  5. 空队列（Empty Queue）： 不包含任何元素的队列。
  6. 满队列（Full Queue）： 队列已达到最大容量，无法再添加新元素。

队列的结构：

队列通常有两种主要的实现方式：数组（顺序队列）和链表（链式队列）。

  1. 数组实现的队列（顺序队列）：

    • 使用数组作为底层存储结构，通过两个指针 front 和 rear 分别指示队头和队尾位置。
    • 入队时将元素添加到 rear 指向的位置，出队时从 front 指向的位置移除元素。
    • 队列满时可能需要进行元素搬移操作。

  2. 链表实现的队列（链式队列）：

    • 使用链表作为底层存储结构，每个节点包含数据和指向下一个节点的指针。
    • 队列的头部由头指针指示，尾部由尾指针指示。
    • 入队时在链表尾部添加新节点，出队时从链表头部移除节点。
    • 链式队列不会存在队列满的情况，可以动态地增加或减少元素。

        无论是数组实现还是链表实现，队列都是一种非常有用的数据结构，常用于模拟排队、任务调度等场景，在计算机科学中有着广泛的应用。

使用数组实现队列 

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

#define MAX_SIZE 100

typedef struct {
    int items[MAX_SIZE];
    int front;
    int rear;
} Queue;

void initQueue(Queue *queue) {
    queue->front = -1;
    queue->rear = -1;
}

int isEmpty(Queue *queue) {
    return queue->front == -1;
}

int isFull(Queue *queue) {
    return (queue->front == 0 && queue->rear == MAX_SIZE - 1) || (queue->front == queue->rear + 1);
}

void enqueue(Queue *queue, int item) {
    if (isFull(queue)) {
        printf("Queue is full. Cannot enqueue element.\n");
    } else {
        if (isEmpty(queue)) {
            queue->front = 0;
            queue->rear = 0;
        } else if (queue->rear == MAX_SIZE - 1) {
            queue->rear = 0;
        } else {
            queue->rear++;
        }
        queue->items[queue->rear] = item;
    }
}

int dequeue(Queue *queue) {
    int item;
    if (isEmpty(queue)) {
        printf("Queue is empty. Cannot dequeue element.\n");
        return -1;
    } else {
        item = queue->items[queue->front];
        if (queue->front == queue->rear) {
            queue->front = -1;
            queue->rear = -1;
        } else if (queue->front == MAX_SIZE - 1) {
            queue->front = 0;
        } else {
            queue->front++;
        }
        return item;
    }
}

int peek(Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue is empty. Cannot peek.\n");
        return -1;
    } else {
        return queue->items[queue->front];
    }
}

int main() {
    Queue queue;
    initQueue(&queue);

    enqueue(&queue, 1);
    enqueue(&queue, 2);
    enqueue(&queue, 3);

    printf("%d\n", dequeue(&queue));  // Output: 1
    printf("%d\n", peek(&queue));     // Output: 2

    return 0;
}

使用链表实现队列

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

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

typedef struct {
    Node *front;
    Node *rear;
} Queue;

void initQueue(Queue *queue) {
    queue->front = NULL;
    queue->rear = NULL;
}

int isEmpty(Queue *queue) {
    return queue->front == NULL;
}

void enqueue(Queue *queue, int item) {
    Node *newNode = (Node *)malloc(sizeof(Node));
    newNode->data = item;
    newNode->next = NULL;
    
    if (isEmpty(queue)) {
        queue->front = newNode;
    } else {
        queue->rear->next = newNode;
    }
    queue->rear = newNode;
}

int dequeue(Queue *queue) {
    int item;
    if (isEmpty(queue)) {
        printf("Queue is empty. Cannot dequeue element.\n");
        return -1;
    } else {
        Node *temp = queue->front;
        item = temp->data;
        queue->front = temp->next;
        free(temp);
        if (queue->front == NULL) {
            queue->rear = NULL;
        }
        return item;
    }
}

int peek(Queue *queue) {
    if (isEmpty(queue)) {
        printf("Queue is empty. Cannot peek.\n");
        return -1;
    } else {
        return queue->front->data;
    }
}

int main() {
    Queue queue;
    initQueue(&queue);

    enqueue(&queue, 1);
    enqueue(&queue, 2);
    enqueue(&queue, 3);

    printf("%d\n", dequeue(&queue));  // Output: 1
    printf("%d\n", peek(&queue));     // Output: 2

    return 0;
}

循环队列

        循环队列（Circular Queue）是一种队列的实现方式，通过在数组或链表的结构中建立循环链接，使得队列在到达结尾时能够回到开头，实现队列空间的循环利用。循环队列避免了普通队列在出队操作后可能出现的空闲位置无法再次利用的问题，提高了队列的空间利用效率。

循环队列的特点：

  1. 循环利用空间： 循环队列通过循环链接的方式，实现队列空间的循环利用，避免了普通队列可能出现的空闲位置无法再次利用的问题。

  2. 指针循环移动： 循环队列中的队头和队尾指针在操作时会进行循环移动，确保在数组或链表结构中正确地循环遍历。

  3. 解决队列空间不足问题： 循环队列能够更高效地利用队列的空间，避免了队列空间不足的问题，使得队列能够继续接收新的元素。

实现循环队列的关键操作：

  1. 初始化队列： 初始化队列时，需要设置队头和队尾指针，通常初始时都指向 -1。

  2. 入队操作： 将元素添加到队列的尾部，同时移动队尾指针，确保循环移动到数组或链表的开头。

  3. 出队操作： 从队列的头部移除元素，同时移动队头指针，确保循环移动到数组或链表的开头。

  4. 判断队列是否为空或已满： 需要实现判断队列是否为空和是否已满的函数，避免非法操作。

        循环队列是一种重要的数据结构，在计算机科学中有着广泛的应用，特别适用于需要高效利用空间并且要求元素有序进出的场景。

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

#define MAX_SIZE 5

typedef struct {
    int items[MAX_SIZE];
    int front, rear;
    int size;
} CircularQueue;

// 初始化循环队列
void initQueue(CircularQueue *queue) {
    queue->front = -1;  // 初始化队列头指针
    queue->rear = -1;   // 初始化队列尾指针
    queue->size = 0;    // 初始化队列大小
}

// 判断队列是否已满
int isFull(CircularQueue *queue) {
    return (queue->front == 0 && queue->rear == MAX_SIZE - 1) || (queue->front == queue->rear + 1);
}

// 判断队列是否为空
int isEmpty(CircularQueue *queue) {
    return queue->front == -1;
}

// 入队操作
void enqueue(CircularQueue *queue, int item) {
    if (isFull(queue)) {
        printf("Queue is full. Cannot enqueue element.\n");
    } else {
        if (queue->front == -1) {
            queue->front = 0;
        }
        queue->rear = (queue->rear + 1) % MAX_SIZE; // 循环移动尾指针
        queue->items[queue->rear] = item;
        queue->size++;
    }
}

// 出队操作
int dequeue(CircularQueue *queue) {
    int item;
    if (isEmpty(queue)) {
        printf("Queue is empty. Cannot dequeue element.\n");
        return -1;
    } else {
        item = queue->items[queue->front];
        if (queue->front == queue->rear) {
            queue->front = -1;
            queue->rear = -1;
        } else {
            queue->front = (queue->front + 1) % MAX_SIZE; // 循环移动头指针
        }
        queue->size--;
        return item;
    }
}

// 获取队首元素
int peek(CircularQueue *queue) {
    if (isEmpty(queue)) {
        printf("Queue is empty. Cannot peek.\n");
        return -1;
    } else {
        return queue->items[queue->front];
    }
}

int main() {
    CircularQueue queue;
    initQueue(&queue);

    enqueue(&queue, 1);
    enqueue(&queue, 2);
    enqueue(&queue, 3);

    printf("%d\n", dequeue(&queue));  // 输出：1
    printf("%d\n", peek(&queue));     // 输出：2

    return 0;
}

在循环队列的实现中，需要注意：

  • 使用取模运算来实现队列头尾指针的循环移动，确保在数组边界处正确循环。
  • 队列为空时，front 和 rear 都指向 -1；队列满时，满足 (front == 0 && rear == MAX_SIZE - 1) 或 (front == rear + 1)。
  • 当 front 和 rear 相等时，表示队列中只有一个元素。

胖提莫
关注
  • 23
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构---第三章栈和队列---队列---选择题
programmer9的博客
05-19 840
数据结构---第三章栈和队列---队列---选择题
数据结构-栈和队列-PPT
02-04
"数据结构-栈和队列-PPT" 数据结构中栈和队列是两种常用的线性表结构，下面对它们的定义、特点和应用进行详细介绍。 栈的定义和特点 栈是一种只能在一端（栈顶）进行插入和删除运算的线性表。栈的逻辑结构与...
栈和队列-----顺序栈
m0_62538383的博客
02-22 7033
1.栈和队列在物理结构上是顺序表 2.typedef关键字详解 此种情况不加typedef 名称写在上面SeqList代表类型名 此种情况不加typedef SeqList 代表全局结构体变量 结构体为无名结构体 上面两种情况的SeqList代表类型名 第一种写的时候直接SeqList XXX 第二种写的时候struct SeqList XXX 类型名相当于给struct Seqlist 起了一一个别名 4.栈顶指针指向的位置没有数据元素 5.卧槽 顺序栈终于...
栈和队列--基本操作
weixin_62580505的博客
02-07 1619
本节目标 学习栈的原理及基本实现 学习队列的原理及基本实现 栈： 一种特殊的线性表，其只允许在固定一端进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出 LIFO （Last In First Out) 的原则。 压栈：栈的插入操作叫做进栈，压栈，入栈，入数据在栈顶。 出栈：栈的删除操作叫做出栈。 出数据在栈顶。 实现 1.利用顺序表实现，即使用尾插 + 尾删的方式实现 2.利用链表实现，即头尾皆可 但相对来说，顺序表的实.
数据结构之栈和队列 - 超详细的教程，手把手教你认识并运用栈和队列
ミカミミミ博客
09-05 1011
数据结构之栈和队列 - 超详细的教程，手把手教你认识并运用栈和队列。
第三章栈和队列-作业题
weixin_52326703的博客
10-17 3686
第三章栈和队列-作业题1.栈和列队的基本概念6-1 使用栈完成回文判断 (12 分)6-2 判断表达式中括号是否匹配 (12 分)6-3 队列的操作集合（带尾指针的循环链表） (18 分)6-4 循环队列的操作集合（只设 rear和quelen） (18 分)6-5 循环队列的操作集合（增设tag） (18 分) 1.栈和列队的基本概念 2-1 若元素a,b,c,d,e,f依次进栈，允许进栈、退栈操作交替进行，但不允许连续三次进行退栈操作，则不可能得到的出栈序列是（D ）。 (2分) A.d,c,e,b,f
03-栈和队列-11
08-03
数据结构中的栈和队列是两种基础且重要的抽象数据类型，它们在计算机科学和软件工程中扮演着核心角色。栈通常被称为“后进先出”（LIFO, Last In First Out）的数据结构，而队列则被称为“先进先出”（FIFO, First ...
04-栈和队列-21
08-04
在IT领域，数据结构是编程基础中的重要组成部分，而栈和队列是两种最基本的数据结构。本节主要探讨了它们的特性和应用，并且通过扩展讨论了如何利用栈和队列解决更复杂的问题。 首先，栈是一种后进先出（LIFO）的...
数据结构之栈和队列-思路清晰纯C
08-31
队列 循环队列 栈 内容学习于 https://www.bilibili.com/video/BV1W64y1z7jh?p=19&spm_id_from=pageDriver&vd_source=4d33bf4ac4499f2c0370694554a02fa5
数据结构课件、代码第3章栈和队列-81-3.ppt
09-28
数据结构中的栈和队列是两种非常基础且重要的数据结构，它们都是线性表的特殊形式，但在操作上有所限制。栈被称为后进先出（LIFO）结构，而队列则是先进先出（FIFO）结构。在本章中，我们将主要探讨栈的定义、顺序栈...
Python-MNE-源定位和逆问题01：源估计（SourceEstimate）数据结构
weixin_58312922的博客
08-25 665
stc是MNE-Python的一个类，表示从源估计中获得的转换的时间序列。对于两个半球，数据分别存储在和中，储存形式为的形式为一个m*n的矩阵，m是这个半球的空间位置的数量，n是时间点的个数。和对应和。这些是表面表征的位置索引。表面的坐标存储在和中，分别表示左半球和右半球。
集合及数据结构第十节（下）————常用接口介绍、堆的应用和java对象的比较
2301_79418684的博客
08-25 806
常用接口介绍和堆的应用 1. PriorityQueue的特性 2. .PriorityQueue常用接口介绍 3. top-k问题 4. 堆排序 5. PriorityQueue中插入对象 6. 元素的比较 7. .对象的比较 8. .集合框架中PriorityQueue的比较方式
【数据结构】队列(Queue)
xiaochuan_bsj的博客
08-28 556
数组，双链表实现队列，附完整代码
数据结构之链表
WSH2012ffff的博客
08-27 618
本文从链表的定义、创建、遍历、插入、删除等多个方面进行了详细讲解，希望能够帮助大家更好地理解和掌握c/c++语言中的链表操作。链表是一种动态数据结构，由节点组成，每个节点包含一个数据元素和一个指向下一个节点的指针。链表是计算机科学中常见的一种数据结构，c/c++语言中也有着丰富的链表操作函数库。在c/c++中，可以使用结构体来定义一个节点，并用指针来表示节点之间的关系，从而实现链表。链表遍历是指按照一定的顺序依次访问链表中的每一个节点。链表删除是指在链表中删除一个节点。
Linux 数据结构 链表
mxyzhy的博客
08-28 225
单向链表操作
数据结构之AVL树的 “奥秘“
robin_suli的博客
08-23 798
对有n个结点的二叉搜索树，若每个元素查找的概率相等，则二叉搜索在二叉搜索树树平均查找长度是结点的深度的函数，即结点越深，则比较次数越多。如果需要 一种查询高效且有序的数据结构，而且数据的个数为静态的(即不会改变)，可以考虑AVL树，但一个结构经常修 改，就不太适合。如果数据有序或接近有序二叉搜索树将退化为单支树，查找元素相当于在顺 序表中搜索元素，效率低下。保证每个结点的左右子树高度之差的绝对值不超过 1。情况一：subLR平衡因子等于-1。情况二：subLR平衡因子等于1。subLR的平衡因子区分情况。
浅谈【数据结构】树与二叉树二
weixin_67526434的博客
08-25 1164
浅谈【数据结构】树与二叉树二
数据结构：单向链表
最新发布
m0_64378221的博客
08-28 346
pTmpNode负责遍历后面的节点，当找到比pMinNode节点更小的值时，更新pMinNode,然后比较pSwapNode与pMinNode值的大小，将小的值存放在pSwapNode节点的数据中，pSwap再指向像一个节点，进行下一轮比较。将一个指针从第一个节点向后走，将一个指针从相遇点向后走，两个指针相遇的位置即为环入口的位置。快指针每次走2步,慢指针每次走1步,快慢指针相遇则说明有环。慢指针和快指针每次走1步(快指针总是领先慢指针k步)快指针到达末尾时，慢指针所在的位置即为中间位置。
数据结构总结
2301_78622258的博客
08-24 596
对单链表，循环链表的实现，顺序栈，链栈的实现过程
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值