C++(9.25)

stack:

cpp 复制代码
#include <iostream>
using namespace std;
class my_stack {
private:
    int* data;       // 动态数组,用于存储栈的元素
    int len;         // 当前栈中元素的个数
    int size;    // 栈的最大容量

public:
    // 默认构造函数,初始化容量为 10
    my_stack(int cap = 10) : len(0), size(cap) {
        data = new int[size];
    }

    // 析构函数,释放动态分配的内存
    ~my_stack() {
        delete[] data;
    }

    // 复制构造函数
    my_stack(const my_stack& other) : len(other.len), size(other.size) {
        data = new int[size];
        for (int i = 0; i < len; ++i) {
            data[i] = other.data[i];
        }
    }

    // 赋值运算符重载
    my_stack& operator=(const my_stack& other) {
        if (this != &other) {
            delete[] data;
            len = other.len;
            size = other.size;
            data = new int[size];
            for (int i = 0; i < len; ++i) {
                data[i] = other.data[i];
            }
        }
        return *this;
    }

    // 返回栈中元素的个数
    int size() const {
        return len;
    }

    // 判断栈是否为空
    bool empty() const {
        return len == 0;
    }

    // 返回栈顶元素
    int& top() {
        if (empty()) {
             return -1;
        }
        return data[len - 1];
    }

    // 向栈顶插入元素
    void push(int value) {
        if (len == size) {
            return -1;
        }
        data[len++] = value;
    }

    // 删除栈顶元素
    void pop() {
        if (empty()) {
           return -1;
        }
        len--;
    }

    // 交换两个栈的内容
    void swap(my_stack& other) {
        swap(data, other.data);
        swap(len, other.len);
        swap(size, other.size);
    }
};

int main() {
    my_stack s1(5);  // 初始化栈容量为 5
    s1.push(10);
    s1.push(20);
    s1.push(30);

    cout << "容量: " << s1.size() << endl;
    cout << "栈顶: " << s1.top() << endl;

    s1.pop();
    cout << "删除后,栈顶元素 " << s1.top() << endl;

    my_stack s2(5);
    s2.push(100);
    s2.push(200);

    cout << "交换后" << endl;
    s1.swap(s2);

    cout << "栈顶: " << s1.top() << endl;
   cout << "交换后: " << s2.top() << endl;

    return 0;
}

queue:

cpp 复制代码
#include <iostream>
#include <stdexcept>
using namespace std;
class my_queue {
private:
    int* data;      // 
    int len;        // 当前队列中的元素个数
    int size;       // 队列的最大容量
    int front;   // 队首元素的索引
    int back;    // 队尾元素的索引

public:
    // 初始化容量为 10
    my_queue(int cap = 10) : len(0), size(cap), front(0), back(-1) {
        data = new int[size];
    }

    // 析构函数,释放动态分配的内存
    ~my_queue() {
        delete[] data;
    }

    // 复制构造函数
    my_queue(const my_queue& other) : len(other.len), size(other.size), front(other.front), back(other.back) {
        data = new int[size];
        for (int i = 0; i < len; i++) {
            data[i] = other.data[(front + i) % size];
        }
    }

    // 赋值运算符重载
    my_queue& operator=(const my_queue& other) {
        if (this != &other) {
            delete[] data;
            len = other.len;
            size = other.size;
            front = other.front;
            back = other.back;
            data = new int[size];
            for (int i = 0; i < len; i++) {
                data[i] = other.data[(front + i) % size];
            }
        }
        return *this;
    }

    // 返回队列中元素的个数
    int the_size() const {
        return len;
    }

    // 判断队列是否为空
    bool empty() const {
        return len == 0;
    }

    // 返回队首元素
    int& front() {
        if (empty()) {
            throw out_of_range("queue is empty");
        }
        return data[front];
    }

    // 返回队尾元素
    int& back() {
        if (empty()) {
            throw out_of_range("queue is empty");
        }
        return data[back];
    }

    // 向队列尾部添加元素
    void push(int value) {
        if (len == size) {
            throw overflow_error("queue is full");
        }
        back = (back + 1) % size;
        data[back] = value;
        ++len;
    }

    // 从队列头部删除元素
    void pop() {
        if (empty()) {
            throw out_of_range("Queue is empty");
        }
        front = (front + 1) % size;
        len--;
    }

    // 交换两个队列的内容
    void swap(my_queue& other) {
        swap(data, other.data);
       swap(len, other.len);
        swap(size, other.size);
        swap(front, other.fron);
       swap(back, other.back);
    }
};

int main() {
    my_queue q1(5);  // 初始化队列容量为 5
    q1.push(10);
    q1.push(20);
    q1.push(30);

    cout << q1.the_size() << endl;
    cout  << q1.front() << endl;
    cout  << q1.back() << endl;

    q1.pop();
    cout q1.front() << endl;

    my_queue q2(5);
    q2.push(100);
    q2.push(200);

    cout  << endl;
    q1.swap(q2);

   cout << q1.front() << endl;
    cout << q2.front() << endl;

    return 0;
}
相关推荐
screenCui2 分钟前
macOS运行python程序遇libiomp5.dylib库冲突错误解决方案
开发语言·python·macos
R-G-B4 分钟前
【02】MFC入门到精通——MFC 手动添加创建新的对话框模板
c++·mfc·mfc 手动添加创建新的对话框
linux kernel18 分钟前
第七讲:C++中的string类
开发语言·c++
jz_ddk20 分钟前
[实战]调频(FM)和调幅(AM)信号生成(完整C语言实现)
c语言·算法·信号处理
Tipriest_32 分钟前
[数据结构与算法] 优先队列 | 最小堆 C++
c++·优先队列·数据结构与算法·最小堆
玩代码32 分钟前
Java线程池原理概述
java·开发语言·线程池
CloudAce云一36 分钟前
谷歌云代理商:谷歌云TPU/GPU如何加速您的AI模型训练和推理
算法
宛西南浪漫戈命44 分钟前
Centos 7下使用C++使用Rdkafka库实现生产者消费者
c++·centos·linq
泰勒疯狂展开1 小时前
Java研学-MongoDB(三)
java·开发语言·mongodb
zzywxc7871 小时前
AI技术通过提示词工程(Prompt Engineering)正在深度重塑职场生态和行业格局,这种变革不仅体现在效率提升,更在重构人机协作模式。
java·大数据·开发语言·人工智能·spring·重构·prompt