C++ Practical-2 day6 类模板之栈

于 2024-09-30 07:00:00 发布
阅读量617 收藏 4
点赞数 12
分类专栏： C++ 文章标签： c++ java 开发语言 C++ Practical-2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wesigj/article/details/142603443
版权

系列文章目录

点击直达——文章总目录

文章目录

C++ Practical-2 day6 类模板之栈

Overview

  • C++不练习coding，就相当于空中楼阁，基础不扎实
  • 光吃不干，等于没吃

1.类模板之栈

在C++中，使用类模板来实现一个栈（Stack）是一种常见的做法，因为它可以提供类型安全和灵活性。下面是一个简单的栈类模板的实现：

#include <iostream>
#include <stdexcept> // for std::out_of_range

template <typename T>
class Stack {
private:
    // 使用动态数组来存储栈的元素
    T* elements;
    size_t size;
    size_t capacity;

    // 动态数组扩容函数
    void resize() {
        capacity = (capacity == 0) ? 1 : (capacity * 2);
        T* newElements = new T[capacity];
        for (size_t i = 0; i < size; ++i) {
            newElements[i] = elements[i];
        }
        delete[] elements;
        elements = newElements;
    }

public:
    // 构造函数
    Stack() : size(0), capacity(0), elements(nullptr) {}

    // 析构函数
    ~Stack() {
        delete[] elements;
    }

    // 拷贝构造函数
    Stack(const Stack& other) : size(other.size), capacity(other.capacity) {
        elements = new T[capacity];
        for (size_t i = 0; i < size; ++i) {
            elements[i] = other.elements[i];
        }
    }

    // 赋值运算符
    Stack& operator=(const Stack& other) {
        if (this != &other) {
            delete[] elements;
            size = other.size;
            capacity = other.capacity;
            elements = new T[capacity];
            for (size_t i = 0; i < size; ++i) {
                elements[i] = other.elements[i];
            }
        }
        return *this;
    }

    // 检查栈是否为空
    bool isEmpty() const {
        return size == 0;
    }

    // 获取栈的大小
    size_t getSize() const {
        return size;
    }

    // 入栈操作
    void push(const T& element) {
        if (size == capacity) {
            resize();
        }
        elements[size++] = element;
    }

    // 出栈操作
    void pop() {
        if (isEmpty()) {
            throw std::out_of_range("Stack<>::pop(): empty stack");
        }
        elements[--size] = T();
    }

    // 获取栈顶元素
    T& top() {
        if (isEmpty()) {
            throw std::out_of_range("Stack<>::top(): empty stack");
        }
        return elements[size - 1];
    }

    // 获取栈顶元素（const版本）
    const T& top() const {
        if (isEmpty()) {
            throw std::out_of_range("Stack<>::top(): empty stack");
        }
        return elements[size - 1];
    }
};

int main() {
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    intStack.push(3);

    std::cout << "Top element: " << intStack.top() << std::endl; // 输出 3

    intStack.pop();
    std::cout << "New top element: " << intStack.top() << std::endl; // 输出 2

    return 0;
}

这个栈类模板实现了基本的栈操作，包括入栈（push）、出栈（pop）、获取栈顶元素（top）、检查栈是否为空（isEmpty）以及获取栈的大小（getSize）。它使用动态数组来存储元素，并在需要时自动扩容。

请注意，这个实现是一个简单的示例，实际应用中可能需要更多的错误检查和优化。

2.如何为这个栈类模板添加一个迭代器接口？

为栈类模板添加迭代器接口，首先需要定义一个迭代器类，该类能够遍历栈中的元素。由于栈的特性是后进先出（LIFO），迭代器通常不是栈数据结构的一部分，但为了演示如何实现，我们可以添加一个简单的迭代器。

下面是一个简单的迭代器实现：

#include <iostream>
#include <stdexcept> // for std::out_of_range

template <typename T>
class Stack {
private:
    T* elements;
    size_t size;
    size_t capacity;

