9.27每日作业

news2024/9/27 22:30:15

将之前实现的顺序表、栈、队列都更改成模板类

顺序表：

list.hpp

#ifndef LIST_HPP
#define LIST_HPP

#include <iostream>
#include<memory.h>
#include<stdlib.h>
#include<string.h>
using namespace std;

//typedef int T;        //类型重命名
template <typename T>

//封装一个顺序表
class SeqList
{
private:
    T *ptr;        //指向堆区空间的起始地址
    int size;             //总长度
    int len = 0;          //当前顺序表实际长度

public:
    void init(int n)
    {
        //在堆区申请出一个长度为n的空间，将其实地址赋值给ptr
        this->ptr = new T[n];

        //给len进行初始化
        this->len = 0;
        this->size = n;
    }

    //判空
    bool empty()
    {
        return this->len == 0;
    }
    //判满
    bool full()
    {
        return this->len == this->size;
    }
    //尾插
    void push_back(T e)
    {
        //判断是否满了
        if(this->full())
        {
            return ;
        }

        this->ptr[len++] = e;
    }
    //插入
    void insert(T index)
    {
        //判断是否满了
        if(this->full())
        {
            return ;
        }
        int i,m;
        cout << "\n请输入要插入的位置：";
        cin >> m;
        //cout << "\n请输入要插入的数值：";
        //cin >> index;
        for(i=this->len; i>=m; i--)
        {
            this->ptr[i] = this->ptr[i-1];
        }
        this->ptr[i] = index;
        this->len++;
    }
    //任意位置删除
    void erase(int index)
    {
        if(empty() == 1)
        {
            return;
        }
        int i;
        for(i = index - 1; i < this->len; i++)
        {
            this->ptr[i] = this->ptr[i+1];
        }
        this->len--;
    }
    //尾删
    void pop_back(int index)
    {
        if(empty() == 1)
        {
            return;
        }
        int i;
        for(i = 0; i < index; i++)
        {
            this->ptr[this->len--] = 0;
        }
    }
    //求长度
    void my_size()
    {
        cout << "长度为：" << this->len <<endl;
    }
    //获取任意位置元素
    T & my_at(int index)
    {
        static T num;
        num = this->ptr[index-1];
        return num;
    }
    //将顺序表进行排序
    void my_sort(bool flag)
    {
        int i,j;
        if(flag)
        {
            for(i = 0; i < this->len; i++)
            {
                for(j = 0; j < this->len - 1- i;j++)
                {
                    if(this->ptr[j]>this->ptr[j+1])
                    {
                        T temp = this->ptr[j];
                        this->ptr[j] = this->ptr[j+1];
                        this->ptr[j+1] = temp;
                    }
                }
            }
        }
        else
        {
            for(i = 0; i < this->len; i++)
            {
                for(j = 0; j < this->len - 1- i;j++)
                {
                    if(this->ptr[j]<this->ptr[j+1])
                    {
                        T temp = this->ptr[j];
                        this->ptr[j] = this->ptr[j+1];
                        this->ptr[j+1] = temp;
                    }
                }
            }
        }
    }
    //定义展示函数
    void show()
    {
        //判空
        if(empty() == 1)
        {
            return;
        }
        cout<<"当前顺序表中的元素分别是：";
        for(int i=0; i<this->len; i++)
        {
            cout<<this->ptr[i]<<" ";
        }
        cout<<endl;
    }
};

#endif // LIST_HPP

 main.cpp

#include "list.hpp"

int main()
{
    SeqList<int> sl;           //实例化一个顺序表对象
    sl.init(10);            //申请空间
    sl.push_back(1);
    sl.push_back(2);
    sl.push_back(3);
    sl.push_back(4);
    sl.push_back(5);
    sl.push_back(6);
    sl.show();
    sl.insert(7);
    sl.show();
    sl.erase(3);
    sl.show();
    sl.pop_back(2);
    sl.show();
    sl.my_size();
    cout << sl.my_at(3) << endl;
    sl.my_sort(1);
    sl.show();
    sl.my_sort(0);
    sl.show();

    return 0;
}

