坐牢第三十五天(c++)

一.作业

1.使用模版类自定义栈

代码:

#include <iostream>
using namespace std;
template<typename T>
// 封装一个栈
class stcak
{
private:
    T *data;    //
    int max_size; // 最大容量
    int top;      // 下标
public:
    // 无参构造函数
    stcak();
    // 有参构造函数
    stcak(int size);
    // 拷贝构造函数
    stcak(const stcak &other);
    // 析构函数
    ~stcak();
    // 判空函数
    bool empty();
    // 判满函数
    bool full();
    // 扩容函数
    void resize(int new_size);
    // 返回元素个数函数
    int size();
    // 向栈顶插入元素函数
    void push(T value);
    // 删除栈顶元素函数
    T pop();
    // 访问栈顶元素函数
    T get_top();
    // 赋值重载函数
    stcak &operator=(const stcak &other);
    // 遍历栈里元素函数
    void show();
    //清空队列函数
    void clear();
};
// 无参构造函数
template<typename T>
stcak<T>::stcak() : max_size(10)
{
    data = new T[10];
    max_size = 10;
    top = -1;
    cout << "无参构造" << endl;
}
// 有参构造函数
template<typename T>
stcak<T>::stcak(int size)
{
    data = new T[size];
    max_size = size;
    top = -1;
    cout << "有参构造" << endl;
}
// 拷贝构造函数
template<typename T>
stcak<T>::stcak(const stcak &other)
{
    max_size = other.max_size;
    top = other.top;
    data = new T[max_size];
    for (int i = 0; i <= top; i++)
    {
        data[i] = other.data[i];
    }
    cout << "拷贝构造" << endl;
}
// 析构函数
template<typename T>
stcak<T>::~stcak()
{
    delete[] data;
    cout << "析构函数" << endl;
}
// 判空函数
template<typename T>
bool stcak<T>::empty()
{
    return top == -1;
}
// 判满函数
template<typename T>
bool stcak<T>::full()
{
    return top == max_size - 1;
}
// 扩容函数
template<typename T>
void stcak<T>::resize(int new_size)
{
    int *new_data = new T[new_size];
    for (int i = 0; i <= top; i++)
    {
        new_data[i] = data[i];
    }
    delete[] data;
    data = new_data;
    max_size = new_size;
}
// 返回元素个数函数
template<typename T>
int stcak<T>::size()
{
    return top + 1;
}
// 向栈顶插入元素函数
template<typename T>
void stcak<T>::push(T value)
{
    if (full())
    {
        // 调用扩容函数
        resize(max_size * 2);
    }
    data[++top] = value;
}
// 删除栈顶元素函数
template<typename T>
T stcak<T>::pop()
{
    if (empty())
    {
        cout << "栈是空的";
        return -1;
    }
    return data[top--]; // 出栈
}
// 访问栈顶元素函数
template<typename T>
T stcak<T>::get_top()
{
    if (empty())
    {
        cout << "栈是空的";
        return T();
    }
    return data[top];
}
// 赋值重载函数
template<typename T>
stcak<T> &stcak<T>::operator=(const stcak &other)
{
    if (this == &other)
    {
        return *this;
    }
    delete[] data;
    max_size = other.max_size;
    top = other.top;
    data = new T[max_size];
    for (int i = 0; i <= top; i++)
    {
        data[i] = other.data[i];
    }
    return *this;
}
// 遍历栈里元素函数
template<typename T>
void stcak<T>::show()
{
    if (empty())
    {
        cout << "遍历失败栈是空的"<<endl;
        return;
    }
    cout << "栈里元素有:"<<endl;
    for (int i = 0; i <= top; i++)
    {
        cout<< data[i] <<'\t'; 
    }
    cout <<endl;
}
//清空栈函数
template<typename T>
void stcak<T>::clear()
{
    top=-1;
    cout <<"栈已清空"<<endl;
}
/******************主函数*********************/ 
int main()
{   
    stcak<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.show();
    cout << "栈的大小:" << s.size() << endl;
    cout <<s.get_top()<< endl;
    s.pop();
    s.show();
    cout << "栈的大小:" << s.size() << endl;
    s.clear();
    s.show();
    return 0;
}

