【Hello算法】 ＞ 第 3 关 ＞栈与队列

已于 2024-04-22 11:54:20 修改
阅读量566 收藏 16
点赞数 10
分类专栏： 【Hello 算法】速通锦集 数据结构 算法 文章标签： 算法 c++ 数据结构 链表
于 2024-04-22 11:53:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_45695811/article/details/138059730
版权

数据结构 之 数组与链表


———————————————————————————————————————————————————————————-
————————————————————Hello算法—速通笔记—第三集—start———————–———————————————-

1 栈 / 栈的常见操作、实现、应用

栈（stack）是一种遵循 先入后出 逻辑的线性数据结构。
堆叠元素的顶部称为 “栈顶”，底部称为“栈底”。将把元素添加到栈顶的操作叫作“入栈”，删除栈顶元素的操作叫作“出栈”。
在这里插入图片描述

栈的常用操作
在这里插入图片描述

/* 初始化栈 */
stack<int> stack;
/* 元素入栈 */
stack.push(1);
stack.push(3);
stack.push(2);
stack.push(5);
stack.push(4);

/* 访问栈顶元素 */
int top = stack.top();
/* 元素出栈 */
stack.pop(); // 无返回值
/* 获取栈的长度 */
int size = stack.size();
/* 判断是否为空 */
bool empty = stack.empty();

栈的实现：
栈可以视为一种受限制的数组或链表。

/* 基于链表实现的栈 */
class LinkedListStack {
  private:
    ListNode *stackTop; // 将头节点作为栈顶
    int stkSize;        // 栈的长度
  public:
    LinkedListStack() {
        stackTop = nullptr;
        stkSize = 0;
    }
    ~LinkedListStack() {
        // 遍历链表删除节点，释放内存
        freeMemoryLinkedList(stackTop);
    }
    /* 获取栈的长度 */
    int size() {     return stkSize;    }
    /* 判断栈是否为空 */
    bool isEmpty() {      return size() == 0;    }
    /* 入栈 */
    void push(int num) {
        ListNode *node = new ListNode(num);
        node->next = stackTop;
        stackTop = node;
        stkSize++;
    }
    /* 出栈 */
    int pop() {
        int num = top();
        ListNode *tmp = stackTop;
        stackTop = stackTop->next;
        // 释放内存
        delete tmp;
        stkSize--;
        return num;
    }
    /* 访问栈顶元素 */
    int top() {
        if (isEmpty())
            throw out_of_range("栈为空");
        return stackTop->val;
    }
    /* 将 List 转化为 Array 并返回 */
    vector<int> toVector() {
        ListNode *node = stackTop;
        vector<int> res(size());
        for (int i = res.size() - 1; i >= 0; i--) {
            res[i] = node->val;
            node = node->next;
        }
        return res;
    }
};

/* 基于数组实现的栈 */
class ArrayStack {
  private:
    vector<int> stack;
  public:
    /* 获取栈的长度 */
    int size() {     return stack.size();    }
    /* 判断栈是否为空 */
    bool isEmpty() {      return stack.size() == 0;    }
    /* 入栈 */
    void push(int num) {      stack.push_back(num);    }
    /* 出栈 */
    int pop() {
        int num = top();
        stack.pop_back();
        return num;
    }
    /* 访问栈顶元素 */
    int top() {
        if (isEmpty())
            throw out_of_range("栈为空");
        return stack.back();
    }
    /* 返回 Vector */
    vector<int> toVector() {     return stack;    }
};

对比两种实现：
时间效率：
基于数组实现的栈在触发扩容时效率会降低，但由于扩容是低频操作，因此平均效率更高。
基于链表实现的栈可以提供更加稳定的效率表现。
空间效率：
基于数组实现的栈可能造成一定的空间浪费。
由于链表节点需要额外存储指针，因此链表节点占用的空间相对较大。需要针对具体情况进行分析。
栈的应用：

  • 浏览器中的后退与前进、软件中的撤销与反撤销。
  • 程序内存管理。