栈：

list.hpp

#ifndef LIST_HPP
#define LIST_HPP

#include <iostream>
using namespace std;

template <typename T>
class my_stack {
private:
    T *data;        // 存储栈元素的动态数组
    int capacity;   // 栈的容量
    int top;        // 栈顶元素的索引

public:
    // 构造函数
    my_stack(int size = 10) : capacity(size), top(-1)
    {
        data = new T[capacity];
    }

    // 析构函数
    ~my_stack()
    {
        delete[] data;
    }

    // 入栈操作
    void push(const T& value)
    {
        if (top + 1 >= capacity)
        {
            resize();
        }
        data[++top] = value;
    }

    // 出栈操作
    void pop()
    {
        if (!empty())
        {
            --top;
        }
        else
        {
            cout << "Stack is empty. Cannot pop." << endl;
        }
    }

    // 查看栈顶元素
    T& peek()
    {
        if (!empty())
        {
            return data[top];
        }
        else
        {
            throw out_of_range("Stack is empty. Cannot peek.");
        }
    }

    // 检查栈是否为空
    bool empty() const
    {
        return top == -1;
    }

    // 获取栈的大小
    int size() const
    {
        return top + 1;
    }

private:
    // 扩容函数
    void resize()
    {
        capacity *= 2;
        T* newData = new T[capacity];
        for (int i = 0; i <= top; ++i)
        {
            newData[i] = data[i];
        }
        delete[] data;
        data = newData;
    }
};
#endif // LIST_HPP

main.cpp

#include "list.hpp"
int main()
{
    my_stack<int> stack;

    // 入栈操作
    stack.push(10);
    stack.push(20);
    stack.push(30);

    cout << "栈顶元素："<< stack.peek() << endl; // 输出: 30
    cout << "栈大小：" << stack.size() << endl;  // 输出: 3

    // 出栈操作
    stack.pop();
    cout << "弹出操作后的顶部元素：" << stack.peek() << endl; // 输出: 20

    // 检查栈是否为空
    stack.pop();
    stack.pop();
    cout << "栈是否为空 " << (stack.empty() ? "是" : "否") << endl;

    return 0;
}

队列：

list.hpp

#ifndef LIST_HPP
#define LIST_HPP

#include <iostream>
#include <stdexcept>
using namespace std;

template <typename T>
class my_queue {
private:
    T* data;        // 存储队列元素的动态数组
    int capacity;   // 队列的容量
    int front;      // 队头元素的索引
    int rear;       // 队尾元素的索引
    int count;      // 当前元素数量

public:
    // 构造函数
    my_queue(int size = 10) : capacity(size), front(0), rear(-1), count(0)
    {
        data = new T[capacity];
    }
    // 拷贝构造函数
    my_queue(const my_queue& other)
    {
        capacity = other.capacity;
        front = other.front;
        rear = other.rear;
        count = other.count;
        data = new T[capacity];
        for (int i = 0; i < count; ++i)
        {
            data[(front + i) % capacity] = other.data[(front + i) % capacity];
        }
    }
    // 拷贝赋值运算符
    my_queue& operator=(const my_queue& other)
    {
        if (this != &other)
        {
            delete[] data;                                           // 释放旧内存
            capacity = other.capacity;
            front = other.front;
            rear = other.rear;
            count = other.count;
            data = new T[capacity];
            for (int i = 0; i < count; ++i)
            {
                data[(front + i) % capacity] = other.data[(front + i) % capacity];
            }
        }
        return *this;
    }
    // 析构函数
    ~my_queue()
    {
        delete[] data;
    }
    // 返回队头元素
    T &my_front()
    {
        if (empty())
        {
            throw out_of_range("队列为空，无法查看队头元素。");
        }
        return data[front];
    }
    // 返回队尾元素
    T& back()
    {
        if (empty())
        {
            throw out_of_range("队列为空，无法查看队尾元素。");
        }
        return data[rear];
    }
    // 检查队列是否为空
    bool empty() const
    {
        return count == 0;
    }
    // 获取队列的大小
    int size() const
    {
        return count;
    }
    // 入队操作
    void push(const T& value)
    {
        if (count >= capacity)
        {
            resize();
        }
        rear = (rear + 1) % capacity;                       // 循环队列
        data[rear] = value;
        count++;
    }
    // 直接构造元素（emplace）
    template <typename... Args>
    void emplace(Args&&... args)
    {
        if (count >= capacity)
        {
            resize();
        }
        rear = (rear + 1) % capacity;                       // 循环队列
        data[rear] = T(std::forward<Args>(args)...);        // 使用完美转发构造元素
        count++;
    }
    // 出队操作
    void pop() {
        if (empty())
        {
            cout << "队列为空，无法出队。" << endl;
            return;
        }
        front = (front + 1) % capacity;                     // 循环队列
        count--;
    }
    // 交换两个队列
    void swap(my_queue& other)
    {
        std::swap(data, other.data);
        std::swap(capacity, other.capacity);
        std::swap(front, other.front);
        std::swap(rear, other.rear);
        std::swap(count, other.count);
    }
private:
    // 扩容函数
    void resize()
    {
        capacity *= 2;
        T* newData = new T[capacity];
        for (int i = 0; i < count; ++i)
        {
            newData[i] = data[(front + i) % capacity];      // 复制元素
        }
        delete[] data;
        data = newData;
        front = 0;                                          // 重置队头索引
        rear = count - 1;                                   // 更新队尾索引
    }
};