结果:

2.使用模版类自定义队列

代码:

#include <iostream>
using namespace std;
template<typename T>
class queue
{
private:
    T *data;    // 容器
    int max_size; // 最大容量
    int front;    // 头下标
    int tail;     // 尾下标
public:
    // 无参构造函数
    queue();
    // 有参构造函数
    queue(int size);
    // 拷贝构造函数
    queue(const queue &other);
    // 析构函数
    ~queue();
    // 判空函数
    bool empty();
    // 判满函数
    bool full();
    // 扩容函数
    void resize(int new_size);
    // 元素个数函数
    int size();
    // 向队列尾部插入元素函数
    void push(T value);
    // 删除首个元素函数 出队
    void pop();
    // 遍历队列元素
    void show();
    // 赋值重载函数
    queue &operator=(const queue &other);
    //清空队列函数
    void clear();
};
// 无参构造函数
template<typename T>
queue<T>::queue():max_size(10)
{
    data = new T[10];
    max_size = 10;
    front = tail = 0;
    cout << "无参构造" << endl;
}
// 有参构造函数
template<typename T>
queue<T>::queue(int size)
{
    data = new T[size];
    max_size = size;
    front = tail = 0;
    cout << "有参构造" << endl;
}
// 拷贝构造函数
template<typename T>
queue<T>::queue(const queue &other)
{
    max_size=other.max_size;
    front=other.front;
    tail=other.tail;
    data=new T[max_size];
    for (int i = front; i != tail; i = (i + 1) % max_size)
    {
        data[i]=other.data[i];
    }   
    cout << "拷贝构造" << endl;
}
// 析构函数
template<typename T>
queue<T>::~queue()
{
    delete[] data;
    cout << "析构函数" << endl;
}
// 判空函数
template<typename T>
bool queue<T>::empty()
{
    return front == tail;
}
// 判满函数
template<typename T>
bool queue<T>::full()
{
    return (tail+1)% max_size == front;
}
// 元素个数函数
template<typename T>
int queue<T>::size()
{
    return (tail-front+max_size) % max_size;
}
// 扩容函数
template<typename T>
void queue<T>::resize(int new_size)
{
    int *new_data = new T[new_size];
    for (int i = front; i <= tail; i++)
    {
        new_data[i] = data[i];
    }
    data = new_data;
    max_size = new_size;
    front =0;
    tail =size();
}
// 向队列尾部插入元素函数
template<typename T>
void queue<T>::push(T value)
{
    if (full())
    {
        // 调用扩容函数
        resize(max_size * 2);
    }
    data[tail] = value;
    tail = (tail + 1) % max_size;
}
// 删除首个元素函数 出队
template<typename T>
void queue<T>::pop()
{
    if (empty())
    {
        cout << "队列为空" << endl;
        return ;
    }
    cout << data[front] << "出队" << endl;
    front = (front + 1) % max_size;
    // return 0;
}
// 遍历队列元素
template<typename T>
void queue<T>::show()
{
    if (empty())
    {
        cout << "遍历失败队列为空" << endl;
        return;
    }
    cout << "队列元素:" << endl;
    for (int i = front; i != tail; i = (i + 1) % max_size)
    {
        cout << data[i] << '\t';
    }
    cout << endl;
}
// 赋值重载函数
template<typename T>
queue<T> &queue<T>::operator=(const queue &other)
{
    if (this == &other)
    {
        return *this;
    }
    delete []data;
    max_size=other.max_size;
    front=other.front;
    tail=other.tail;
    data=new T[max_size];
    for (int i = front; i != tail; i = (i + 1) % max_size)
    {
        data[i]=other.data[i];
    }
    cout << "拷贝赋值函数" <<endl;  
    return *this; 
}
//清空队列函数
template<typename T>
void queue<T>::clear()
{
    front=tail=0;
    cout << "队列已清空"<<endl;
}
/******************主函数*********************/
int main()
{
    queue<int> s;
    s.push(1);
    s.push(2);
    s.push(3);
    s.show();
    cout << "队列的大小:" << s.size() << endl;
    s.pop();
    s.show();
    cout << "队列的大小:" << s.size() << endl;
    s.clear();
    s.show();
    return 0;
}