2 队列 /队列的常见操作、实现、应用

队列（queue）是一种遵循 先入先出 规则的线性数据结构。
在这里插入图片描述队列的常见操作与实现

/* 初始化队列 */
queue<int> queue;
/* 元素入队 */
queue.push(1);
queue.push(3);
queue.push(2);
queue.push(5);
queue.push(4);

/* 访问队首元素 */
int front = queue.front();
/* 元素出队 */
queue.pop();
/* 获取队列的长度 */
int size = queue.size();
/* 判断队列是否为空 */
bool empty = queue.empty();

/* 基于链表实现的队列 */
class LinkedListQueue {
  private:
    ListNode *front, *rear; // 头节点 front ，尾节点 rear
    int queSize;
  public:
    LinkedListQueue() {
        front = nullptr;
        rear = nullptr;
        queSize = 0;
    }
    ~LinkedListQueue() {
        // 遍历链表删除节点，释放内存
        freeMemoryLinkedList(front);
    }
    /* 获取队列的长度 */
    int size() {     return queSize;    }
    /* 判断队列是否为空 */
    bool isEmpty() {      return queSize == 0;    }
    /* 入队 */
    void push(int num) {
        // 在尾节点后添加 num
        ListNode *node = new ListNode(num);
        // 如果队列为空，则令头、尾节点都指向该节点
        if (front == nullptr) {
            front = node;
            rear = node;
        }
        // 如果队列不为空，则将该节点添加到尾节点后
        else {
            rear->next = node;
            rear = node;
        }
        queSize++;
    }
    /* 出队 */
    int pop() {
        int num = peek();
        // 删除头节点
        ListNode *tmp = front;
        front = front->next;
        // 释放内存
        delete tmp;
        queSize--;
        return num;
    }
    /* 访问队首元素 */
    int peek() {
        if (size() == 0)
            throw out_of_range("队列为空");
        return front->val;
    }
    /* 将链表转化为 Vector 并返回 */
    vector<int> toVector() {
        ListNode *node = front;
        vector<int> res(size());
        for (int i = 0; i < res.size(); i++) {
            res[i] = node->val;
            node = node->next;
        }
        return res;
    }
};

/* 基于环形数组实现的队列 */
class ArrayQueue {
  private:
    int *nums;       // 用于存储队列元素的数组
    int front;       // 队首指针，指向队首元素
    int queSize;     // 队列长度
    int queCapacity; // 队列容量
  public:
    ArrayQueue(int capacity) {
        // 初始化数组
        nums = new int[capacity];
        queCapacity = capacity;
        front = queSize = 0;
    }
    ~ArrayQueue() {     delete[] nums;    }
    /* 获取队列的容量 */
    int capacity() {      return queCapacity;    }
    /* 获取队列的长度 */
    int size() {        return queSize;    }
    /* 判断队列是否为空 */
    bool isEmpty() {      return size() == 0;    }
    /* 入队 */
    void push(int num) {
        if (queSize == queCapacity) {
            cout << "队列已满" << endl;
            return;
        }
        // 计算队尾指针，指向队尾索引 + 1
        // 通过取余操作实现 rear 越过数组尾部后回到头部
        int rear = (front + queSize) % queCapacity;
        // 将 num 添加至队尾
        nums[rear] = num;
        queSize++;
    }
    /* 出队 */
    int pop() {
        int num = peek();
        // 队首指针向后移动一位，若越过尾部，则返回到数组头部
        front = (front + 1) % queCapacity;
        queSize--;
        return num;
    }
    /* 访问队首元素 */
    int peek() {
        if (isEmpty())
            throw out_of_range("队列为空");
        return nums[front];
    }
    /* 将数组转化为 Vector 并返回 */
    vector<int> toVector() {
        // 仅转换有效长度范围内的列表元素
        vector<int> arr(queSize);
        for (int i = 0, j = front; i < queSize; i++, j++) {
            arr[i] = nums[j % queCapacity];
        }
        return arr;
    }
};

应用·：

  • 淘宝订单
  • 各类待办事项

