9.27每日作业

最新推荐文章于 2024-10-09 17:19:41 发布
最新推荐文章于 2024-10-09 17:19:41 发布
阅读量403 收藏
点赞数 10
文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62099195/article/details/142600670
版权

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

顺序表：

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;
}

Hello.。World
关注
栈的实现及应用
qq_71139242的博客
10-18 435
栈的实现及应用
顺序栈操作（C语言代码）
master_hunter的博客
01-16 998
顺序栈是一种使用连续存储空间（如数组）来存储栈中元素的栈结构。它具有后进先出（LIFO, Last In First Out）的特性，即最后入栈的元素会首先出栈。
8.7作业
wbbbzzzzz的博客
08-07 451
【代码】8.7作业。
循环队列及链队列的基本操作
qq_62949330的博客
05-07 2799
循环队列及链队列的基本操作
编写程序，通过逻辑运算符和表达式解决相关问题。
liuaolong_aolong的博客
02-19 728
1. 某学校毕业要求学分规定如下： • 必修课必须全部通过（分数>=60） • 选修课至少通过5门（分数>=60）或者3门选修课分数大于90分即可。 要求，根据分数判断某学生能否正常毕业： • 测试样例第一行输入两个整数 n, m，表示 n 门必修课和 m 门选修课，第二行输入 n 个整数，第三行输入 m 个整数，表示每门选修课的分数。 • 判断如果能正常毕业输出通过考核，否则输出未通过考核。
数据结构 - 顺序栈的基本操作(C语言)
Northxw
12-11 4549
顺序栈：利用顺序存储方式实现的栈。 顺序栈的定义： (1)：栈中元素用一个预设的足够长度的一维数组来实现：DataType data[MAXSIZE]。 (2)：栈底位置可以设置在数组的任何一个端点，而栈顶随着插入和删除而变化。 (3)：用int top 作为栈顶的指针，指明当前栈顶位置。通常：0下标设为栈底，空栈时top=-1;入栈时栈顶指针+1，出栈时栈顶指针-1。 顺序栈的存储结构
C++ —— 优先级队列(priority queue)的模拟实现
最新发布
hedhjd的博客
10-09 664
队列是一种先进先出的数据类型。元素的入队都只能从队尾进入，出队时从队列头部出去优先级队列不能先进先出，更像是数据类型中的“堆”，也就是数组优先级队列每次出队的元素是队列中优先级最高的那个元素，默认大的值优先级高，如果想要小的值优先级高可以使用仿函数，而不是队首的元素，也就是每次出队，都是将当前队列中最大的那个元素出队。
顺序栈的基本操作
红叶的专栏
04-21 858
顺序栈的基本操作#include<iostream> using namespace std;#define MAXSIZE 10typedef int Elemtype; typedef struct { Elemtype elem[MAXSIZE]; int top; }Seqstack;void Initstack(Seqstack &s); void Clear(Seqsta
循环队列的c语言实现
倚楼听风雨的博客
09-23 6858
一、什么是循环队列     1、基本概念     队列就是一个能够实现“先进先出”的存储结构，队列分为链式队列和静态队列。静态队列一般用数组来实现，但此时的队列必须是循环队列，否则会造成巨大的内存浪费；链式队列是用链表来实现队列的。说白了循环队列就是一个数组，我们把这个数组当成首尾相连来使用(写到数组的末尾后从头开始写)。     2、结构体 typedef char Item;
实验三 顺序栈的基本操作实现及其应用
Gaza_的博客
12-24 4744
一、实验目的 1、   熟练掌栈和队列的结构特点，掌握栈和队列的顺序存储和链式存储结构和实现。 2、   学会使用栈和队列解决实际问题。 二、实验内容 栈的压栈和出栈操作。 三、 #include using namespace std; const int StackSize=20; /*数组长度为20、*/ template class SeqStack {
【C++】手动实现栈的封装
2301_77133426的博客
09-03 236
使用C++手动实现了封装栈类，包含了一部分的成员函数
【头歌】顺序栈的基本操作及应用
qq_39977056的博客
01-30 4271
define STACK_INIT_SIZE 100 //存储空间初始分配量#define STACKINCREMENT 10 //存储空间分配增量// 定义栈元素类型为整型//栈的基址即栈底指针//栈顶指针//当前分配的空间}SqStack;
【头歌】循环队列及链队列的基本操作
qq_39977056的博客
01-30 4396
define MAX_QSIZE 5 // 最大队列长度+1struct SqQueue{ QElemType *base;// 初始化的动态分配存储空间 int front;// 头指针，若队列不空，指向队列头元素 int rear;// 尾指针，若队列不空，指向队列尾元素的下一个位置};使用顺序队列时会出现“假溢出现象”，为了能够充分地使用数组中的存储空间，可以把数组的前端和后端连接起来，形成一个环形的表，即把存储队列元素的表从逻辑上看成一个环。这个环形的表叫做循环队列。
头歌作业之排序1、2、3、4
weixin_62075168的博客
01-01 9602
为了完成本关任务，你需要掌握：链表的相关操作和掌握选择排序算法。为了完成本关任务，你需要掌握：直接插入排序的算法思想。为了完成本关任务，你需要掌握：折半插入排序算法。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写一个能实现希尔排序算法的函数。本关任务：编写函数实现折半插入排序算法。3 9 5 8 7 （数字序列）
python-运算符-简单案例
qq_37143903的博客
06-03 1631
编程要求 根据提示，在右侧编辑器补充代码，写出正确的表达式。 （1）从测试集获取整数数值a,b,c,d,e （2）写出以下表达式： x1为a分之b的c倍 x3为a分之b的c次方 x3求d除以e的余数 x4求d除以e的整数部分 （3）输出以上计算结果 （4）输出c、d、e是否按从小到大顺序排列 （5）输出e是否同时能被2、3整除 （6）输出d是否高于或等于这5个数的平均值 测试说明 平台会对你编写的代码进行测试： 测试输入：2，3，3，37，13； 预期输出： 4.5 3.375 11 2 F
【头歌】顺序表的基本操作
qq_39977056的博客
01-23 1万+
时，在函数体内不需要改变主调函数中的实参变量的值，只需读取主调函数中的实参变量的值，因此函数形参定义为变量，采用值传递。，i-1上的结点，依次后移到位置n，n-1，…关于逆置，有一种非常暴力的解决方法，就是单独开辟一个同等大小的顺序表，然后新表从前往后遍历，同时原表从后往前遍历，依次赋值，最后得到的就是逆置后的顺序表。，ai−1，ai，ai+1，…顺序表的就地逆置，只需让顺序表中的数据元素头尾依次交换即可，即交换第一个元素和最后一个元素，第二个和倒数第二个，依此类推，这种方法的空间复杂度为O(1)。
链式栈的创建及操作
weixin_46016969的博客
10-31 1847
链式实现栈及基本操作 1.在完成栈的实现前,我们先来了解什么是栈,栈的存储结构又是什么,举一个简单的例子来了解什么是栈吧，现实生活中我们通常会叠衣服，是不是我们先叠的衣服最后才能拿出来,而后叠的衣服最先拿出来 栈又由数组和链式两种方式 以下是数组和链式栈的实现原理 数组形式的栈: 链式栈: 2.了解了栈是什么之后，我们用代码来实现栈 (1)首先创建结点结构体变量 struct Node { int data; //数据域 struct Node *next; //指针
Educoder MySQL数据库 - 数据库和表的基本操作（二）
知足且上进，温柔而坚定
05-02 1万+
第1关：插入数据 编程要求 根据提示，在右侧编辑器Begin-End处补充代码： 我们为你新建了一个空数据表tb_emp，请你为它同时添加3条数据内容； 空数据表结构如下，注意字段3 为DeptId，倒数第二个字母为大写的i： 需要你同时添加的数据内容为： （注意，是同时插入多条记录） 测试说明 我会对你编写的代码进行测试，最终结果会如下图所示： 开始你的任务吧，祝你成功！ USE Company; #请在此处添加实现代码 ########## Begin #
educoderC语言平台实训答案【添加结构体+文件部分】（仅供参考）
热门推荐
qq_44737028的博客
06-25 2万+
第3部分 选择结构程序设计进阶 第1关 快递费用计算 任务描述 本关任务：编写一个计算机快递费的程序。 上海市的某快递公司根据投送目的地距离公司的远近，将全国划分成5个区域： 快递费按邮件重量计算，由起重费用、续重费用两部分构成： （1） 起重（首重）1公斤按起重资费计算（不足1公斤，按1公斤计算），超过首重的重量，按公斤（不足1公斤，按1公斤计算）收取续重费； （2） 同城起重资费10元，续重3元/公斤； （3） 寄往1区（江浙两省）的邮件，起重资费10元，续重4元； （4） 寄往其他地区的邮件，起重资
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值