#endif // LIST_HPP

main.cpp

#include "list.hpp"
int main()
{
    my_queue<int> queue;

    // 入队操作
    queue.push(10);
    queue.push(20);
    queue.push(30);

    cout << "队头元素：" << queue.my_front() << endl;                        // 输出: 10
    cout << "队尾元素：" << queue.back() << endl;                            // 输出: 30
    cout << "队列大小：" << queue.size() << endl;                            // 输出: 3

    // 出队操作
    queue.pop();
    cout << "出队操作后的队头元素：" << queue.my_front() << endl;              // 输出: 20

    // 检查队列是否为空
    queue.pop();
    queue.pop();
    cout << "队列是否为空 " << (queue.empty() ? "是" : "否") << endl;         // 输出: 是

    return 0;
}

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

nginx常用的性能优化

nginx常用的性能优化

第一步调整工作进程数&#xff1a; 设置成auto&#xff0c;会自动按照CPU核心数来启动工作进程数&#xff0c;如果设置具体数字&#xff0c;则只会使用指定数量的CPU核心&#xff0c;无法将CPU同一时间都能用得到&#xff0c;所以就不能发挥服务器的最大的性能。 第二步增加进程…
阅读更多...
章管家 listUploadIntelligent.htm SQL注入漏洞

章管家 listUploadIntelligent.htm SQL注入漏洞

漏洞描述&#xff1a; 章管家 listUploadIntelligent.htm 接口处存在SQL注入漏洞&#xff0c;未经身份验证的远程攻击者除了可以利用 SQL 注入漏洞获取数据库中的信息&#xff08;例如&#xff0c;管理员后台密码、站点的用户个人信息&#xff09;之外&#xff0c;甚至在高权限…
阅读更多...
基于大数据的高血压人群数据分析及可视化系统

基于大数据的高血压人群数据分析及可视化系统

作者&#xff1a;计算机学姐 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、JSP、ElementUI、Python、小程序等&#xff0c;“文末源码”。 专栏推荐&#xff1a;前后端分离项目源码、SpringBoot项目源码、Vue项目源码、SSM项目源码 精品专栏&#xff1a;Java精选实战项目…
阅读更多...
MMD模型及动作一键完美导入UE5-衣服布料模拟（四）

MMD模型及动作一键完美导入UE5-衣服布料模拟（四）