3 双向队列

双向队列（double-ended queue）提供了更高的灵活性，允许在头部和尾部执行元素的添加或删除操作。
常用操作
在这里插入图片描述

/* 初始化双向队列 */
deque<int> deque;
/* 元素入队 */
deque.push_back(2);   // 添加至队尾
deque.push_back(5);
deque.push_back(4);
deque.push_front(3);  // 添加至队首
deque.push_front(1);
/* 访问元素 */
int front = deque.front(); // 队首元素
int back = deque.back();   // 队尾元素
/* 元素出队 */
deque.pop_front();  // 队首元素出队
deque.pop_back();   // 队尾元素出队
/* 获取双向队列的长度 */
int size = deque.size();
/* 判断双向队列是否为空 */
bool empty = deque.empty();

实现

/* 双向链表节点 */
struct DoublyListNode {
    int val;              // 节点值
    DoublyListNode *next; // 后继节点指针
    DoublyListNode *prev; // 前驱节点指针
    DoublyListNode(int val) : val(val), prev(nullptr), next(nullptr) {
    }
};
/* 基于双向链表实现的双向队列 */
class LinkedListDeque {
  private:
    DoublyListNode *front, *rear; // 头节点 front ，尾节点 rear
    int queSize = 0;              // 双向队列的长度
  public:
    /* 构造方法 */
    LinkedListDeque() : front(nullptr), rear(nullptr) {
    }
    /* 析构方法 */
    ~LinkedListDeque() {
        // 遍历链表删除节点，释放内存
        DoublyListNode *pre, *cur = front;
        while (cur != nullptr) {
            pre = cur;
            cur = cur->next;
            delete pre;
        }
    }
    /* 获取双向队列的长度 */
    int size() {      return queSize;    }
    /* 判断双向队列是否为空 */
    bool isEmpty() {       return size() == 0;    }
    /* 入队操作 */
    void push(int num, bool isFront) {
        DoublyListNode *node = new DoublyListNode(num);
        // 若链表为空，则令 front 和 rear 都指向 node
        if (isEmpty())
            front = rear = node;
        // 队首入队操作
        else if (isFront) {
            // 将 node 添加至链表头部
            front->prev = node;
            node->next = front;
            front = node; // 更新头节点
        // 队尾入队操作
        } else {
            // 将 node 添加至链表尾部
            rear->next = node;
            node->prev = rear;
            rear = node; // 更新尾节点
        }
        queSize++; // 更新队列长度
    }
    /* 队首入队 */
    void pushFirst(int num) {       push(num, true);    }
    /* 队尾入队 */
    void pushLast(int num) {        push(num, false);    }
    /* 出队操作 */
    int pop(bool isFront) {
        if (isEmpty())
            throw out_of_range("队列为空");
        int val;
        // 队首出队操作
        if (isFront) {
            val = front->val; // 暂存头节点值
            // 删除头节点
            DoublyListNode *fNext = front->next;
            if (fNext != nullptr) {
                fNext->prev = nullptr;
                front->next = nullptr;
            }
            delete front;
            front = fNext; // 更新头节点
        // 队尾出队操作
        } else {
            val = rear->val; // 暂存尾节点值
            // 删除尾节点
            DoublyListNode *rPrev = rear->prev;
            if (rPrev != nullptr) {
                rPrev->next = nullptr;
                rear->prev = nullptr;
            }
            delete rear;
            rear = rPrev; // 更新尾节点
        }
        queSize--; // 更新队列长度
        return val;
    }
    /* 队首出队 */
    int popFirst() {       return pop(true);    }
    /* 队尾出队 */
    int popLast() {    return pop(false);    }
    /* 访问队首元素 */
    int peekFirst() {
        if (isEmpty())
            throw out_of_range("双向队列为空");
        return front->val;
    }
    /* 访问队尾元素 */
    int peekLast() {
        if (isEmpty())
            throw out_of_range("双向队列为空");
        return rear->val;
    }
    /* 返回数组用于打印 */
    vector<int> toVector() {
        DoublyListNode *node = front;
        vector<int> res(size());
        for (int i = 0; i < res.size(); i++) {
            res[i] = node->val;
            node = node->next;
        }
        return res;
    }
};