    void resize() {
        capacity = (capacity == 0) ? 1 : (capacity * 2);
        T* newElements = new T[capacity];
        for (size_t i = 0; i < size; ++i) {
            newElements[i] = elements[i];
        }
        delete[] elements;
        elements = newElements;
    }

public:
    Stack() : size(0), capacity(0), elements(nullptr) {}
    ~Stack() {
        delete[] elements;
    }
    Stack(const Stack& other) : size(other.size), capacity(other.capacity) {
        elements = new T[capacity];
        for (size_t i = 0; i < size; ++i) {
            elements[i] = other.elements[i];
        }
    }
    Stack& operator=(const Stack& other) {
        if (this != &other) {
            delete[] elements;
            size = other.size;
            capacity = other.capacity;
            elements = new T[capacity];
            for (size_t i = 0; i < size; ++i) {
                elements[i] = other.elements[i];
            }
        }
        return *this;
    }

    bool isEmpty() const {
        return size == 0;
    }

    size_t getSize() const {
        return size;
    }

    void push(const T& element) {
        if (size == capacity) {
            resize();
        }
        elements[size++] = element;
    }

    void pop() {
        if (isEmpty()) {
            throw std::out_of_range("Stack<>::pop(): empty stack");
        }
        elements[--size] = T();
    }

    T& top() {
        if (isEmpty()) {
            throw std::out_of_range("Stack<>::top(): empty stack");
        }
        return elements[size - 1];
    }

    const T& top() const {
        if (isEmpty()) {
            throw std::out_of_range("Stack<>::top(): empty stack");
        }
        return elements[size - 1];
    }

    // 迭代器接口
    class Iterator {
    private:
        const Stack* stack;
        size_t index;

    public:
        Iterator(const Stack* s, size_t idx) : stack(s), index(idx) {}

        T& operator*() const {
            return stack->elements[index];
        }

        T* operator->() const {
            return &stack->elements[index];
        }

        Iterator& operator++() {
            if (index > 0) index--;
            return *this;
        }

        Iterator operator++(int) {
            Iterator temp = *this;
            ++(*this);
            return temp;
        }

        bool operator==(const Iterator& other) const {
            return index == other.index && stack == other.stack;
        }

        bool operator!=(const Iterator& other) const {
            return !(*this == other);
        }
    };

    Iterator begin() const {
        return Iterator(this, size - 1);
    }

    Iterator end() const {
        return Iterator(this, -1);
    }
};