1、给角色刷布料 1、打开角色，通过Window->Clothing打开模型布料窗口 2、选中裙子右键，创建布料数据 3、选择裙子，右键->应用布料数据 4、激活布料画笔，就可以开始绘制布料了 5、调整画笔大小和布料值进行绘制，布料值为0表示刚体
阅读更多...
网络安全：保护数字时代的堡垒

网络安全：保护数字时代的堡垒

网络安全&#xff1a;保护数字时代的堡垒 引言&#xff1a; 在数字化时代&#xff0c;网络安全的重要性日益凸显。它不仅关系到个人隐私保护&#xff0c;还涉及国家安全和经济发展。随着技术的发展&#xff0c;网络安全的威胁也在不断进化&#xff0c;从个人设备到企业网络&am…
阅读更多...
2024图纸加密软件集锦|10款好用不踩雷的图纸加密软件推荐！

2024图纸加密软件集锦|10款好用不踩雷的图纸加密软件推荐！

小李&#xff1a;“老张&#xff0c;最近咱们公司的设计图纸泄密事件频发&#xff0c;真是让人头疼啊&#xff01;你有没有什么好的图纸加密软件推荐&#xff0c;能帮我们加强设计文件的安全性&#xff1f;” 老张&#xff1a;“小李啊&#xff0c;你算是问对人了。随着数字化…
阅读更多...
《pyqt+open3d》open3d可视化界面集成到qt中

《pyqt+open3d》open3d可视化界面集成到qt中

《pyqtopen3d》open3d可视化界面集成到qt中 一、效果显示二、代码三、资源下载 一、效果显示 二、代码 参考链接 main.py import sys import open3d as o3d from PyQt5.QtWidgets import QApplication, QMainWindow, QWidget from PyQt5.QtGui import QWindow from PyQt5.Qt…
阅读更多...
高通Android 12 push framework.jar和service.jar

高通Android 12 push framework.jar和service.jar

1、Android framework.jar和service.jar替换注意事项 2、单编 adb push service.jar脚本 如下 adb root adb disable-verity adb remountadb push services.jar system/framework adb push services.jar.prof system/framework adb push oat/arm64/services.art /system/fram…
阅读更多...
重磅首发！大语言模型LLM学习路线图来了！

重磅首发！大语言模型LLM学习路线图来了！

ChatGPT的出现在全球掀起了AI大模型的浪潮&#xff0c;2023年可以被称为AI元年&#xff0c;AI大模型以一种野蛮的方式&#xff0c;闯入你我的生活之中。 从问答对话到辅助编程&#xff0c;从图画解析到自主创作&#xff0c;AI所展现出来的能力&#xff0c;超出了多数人的预料&…
阅读更多...
酒店智能门锁SDK接口pro[V10] 对接酒店收银-模块封装C#-SAAS本地化-未来之窗行业应用跨平台架构

酒店智能门锁SDK接口pro[V10] 对接酒店收银-模块封装C#-SAAS本地化-未来之窗行业应用跨平台架构