/* 基于环形数组实现的双向队列 */
class ArrayDeque {
  private:
    vector<int> nums; // 用于存储双向队列元素的数组
    int front;        // 队首指针，指向队首元素
    int queSize;      // 双向队列长度
  public:
    /* 构造方法 */
    ArrayDeque(int capacity) {
        nums.resize(capacity);
        front = queSize = 0;
    }
    /* 获取双向队列的容量 */
    int capacity() {
        return nums.size();
    }
    /* 获取双向队列的长度 */
    int size() {
        return queSize;
    }
    /* 判断双向队列是否为空 */
    bool isEmpty() {
        return queSize == 0;
    }
    /* 计算环形数组索引 */
    int index(int i) {
        // 通过取余操作实现数组首尾相连
        // 当 i 越过数组尾部后，回到头部
        // 当 i 越过数组头部后，回到尾部
        return (i + capacity()) % capacity();
    }
    /* 队首入队 */
    void pushFirst(int num) {
        if (queSize == capacity()) {
            cout << "双向队列已满" << endl;
            return;
        }
        // 队首指针向左移动一位
        // 通过取余操作实现 front 越过数组头部后回到尾部
        front = index(front - 1);
        // 将 num 添加至队首
        nums[front] = num;
        queSize++;
    }
    /* 队尾入队 */
    void pushLast(int num) {
        if (queSize == capacity()) {
            cout << "双向队列已满" << endl;
            return;
        }
        // 计算队尾指针，指向队尾索引 + 1
        int rear = index(front + queSize);
        // 将 num 添加至队尾
        nums[rear] = num;
        queSize++;
    }
    /* 队首出队 */
    int popFirst() {
        int num = peekFirst();
        // 队首指针向后移动一位
        front = index(front + 1);
        queSize--;
        return num;
    }
    /* 队尾出队 */
    int popLast() {
        int num = peekLast();
        queSize--;
        return num;
    }
    /* 访问队首元素 */
    int peekFirst() {
        if (isEmpty())
            throw out_of_range("双向队列为空");
        return nums[front];
    }
    /* 访问队尾元素 */
    int peekLast() {
        if (isEmpty())
            throw out_of_range("双向队列为空");
        // 计算尾元素索引
        int last = index(front + queSize - 1);
        return nums[last];
    }
    /* 返回数组用于打印 */
    vector<int> toVector() {
        // 仅转换有效长度范围内的列表元素
        vector<int> res(queSize);
        for (int i = 0, j = front; i < queSize; i++, j++) {
            res[i] = nums[index(j)];
        }
        return res;
    }
};

应用

  • 双向队列兼具栈与队列的逻辑，因此它可以实现这两者的所有应用场景，同时提供更高的自由度。

4 Tips

  1. 浏览器的前进后退功能本质上是“栈”的体现。
  2. 在出栈后，如果后续仍需要使用弹出节点则不需要释放内存，反之则c/c++需要手动释放内存。
  3. 双向队列表现的是栈+队列的逻辑，可实现栈与队列的所有应用，且更灵活。
  4. 撤销（undo）与反撤销（redo）的实现：
    使用两个栈，栈 A 用于撤销，栈 B 用于反撤销。
    每当用户执行一个操作，将这个操作压入栈 A ，并清空栈 B 。
    当用户执行“撤销”时，从栈 A 中弹出最近的操作，并将其压入栈 B 。
    当用户执行“反撤销”时，从栈 B 中弹出最近的操作，并将其压入栈 A 。

————————————————————————————————————————————————————————————
—————————————————————Hello算法—速通笔记—第三集—end—————————————————————–—-