结果:

3.使用模版类自定义动态数组

代码:

#include <iostream>
#include <cstring> // 引入cstring以使用memcpy
using namespace std;

template <typename T>
class SeqList
{
private:
    T *data;      // 顺序表的数组
    int max_size; // 容器最大内存
    int size = 0; // 数组的大小
    int len = 0;  // 顺序表实际长度

public:
    // 构造函数
    SeqList()
    {
        init(10, 100);
    }

    SeqList(int s, int max_s)
    {
        init(s, max_s);
    }

    // 析构函数
    ~SeqList()
    {
        free();
    }

    // 拷贝构造
    SeqList(const SeqList<T> &other)
    {
        init(other.size, other.max_size);
        for (int i = 0; i < other.len; i++)
        {
            add(other.data[i]);
        }
    }
    // 初始化函数
    void init(int s, int max_s)
    {
        max_size = max_s;
        size = s;           // 当前数组的最大容量
        data = new T[size]; // 在堆区申请一个顺序表容器
    }
    // 判空函数
    bool empty()
    {
        return len == 0;
    }
    // 判满函数
    bool full()
    {
        return size==len;
    }

    // 添加数据函数
    bool add(T e)
    {
        if (data == NULL)
        {
            cout << "添加数据失败" << endl;
            return false;
        }
        if (full())
        {
            if (len == max_size)
            {
                cout << "添加数据失败,内存已满" << endl;
                return false;
            }
            expend();
        }
        data[len++] = e;
        cout << "添加数据成功" << endl;
        return true;
    }
    // 求当前顺序表的实际长度
    int length()
    {
        return len;
    }
    // 任意位置插入函数
    bool insert_pos(int pos, T e)
    {
        if (data == NULL || pos < 0 || pos > len)
        {
            cout << "插入数据失败" << endl;
            return false;
        }
        if (full())
        {
            expend();
        }
        for (int i = len - 1; i >= pos; i--)
        {
            data[i + 1] = data[i];
        }
        data[pos] = e;
        len++;
        cout << "插入数据成功" << endl;
        return true;
    }
    // 任意位置删除函数
    bool delete_pos(int pos)
    {
        if (data == NULL || SeqList::empty() || pos < 0 || pos >= len)
        {
            cout << "删除数据失败" << endl;
            return false;
        }
        for (int i = pos + 1; i < len; i++)
        {
            data[i - 1] = data[i];
        }
        len--;
        cout << "删除数据成功" << endl;
        return true;
    }
    // 访问容器中任意一个元素 at
    T &at(int index)
    {
        if (data == NULL || SeqList::empty() || index < 0 || index >= len)
        {
            cout << "访问数据失败" << endl;
        }
        return data[index];
    }
    // 遍历整个数组输出
    void show()
    {
        if (data == NULL || SeqList::empty())
        {
            cout << "遍历数组失败" << endl;
            return;
        }
        cout << "数组中的数据:" << endl;
        for (int i = 0; i < length(); i++)
        {
            cout << data[i] << '\t';
        }
        cout << endl;
    }

    // 君子函数:二倍扩容
    void expend()
    {
        T *temp;
        size = 2 * size;
        temp = new T[size];
        memcpy(temp, data, sizeof(T) * len);
        free();
        data = temp;
    }

    // 释放函数
    void free()
    {
        delete[] data;
        data = NULL;
        cout << "释放空间成功" << endl;
    }
};

int main()
{
    SeqList<int> L;
    L.add(1);
    L.add(2);
    L.add(3);
    L.add(4);
    L.add(5);
    L.add(6);
    L.add(6);
    L.add(6);
    L.add(99);
    L.add(99);
    L.add(99);
    L.add(99);
    L.show();
    L.free();
    L.show();
    return 0;
}