一、代码 public class CyberWin_hoteldoor_prousbv10_2024{[DllImport("024.dll", CharSet CharSet.Ansi, CallingConvention CallingConvention.StdCall, EntryPoint "GetDLLVersion")]public static extern int GetDLLVersion(StringBuilder sDllVer…
阅读更多...
新手答疑 | 零基础该怎么学习嵌入式？嵌入式Linux学习路线是什么？嵌入式开发板推荐？

新手答疑 | 零基础该怎么学习嵌入式？嵌入式Linux学习路线是什么？嵌入式开发板推荐？

很多初学者想要涉足嵌入式Linux开发领域&#xff0c;但往往在刚入门阶段&#xff0c;会因为初次接触到大量复杂的概念术语和深奥的技术文档感到压力重重&#xff0c;面对这些内容不知从何下手&#xff0c;感到十分迷茫&#xff0c;网上的内容也纷繁复杂&#xff0c;没有清晰的学…
阅读更多...
【STM32】SPI回顾

【STM32】SPI回顾

一、定义 SPI是Motorola首先提出的全双工四线同步串行外围接口&#xff0c;采用主从模式&#xff08;Master-Slave&#xff09;架构。 二、单机与多机通信 4线SPI器件有四个信号&#xff1a;时钟(SPI CLK, SCLK)、主机输出从机输入(MOSI)、主机输入从机输出(MISO)、片选(CS/N…
阅读更多...
怎么备考2024年11月软考高级系统架构师 ?

怎么备考2024年11月软考高级系统架构师 ?

分享下我的系统架构设计师考证之路&#xff0c;希望能对即将参加考试的小伙伴们带来一些启示和帮助。 先贴出自己软考系统架构设计师成绩&#xff0c;备考一次就通过了考试。 一、架构考试教材 架构考试教材目前使用的是系统架构设计师教程&#xff08;第2版&#xff09;&…
阅读更多...
进程（一万字学习笔记）

进程（一万字学习笔记）

------------------------本文为学习进程记录的学习笔记&#xff0c;如有问题欢迎指正 -------------------------- 目录 1.定义 2.进程的种类 2.进程的内存布局 3.进程控制块&#xff08;PCB&#xff09; 4.进程源语 fork() 写时复制 exec() execl函数 wait() #进…
阅读更多...
GloVe（全局词向量嵌入）

GloVe（全局词向量嵌入）

目录 GloVe简介 1.使用预训练的GloVe的词向量(英文文本的用的最多) 2.自己训练Glove词向量 3. 知识点 GloVe简介 GloVe的全称叫Global Vectors for Word Representation&#xff0c;它是一个基于全局词频统计&#xff08;count-based & overall statistics&#xff09;的…
阅读更多...
OpenAI为高级语音模式添加五种声音，已正式推出！华为发布业界首个L4自动驾驶网络｜AI日报

OpenAI为高级语音模式添加五种声音，已正式推出！华为发布业界首个L4自动驾驶网络｜AI日报

文章推荐 法国亿万富翁加入字节跳动董事会&#xff01;美国总统候选人哈里斯、特朗普纷纷向人工智能和加密货币产业示好&#xff5c;AI日报 今日热点 华为发布业界首个L4自动驾驶网络——星河AI自动驾驶网络解决方案 在华为全联接大会2024“星河 AI 自动驾驶网络”论坛上&a…
阅读更多...
【深度学习】深度学习框架有哪些及其优劣势介绍

【深度学习】深度学习框架有哪些及其优劣势介绍

本文摘要 在深度学习的开发中&#xff0c;有许多流行的深度学习框架可供使用。本文主要介绍其中一些常见的深度学习框架以及其优劣势。 注&#xff1a;个人观点&#xff0c;仅供学习参考。 原文地址&#xff1a;【深度学习】深度学习框架有哪些及其优劣势介绍 TensorFlow 开发…
阅读更多...
教育行业知乎广告投放，如何开户？

教育行业知乎广告投放，如何开户？

随着教育行业的竞争日益激烈&#xff0c;作为一家致力于提供高质量教育资源的企业&#xff0c;如何在众多竞争者中脱颖而出&#xff0c;成为客户心中的首选呢&#xff1f;知乎作为高质量人群平台&#xff0c;无疑是教育行业品牌推广的理想平台。它不仅汇聚了大量求知欲旺盛的用…
阅读更多...
分享：一个小学四则运算出题工具

分享：一个小学四则运算出题工具

前言 目的在于辅助家长对孩子小学数学的教导。功能分六个部分&#xff1a;计算、加法、减法、乘法、除法和混合&#xff0c;其中&#xff0c;计算的功能在于计算特定算式的结果以及竖式过程&#xff0c;其他的则是基于参数生成指定数目的四则算式&#xff0c;并给出结果和竖式…
阅读更多...
CSS边框

CSS边框

CSS 中的边框是围绕着元素内容和内边距的一条或多条线段&#xff0c;您可以自定义这些线段的样式、宽度以及颜色。您可以通过下面几个属性分别定义边框的样式、宽度和颜色&#xff1a; border-style&#xff1a;设置边框的样式&#xff0c;例如实线、虚线等&#xff1b;border…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023