Qiqy
关注
  • 10
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
第三章 栈和队列（含答案）
m0_56698045的博客
12-13 2047
栈和队列含答案 ## 栈和队列含答案 第3章 栈和队列 一、填空题 1. 向量、栈和队列都是 线性 结构，可以在向量的 任何 位置插入和删除元素；对于栈只能在 栈顶 插入和删除元素；对于队列只能在 队尾 插入和 队首 删除元素。 2. 栈是一种特殊的线性表，允许插入和删除运算的一端称为 栈顶 。不允许插入和删除运算的一端称为 栈底 。 3. 队列 是被限定为只能在表的一端进行插入运算，在表的另一端进行
第三章 栈与队列
icepointLine的专栏
07-16 1205
第三章   栈与队列 一、栈 1.栈：只能在表尾进行插入和删除操作的线性表       允许插入和删除的一端称为栈顶，另一端为栈底 2.栈的操作特性：线性关系；后进先出 3.顺序栈：是栈的顺序存储结构，是顺序表的简化 栈底—>数组下标为0的一端 top指针—>栈顶元素在数组中的位置 4.顺序栈的栈空和栈满条件 栈空：top=-1      栈满：top=StackSize-1
代码随想录 Day8 栈(FILO)与队列(FIFO) LeetCode T232 用栈实现队列 LeetCodeT225 用队列实现栈
qiuqiushuibx的博客
10-02 218
栈和队列都是大家不陌生的数据结构,我们之前的栈和队列一般是用数组或链表来实现的 ,这里我们给出实现方式,用于帮助更好的理解.
数据结构与算法-Part4——栈与队列
leikang111的博客
04-09 2157
C#栈与队列全收录!
第3章 栈和队列
kingKINGabduxhbs的博客
08-13 1101
第3章栈和队列栈1.知识点提要1.栈的定义及基本运算2.栈的混洗3.栈的顺序存储结构1.顺序栈的两种存储分配1.静态存储分配2.动态存储分配2.两种进栈和出栈处理3.两个顺序栈共用一个存储空间4.栈的链式存储结构5.理解栈的存储结构的要点 栈 1.知识点提要 1.栈的定义及基本运算 2.栈的混洗 问：如果列车按照1，2，3，，，n进站，那么有多少种情况出栈？不可能的情况有多少种？ 答：根据ca...
Hello 算法.pdf
11-13
数据结构是算法学习的基础，包括数组、链表、栈、队列、树、图等。了解数据结构的特点和应用场景，是学习算法的前提。 知识点三：算法设计的基本原则 算法设计需要遵循一定的基本原则，包括时间复杂度、空间复杂度...
《Hello 算法》：动画图解、一键运行的数据结构与算法教程，支持 Java
01-14
《Hello 算法》是一本独特且互动性强的教程，专为学习数据结构与算法设计。通过动画图解和一键运行的特性，它提供了一种直观、实践性极强的学习方式，使得初学者和有经验的开发者都能深入理解这些核心计算机科学概念...
go版本的hello算法
03-05
- **数据结构分类**：介绍了不同类型的数据结构，如数组、链表、栈、队列、树和图等，并讨论了它们的特点和适用场景。 ### 四、学习资源与支持 - **源代码仓库**: 本书的所有代码均托管在GitHub仓库([github....
Hello 算法 C++ 语言版
10-10
书的内容涵盖了从基本数据结构如数组、链表、栈、队列，到高级算法如排序、搜索、图论等。每章不仅介绍概念，还会通过实例和练习题帮助读者巩固理解。通过本书，读者不仅可以学习到C++语言中的算法实现，还能培养...
hello-algo-数据结构与算法-zh-csharp.pdf
01-24
本书的内容涵盖了数据结构与算法的基础知识，包括数组、链表、栈、队列、树、图等数据结构，以及排序、查找、图形遍历等算法。书中还提供了大量的编程实践和习题，帮助读者更好地掌握数据结构与算法的知识。 本书的...
备战秋招60天算法挑战，Day17
溜达虎的博客
08-13 355
给定两个字符串 和 ，编写一个函数来判断 是否是 的字母异位词。注意： 若 和 中每个字符出现的次数都相同，则称 和 互为字母异位词。举个例子： 视频题解 有效的字母异位词 思路来源 思路来源 思路解析 方法一 排序 分别对和进行排序，然后比较排序后的字符串是否相等。 java代码 python代码 复杂度分析 时间复杂度： 快排的时间复杂度是O(nlogn)，其中是字符串的长度。空间复杂度： 快排的空间复杂度是O(logn)。假设， 。 java代码 python代码 复杂度分析 时
haproxy算法与具体实现
K1487994142的博客
08-11 979
负载均衡：Load Balance，简称LB，是一种服务或基于硬件设备等实现的高可用反向代理技术，负载均 衡将特定的业务(web服务、网络流量等)分担给指定的一个或多个后端特定的服务器或设备，从而提高了 公司业务的并发处理能力、保证了业务的高可用性、方便了业务后期的水平动态扩展。
【LeetCode】字母异位词分组
LittleFishC的博客
08-14 147
使用unordered_map（哈希表）将排序后的字符串映射到一个字符串列表中。哈希表的键是排序后的字符串，值是所有与该键对应的原始字符串组成的列表。输入: strs = [“eat”, “tea”, “tan”, “ate”, “nat”, “bat”]输出: [[“bat”],[“nat”,“tan”],[“ate”,“eat”,“tea”]]给你一个字符串数组，请你将字母异位词组合在一起。字母异位词是由重新排列源单词的所有字母得到的一个新单词。输出: [[“a”]]输出: [[“”]]
每日OJ_牛客HJ75 公共子串计算
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
08-12 528
每日OJ_牛客HJ75 公共子串计算（求最大公共子串，使用递推实现 假设 x(i)：字符串第i个字符 y(j)：字符串第j个字符 dp[i][j]：以x(i)，y(j)结尾的最大子串长度。比如：x: "abcde" y:"bcdae" dp[2][1]：以x(2)，y(1)结尾的最大子串长度即：x遍历到"abc"，y遍历 到"bc"，都以字符'c'结尾时最大公共子串为"bc"）
【算法模板】计算几何：旋转卡壳求凸包直径
2303_80346267的博客
08-14 370
旋转卡壳算法是一种几何算法，主要用于在二维平面上求解与凸包相关的最优问题。该算法利用凸包顶点的顺序性和对称性，通过模拟两个卡壳（calipers）沿着凸包边界的旋转来寻找最优解。常见的应用包括计算凸包的直径（即最远点对之间的距离）、最小包围矩形（最小面积矩形），以及最小宽度（宽度最小的方向）。
贪心算法3
2301_79555067的博客
08-14 190
贪心算法leetcode题解包括：134. 加油站 135. 分发糖果 860.柠檬水找零 406.根据身高重建队列
C语言实现排序之归并排序算法
2403_83044722的博客
08-14 245
归并排序采用分治法策略，将数组递归地分成两半，然后对每一半进行排序，最后将两个已排序的子数组合并成一个完整的有序数组。
代码随想录算法训练营第四十四天 | 动态规划 part11
最新发布
qq_43456971的博客
08-15 146
【代码】代码随想录算法训练营第四十四天 | 动态规划 part11。
多态（二）
hhhh_h_h_的博客
08-14 250
一个含有虚函数的类中都至少都有一个虚函数表指针，因为虚函数 的地址要被放到虚函数表中，虚函数表也简称虚表。虚函数的继承是一种接口继承，派生类继承的是基类虚函数的接口，目的是为了重写，达成。普通函数的继承是一种实现继承，派生类继承了基类函数，可以使用函数，继承的是函数的实。多态，继承的是接口。所以如果不实现多态，不要把函数定义成虚函数。以下程序输出结果是什么（）
《Hello算法》：数据结构与算法入门指南
3. **数据结构**：数据结构是支撑算法实现的重要基石，书中可能涉及数组、链表、栈、队列、树等基本数据结构，以及哈希表这一高效的数据存储和检索工具。 4. **图论**：图论在算法中占有重要地位，书中可能涵盖图的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值