结果:

二.思维导图

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:/a/872497.html

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

【全志H616】【开源】 ARM-Linux 智能分拣项目:阿里云、网络编程、图像识别

【全志H616】【开源】 ARM-Linux 智能分拣项目&#xff1a;阿里云、网络编程、图像识 文章目录 【全志H616】【开源】 ARM-Linux 智能分拣项目&#xff1a;阿里云、网络编程、图像识1、实现功能2、软件及所需环境3、逻辑流程图及简述3.1 完整逻辑流程图3.2 硬件接线3.3 功能简述…

部署project_exam_system项目——及容器的编排

&#xff08;一&#xff09;安装docker、编辑daemon.json文件、安装docker-compose编排容器、启动docker 1.环境准备 [rootdocker--1 ~]# rz -Erz waiting to receive.[rootdocker--1 ~]# lsanaconda-ks.cfg docker.sh[rootdocker--1 ~]# source docker.sh [rootdocker--1 ~…

基于Flink的流式计算可视化开发实践之配置->任务生成->任务部署过程

1. 引言 在我们大数据平台(XSailboat)的DataStudio模块中实现了基于Hive的业务流程开发和基于Flink的实时计算管道开发。 DataStudio是用来进行数据开发的&#xff0c;属于开发环境&#xff0c;另外还有任务运维模块&#xff0c;负责离线分析任务和实时计算任务在生产环境的部…

30岁程序员的焦虑:转行还是继续死磕?现在什么方向更有前景?

最适合转入AI大模型的莫过于程序员和在读大学生了吧。 对于程序员来说&#xff0c;码农之路并不是一帆风顺。对于每一个入行IT业的社会青年来说&#xff0c;谁不是抱着想要成为最高峰的技术大咖或者跃进管理岗的小目标&#xff1f; 然而往往更多的人并非互联网吹捧的如此耀眼…

低代码平台:加速企业制造业数字化转型的新引擎

近期&#xff0c;国家发布了中小企业数字化转型试点城市的政策&#xff0c;旨在通过先行先试&#xff0c;探索支持制造业特别是汽车制造行业数字化转型的有效模式。这一政策的出台&#xff0c;为汽车制造企业的数字化转型提供了强有力的政策支持和方向指引&#xff0c;标志着汽…

【论文速读】| SEAS:大语言模型的自进化对抗性安全优化

本次分享论文&#xff1a;SEAS: Self-Evolving Adversarial Safety Optimization for Large Language Models 基本信息 原文作者: Muxi Diao, Rumei Li, Shiyang Liu, Guogang Liao, Jingang Wang, Xunliang Cai, Weiran Xu 作者单位: 北京邮电大学, 美团 关键词: 大语言模…

vue.js项目实战案例详细源码讲解

​ 大家好&#xff0c;我是程序员小羊&#xff01; 前言&#xff1a; 为帮助大家更好地掌握Vue.js项目的开发流程&#xff0c;我将为你讲解一个完整的Vue.js实战案例&#xff0c;并提供详细的源码解析。这个案例将涵盖从项目创建到实现各种功能模块的全过程&#xff0c;适合用于…

基于空间结构光场照明的三维单像素成像

单像素成像是一种新兴的计算成像技术。该技术使用不具备空间分辨能力的单像素探测器来获取目标物体或场景的空间信息。单像素探测器具有高的时间分辨率、光探测效率和探测带宽&#xff0c;因此单像素光学成像技术在散射、弱光等复杂环境下相较于传统面阵成像技术展现了很大优势…

面试题:软件测试缺陷产生的原因有哪些?

软件缺陷产生的原因多种多样&#xff0c;一般可能有以下几种原因&#xff1a; 1.需求表述、理解、编写引起的错误。 2.系统架构设计引起的错误。 3.开发过程缺乏有效的沟通及监督&#xff0c;甚至没有沟通或监督。 4.程序员编程中产生的错误。 5.软件开发工具本身隐藏的问…