int main() {
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    intStack.push(3);

    std::cout << "Stack elements: ";
    for (Stack<int>::Iterator it = intStack.begin(); it != intStack.end(); ++it) {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

在这个实现中，我们定义了一个嵌套的Iterator类，它包含了指向栈对象的指针和当前索引。迭代器提供了operator*、operator->、operator++和比较运算符operator==和operator!=，以支持基本的迭代器操作。

begin()和end()成员函数分别返回指向栈顶元素和栈底元素（即栈外一个位置）的迭代器。

请注意，这个迭代器实现是反向迭代的，因为它从栈顶开始遍历到栈底。在实际应用中，栈通常不提供迭代器，因为迭代器与栈的LIFO特性不相符。如果你需要迭代器，可能需要考虑使用其他数据结构，如列表或向量。

3.这个栈类模板在性能上有哪些优化空间？

栈类模板的性能优化可以从多个方面进行考虑，以下是一些常见的优化策略：

  1. 减少内存重新分配：

    • 当栈的容量不足以容纳新元素时，需要重新分配内存并复制现有元素到新的内存区域。这个过程是昂贵的。可以通过增加初始容量或使用更大的扩容因子来减少扩容的次数。

  2. 使用更高效的内存分配策略：

    • 可以使用内存池来管理内存分配，这样可以减少系统调用和内存碎片。

  3. 避免不必要的复制：

    • 如果元素类型支持移动语义，使用std::move来避免不必要的复制操作。

  4. 优化迭代器：

    • 如果迭代器使用频繁，可以考虑实现更高效的迭代器，比如使用延迟初始化。

  5. 减少动态内存分配：

    • 如果栈的大小是固定的，可以使用静态数组而不是动态数组来存储元素。

  6. 使用自定义内存分配器：

    • 如果栈是程序中频繁使用的数据结构，可以考虑使用自定义的内存分配器来优化性能。

  7. 优化数据结构：

    • 考虑使用链表而不是动态数组来实现栈，这样可以避免内存重新分配的问题。

  8. 减少异常抛出：

    • 在pop和top函数中，如果栈为空，则抛出异常。如果程序中栈为空是一个常见情况，可以考虑返回一个特殊值或使用错误码来避免抛出异常。

  9. 使用无锁并发访问：

    • 如果栈需要在多线程环境中使用，可以考虑实现无锁的数据结构来提高并发性能。

  10. 避免使用虚函数：

    • 如果栈类需要继承，避免使用虚函数，因为它们会增加额外的开销。

  11. 减少成员函数的调用：

    • 对于频繁调用的成员函数，可以考虑内联函数以减少函数调用的开销。

  12. 使用模板特化：

    • 对于特定的数据类型，可以提供特化的实现来优化性能。

  13. 减少内存访问：

    • 优化数据结构的内存布局，减少缓存未命中的可能性。

  14. 使用引用计数：

    • 如果栈中存储的是智能指针，可以考虑使用引用计数来减少内存使用。

  15. 避免使用异常处理：

    • 如果栈操作中可能会抛出异常，可以考虑使用错误码或返回特殊值来处理错误，以避免异常处理的开销。

请注意，优化应该基于实际的性能瓶颈进行。在进行优化之前，最好使用性能分析工具来确定程序的瓶颈所在。

4.我想在栈中实现一个优先队列，需要对栈类模板做哪些修改？

实现一个优先队列通常需要根据元素的优先级来出队，而不是遵循先进先出（FIFO）的原则。这意味着我们需要对栈的元素进行排序或者使用其他方法来保证每次出队时都是优先级最高的元素。

以下是实现优先队列的一些方法：

4.1. 使用最小堆

最小堆是一种常用的实现优先队列的数据结构。在最小堆中，父节点的值总是小于或等于其子节点的值。这样，堆顶元素就是优先级最高的元素。

4.2. 使用有序数组或链表

每次插入元素时，将元素插入到数组或链表中的适当位置，以保持元素的有序性。

4.3. 使用二叉搜索树

使用二叉搜索树（BST），并对其进行平衡，如AVL树或红黑树，可以快速插入、删除和查找元素。

4.4. 使用斐波那契堆

斐波那契堆是一种高级的数据结构，它在执行减少键值和合并堆操作时非常高效。

4.5.修改栈类模板

以下是如何修改你的栈类模板以实现一个简单的最小堆优先队列：

#include <iostream>
#include <stdexcept>
#include <vector>

template <typename T>
class PriorityQueue {
private:
    std::vector<T> elements;

    // 交换元素
    void swap(T& a, T& b) {
        T temp = a;
        a = b;
        b = temp;
    }

    // 上浮调整
    void siftUp(int index) {
        while (index > 0) {
            int parentIndex = (index - 1) / 2;
            if (elements[index] < elements[parentIndex]) {
                swap(elements[index], elements[parentIndex]);
                index = parentIndex;
            } else {
                break;
            }
        }
    }

    // 下沉调整
    void siftDown(int index) {
        int size = elements.size();
        int leftChildIndex, rightChildIndex, smallestIndex;

        while (true) {
            leftChildIndex = 2 * index + 1;
            rightChildIndex = 2 * index + 2;
            smallestIndex = index;

            if (leftChildIndex < size && elements[leftChildIndex] < elements[smallestIndex]) {
                smallestIndex = leftChildIndex;
            }
            if (rightChildIndex < size && elements[rightChildIndex] < elements[smallestIndex]) {
                smallestIndex = rightChildIndex;
            }
            if (smallestIndex != index) {
                swap(elements[index], elements[smallestIndex]);
                index = smallestIndex;
            } else {
                break;
            }
        }
    }

public:
    void push(const T& element) {
        elements.push_back(element);
        siftUp(elements.size() - 1);
    }

    void pop() {
        if (elements.empty()) {
            throw std::out_of_range("PriorityQueue<>::pop(): empty queue");
        }
        elements[0] = elements.back();
        elements.pop_back();
        siftDown(0);
    }

    T top() const {
        if (elements.empty()) {
            throw std::out_of_range("PriorityQueue<>::top(): empty queue");
        }
        return elements[0];
    }

    bool isEmpty() const {
        return elements.empty();
    }

    size_t getSize() const {
        return elements.size();
    }
};

int main() {
    PriorityQueue<int> pq;
    pq.push(10);
    pq.push(30);
    pq.push(20);

    std::cout << "Top element: " << pq.top() << std::endl; // 输出 10

    pq.pop();
    std::cout << "New top element: " << pq.top() << std::endl; // 输出 20

    return 0;
}

4.6.解释

  1. 最小堆的表示：

    • 使用一个动态数组（std::vector）来存储元素。

  2. 上浮调整（siftUp）：

    • 当新元素插入时，将其放在数组的末尾，然后与父节点比较，如果新元素的优先级更高，则与父节点交换位置，直到找到合适的位置。

  3. 下沉调整（siftDown）：

    • 当元素被删除（通常是堆顶元素）时，将数组的第一个元素替换为最后一个元素，然后与子节点比较，如果当前元素的优先级较低，则与子节点交换位置，直到找到合适的位置。

  4. push操作：

    • 将新元素插入数组的末尾，然后进行上浮调整。

  5. pop操作：

    • 将数组的第一个元素替换为最后一个元素，然后删除最后一个元素，并对新的第一个元素进行下沉调整。

  6. top操作：

    • 返回数组的第一个元素，即优先级最高的元素。

  7. isEmpty和getSize操作：

    • 分别检查队列是否为空和返回队列的大小。

这个实现提供了一个基本的优先队列功能，可以根据需要进行进一步的优化和扩展。

关于作者

WeSiGJ
关注
专栏目录
C++ Practical-2 day7 类模板特化之数组
wesigj的博客
09-30 911
首先，定义一个包含虚函数的基类模板，这个基类模板将被用于后续的特化。public:// 纯虚函数virtual ~Base() {} // 虚析构函数以确保派生类对象的正确清理定义一个派生类模板，继承自基类模板，并实现基类中的虚函数。
C++ Practical-2 day5 模板之函数模板
wesigj的博客
09-29 458
函数模板是C++中一种支持泛型编程的工具，它允许你编写与数据类型无关的函数。通过使用模板，你可以创建一个函数，它可以在编译时自动适应任何给定的数据类型。模板特化是为特定类型提供特定实现的方法。这在你需要为某些特定类型提供优化或特殊行为时非常有用。偏特化通常用于类模板，但也可以通过模板重载实现函数的偏特化。通过使用函数模板，你可以编写更加通用和灵活的代码。
C++ Practical-1 day9
wesigj的博客
09-27 1691
在C++中，自定义异常类通常是通过继承自类来实现的。自定义异常允许你为特定错误情况提供更多的上下文信息。继承：创建一个新类，继承自，并重写what()方法，该方法返回一个描述异常的字符串。提供构造函数：为你的异常类提供构造函数，允许设置错误消息和其他相关信息。抛出异常：在代码中使用throw关键字抛出你的自定义异常对象。捕获异常：使用try-catch块捕获并处理异常。// 自定义异常类private:public:// 重写 what() 方法// 一个可能抛出异常的函数try {
C++ Practical-1 day3
wesigj的博客
09-24 965
C++ Practical-1 day3
C++ Practical-1 day10
wesigj的博客
09-27 956
get()可以读取单个字符或字符数组，而getline()只能读取到对象或字符数组。get()会忽略前面的空白字符，而getline()不会忽略任何字符，包括前面的空白字符。getline()会读取换行符之前的整行数据，而get()会读取到第一个换行符为止的数据。对于像std::endl这样的流操纵符，或者像std::flush这样的函数，不需要指定变量，因为它们作用于流本身。// 输出并换行// 输出并刷新输出缓冲区return 0;在C++中，可以通过多种方式实现自定义的格式化输出。
C++ Practical-1 day2
wesigj的博客
09-23 1154
/ 定义一个结构体，用于表示点int x;int y;// 创建一个点Point p;p.x = 10;p.y = 20;// 输出点的坐标// 创建另一个点// 列表初始化// 修改并输出点的坐标return 0;C++11允许在结构体中定义函数，这使得结构体可以包含方法。#include // 用于sqrt函数// 定义一个结构体，用于表示点，并包含一个方法int x, y;// 方法：计算点到原点的距离return 0;
C++ Practical-1 day8
wesigj的博客
09-26 1622
点击直达——文章总目录在C++中， 是 STL（Standard Template Library，标准模板库）中的一个关联容器，它根据键（Key）来存储和组织数据。 是基于红黑树实现的，它保证了元素的有序性，并且提供了对元素的高效访问。 1.4.注意事项 默认排序： 默认使用 对键进行排序，如果需要自定义排序，可以提供自定义比较函数。键的类型：键的类型必须支持比较运算符，且不允许修改键的值。迭代器： 提供了迭代器，可以用于遍历元素。异常安全： 的操作通常抛出异常时，容器的状态不会被破坏，可以安全地处
BUUCTF Misc Page2-6部分题目
热门推荐
cuihua的博客
07-15 7万+
BUUCTF Misc Page2-6部分题目
[翻译]《Programming - Principles and Practice Using C++, Second Edition》- Chapter 0
WarwickCSProject
09-01 966
本文导航（全文7500字左右，按正常阅读速度，大概需要15-25分钟）Notes to the Readers 写给读者 Notes to the Readers 写给读者 When the terrian disagrees with the map 当实际地形与地图标定不符时 trust the terrian. 相信地形 ——Swiss army proverb 瑞士军队格言 ...
C++教程电子书籍URL
11-20
- **简介**: 针对C++模板编程进行了深入探讨，适合希望掌握这一高级特性并灵活运用的学习者。 #### 14. **《C++ Coding Standards》** - **链接**: [http://bbs.topsage.com/dispbbs.asp?boardID=121&ID=175999]...
剖析虚幻渲染体系（14）- 延展篇：现代渲染引擎演变史Part 1（萌芽期）
www_xuhss_com的博客
04-04 5604
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 目录* 14.1 本篇概述 + 14.1.1 游戏引擎简介 + 14.1.2 游戏引擎模块 + 14.1.3 游戏引擎列表 - 14.1.3.1 Unreal Engine - 14.1.3.2 Unity - 14.1.3.3 CryEngine - 14.1.3.4 Doo
JavaEE知识体系
yuh2012的博客
07-11 2万+
1 1.文件上传下载 1.1 文件上传 1.1.1 文件上传的作用 例如网络硬盘！就是用来上传下载文件的。 在智联招聘上填写一个完整的简历还需要上传照片呢。 1.1.2 文件上传对页面的要求 1.必须使用表单，而不能是超链接； 2.表单的method必须是POST，而不能是GET； 3.表单的enctype必须是multipart/form-data； 4.在表单中添加file表
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 1028
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
【ARM 嵌入式 C 入门及渐进26 -- 内敛函数和宏定义的区别】
CodingCos的博客
09-25 923
在 C 语言中，内联函数和宏定义都可以用来减少函数调用的开销和提高代码执行效率，但它们在许多方面存在显著区别。内联函数使用inline关键字定义。宏定义使用#define预处理指令。无类型检查：宏是文本替换，没有类型检查，可能导致类型错误。调试困难：宏替换在预处理阶段完成，难以在调试器中跟踪宏的行为。全局作用域：宏在定义后全局有效，可能引起命名冲突和作用域污染。维护复杂：宏替换简单但容易出错，逻辑复杂时难以维护。性能优化：宏是简单的文本替换，不涉及编译器优化。return 0;
pyqt瀑布流布局
weixin_54217201的博客
09-21 500
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 440
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
最新发布
静谧、淡雅
09-29 110
【YOLOv8改进[SPPF]】使用SPPFCSPC替换SPPF模块 + 含全部代码和详细修改方式
简易STL实现 | Set 的实现
AsherGu的博客
09-26 430
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

WeSiGJ

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值