哨兵排序算法

代码展示 #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h>#define MAXSIZE 20 //直接排序 typedef struct {int r[MAXSIZE 1];int length; } SqList; int InsertSort(SqList* L) {int i, j;for (i 2; i < L->length; i){if (L-…

mysql自增主键插入后返回id与实际插入id不同

加入这一段即可 GeneratedValue(strategy GenerationType.IDENTITY)

张飞硬件10-TVS管篇笔记

TVS管的原理 TVS或称瞬变电压抑制二极管&#xff0c;是在二极管工艺基础上发展起来的新产品&#xff0c;其电路符号和普通稳压管相同&#xff0c;外形也与普通二极管无异。当TVS管两端经受瞬间的高能量冲击时&#xff0c;它能以极高的速度将其阻抗骤然降低&#xff0c;同时吸收…

el-table 单元格,双击编辑

el-table 单元格&#xff0c;双击编辑 实现效果 代码如下 <template><el-table :data"tableData" style"width: 100%"><el-table-column prop"name" label"姓名" width"180"><template slot-scope&q…

【机器学习】梯度提升和随机森林的概念、两者在python中的实例以及梯度提升和随机森林的区别

引言 梯度提升&#xff08;Gradient Boosting&#xff09;是一种强大的机器学习技术&#xff0c;它通过迭代地训练决策树来最小化损失函数&#xff0c;以提高模型的预测性能 随机森林&#xff08;Random Forest&#xff09;是一种基于树的集成学习算法&#xff0c;它通过组合多…

Java队列详细解释

队列 一、什么是队列&#xff08;Queue&#xff09; java队列是一种线性数据结构&#xff0c;它的特点是先进先出。在队列中&#xff0c;元素的添加&#xff08;入队&#xff09;操作在队尾进行&#xff0c;而元素的移除&#xff08;出队&#xff09;操作则在队头进行。因此&a…

最近大模型最火的就业方向有哪些?

在2023和2024年&#xff0c;大语言模型的发展迎来了绝对风口&#xff0c;吸引了大量创业者和投资者。然而&#xff0c;经过一年的发展&#xff0c;许多公司已经销声匿迹。那么&#xff0c;未来大模型方向上还有哪些可以继续发展的方向呢? 基座大模型预训练 现状 - 展现出“胜…

TikTok Live与跨境电商的深度融合:直播带货引领品牌出海

在TikTok Live的应用中&#xff0c;品牌能够利用这一互动性极强的功能开辟新的销售渠道&#xff0c;推动全球业务的增长。本文Nox聚星将和大家探讨TikTok Live如何与跨境电商相结合&#xff0c;分析其应用场景。 一、TikTok Live与跨境电商的结合优势 庞大的用户基础&#xff…

使用 OpenCV 和 NumPy 进行图像处理:HSV 范围筛选实现PS抠图效果

使用 OpenCV 和 NumPy 进行图像处理&#xff1a;HSV 范围筛选实现PS抠图效果 在计算机视觉和图像处理领域&#xff0c;OpenCV 是一个非常强大的库&#xff0c;能够帮助我们执行各种图像操作。在这篇博客中&#xff0c;我们将通过一个简单的示例演示如何使用 OpenCV 和 NumPy 来…

machine learning - 2

泛化误差 也可以认为是预测时的误差。 训练误差 并不是越小越好&#xff0c;太小会过拟合。 获得测试集合的方法&#xff1a; 1&#xff09;&#xff1a; 2&#xff09;&#xff1a;例如&#xff1a;k-折交叉验证法&#xff0c; 就的每k个数据取一个座位测试集 3&#xff0…

1.39TB高清卫星影像更新(WGS84坐标投影)

最近对WGS84版的高清卫星影像数据进行了一次更新&#xff0c;并基于更新区域生成了相应的接图表。 1.39TB高清卫星影像更新 本次数据更新了1576个离线包&#xff0c;共1.39TB大小&#xff0c;并全部生成了更新接图表。 更新接图表范围 更新接图表由每一个离线包文件的范围构…