C++：采用模板封装顺序表，栈，队列

1.顺序表：

list.hpp

#ifndef LIST_HPP
#define LIST_HPP
#include <iostream>

using namespace std;

template <class L>

class Seqlist
{
private:
    L *ptr;
    L size;
    L len=0;

public:
    void init(L n)
    {
        //堆区申请空间（大小为n）
        this->ptr=new L[n];
        //bzero(this->ptr,sizeof(L)*n);


        this->len=0;
        this->size=n;
        //
    }

    bool empty()
    {
        return this->len==0;
    }

    bool full()
    {
        return this->len==this->size;
    }

    void push_back(L e)//尾插
    {
        if(this->full())
        {
            return ;
        }
        this->ptr[len++]=e;
    }
    //插入
    void insert(L index,L num)
    {
        if(full())
        {
            return;
        }
        for(L i=len-1;i>=index-1;i--)
        {
            ptr[i+1]=ptr[i];
        }

        ptr[index-1]=num;
        len++;
    }
    //任意位置删除
    void erase(L index)
    {
        if(empty())
        {
            return;
        }
        for(L i=index;i<len;i++)
        {
            ptr[i-1]=ptr[i];
            ptr[i]=NULL;
        }
        len--;
    }
    //尾删
    void pop_back()
    {
        if(empty())
        {
            return;
        }
        ptr[len-1]=NULL;
        len--;

    }


    void show()
    {//判空
        if(len==0)
        {
            return;
        }

        cout<<"顺序表"<<endl;
        for(int i=0;i<len;i++)
        {
            cout<<ptr[i]<<ends;
        }

        cout<<endl;
    }
    //当前长度
    L cur_size()
    {
        if(empty())
        {
            return 0;
        }
        else
        {
            return len;
        }
    }

    L at(L index)
    {
        L num;
        num=ptr[index-1];
        return num;
    }

    void sort(bool flag)
    {
        if(flag)
        {
            for(int i=1;i<len;i++)
            {
                for(int j=0;j<len-i;j++)
                {
                    if(ptr[j]>ptr[j+1])
                    {
                        L temp;
                        temp=ptr[j];
                        ptr[j]=ptr[j+1];
                        ptr[j+1]=temp;
                    }
                }
            }
        }
        else
        {
            for(int i=1;i<len;i++)
            {
                for(int j=0;j<len-i;j++)
                {
                    if(ptr[j]<ptr[j+1])
                    {
                        L temp;
                        temp=ptr[j];
                        ptr[j]=ptr[j+1];
                        ptr[j+1]=temp;
                    }
                }
            }

        }
    }

};
#endif // LIST_HPP

2.栈：

strack.hpp

#ifndef STACK_HPP
#define STACK_HPP

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

template <class T>
class StackNode
{
public:
    T data;//存储数据
    StackNode *next;//指向下一个节点

    //构造函数
    StackNode(T d):data(d),next(nullptr){}

};
template <class T>
class Stack
{
private:
    StackNode<T> *top;//指向栈顶
    int len;//栈中元素数量

public:

    Stack():top(nullptr),len(0){}
    //析构函数
    ~Stack()
    {
        while(!empty())
        {
            pop();
        }
    }

    bool empty() //判断栈是否为空
    {
        return top==nullptr;
    }

    int size()//获取栈的大小
    {
        return len;
    }
    //压栈操作


    void push(T element)
    {
        StackNode<T>  *newnode=new StackNode<T>(element);//申请空间并初始化
        newnode->next=top;
        top=newnode;
        len++;
    }
    //出栈操作
    T pop()
    {
        if(empty())
        {
            throw out_of_range("空栈");
        }
        StackNode<T>  *temp=top;
        T value=top->data;
        top=top->next;
        delete temp;
        len--;
        return value;
    }
    //查看栈顶元素
    T look_top()
    {
        if(empty())
        {
            throw out_of_range("空栈");
        }
        return top->data;
    }
    //清空栈
    void clear()
    {
        while (!empty())
        {
            pop();
        }
    }
    Stack& operator=(const Stack& other)
    {
        if (this != &other)
        {
            clear(); // 清空当前栈
            // 复制元素
            StackNode<T>  *current = other.top;
            while (current != nullptr)
            {
                push(current->data);
                current = current->next;
            }
        }
        return *this;
    }

    void swap(Stack& other)
    {
        StackNode<T> * tempTop = top;
        top = other.top;
        other.top = tempTop;

        T templen = len;
        len = other.len;
        other.len = templen;
    }
};

#endif // STACK_HPP

3.队列：

queue.hpp

#ifndef QUEUE_H
#define QUEUE_H

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


template <class T>
class QueueNode
{
public:
    T data;
    QueueNode *next;

    //有参构造
    QueueNode(T d):data(d),next(nullptr){}
};
template <class T>
class Queue
{
private:
    QueueNode<T>* front; // 指向队列头部的指针
    QueueNode<T>* rear;  // 指向队列尾部的指针
    int count;        // 队列中元素的数量

public:

    // 构造函数
    Queue() : front(nullptr), rear(nullptr), count(0)
    {

    }

    ~Queue()
    {
        clear();
    }
    void clear()
    {
        while (front != nullptr)
        {
            QueueNode<T>* temp = front;
            front = front->next;
            delete temp;
        }
        rear = nullptr;
        count = 0;
    }

    // 查看队列前端元素
    T frontElement()
    {
        if (empty())
        {
            throw std::out_of_range("空队列");
        }
        return front->data;
    }
    // 查看队列尾部元素
    T backElement()
    {
        if (empty())
        {
            throw std::out_of_range("空队列");
        }
        return rear->data;
    }
    //判断队列是否为空
    bool empty()
    {
        return front == nullptr;
    }
    // 获取队列的大小
    int size()
    {
        return count;
    }

    // 入队操作
    void push(T element)
    {
        QueueNode<T>* newNode = new QueueNode<T>(element);
        if (rear == nullptr)  // 队列为空
        {
            front = rear = newNode;
        } else
        {
            rear->next = newNode;
            rear = newNode;
        }
        count++;
    }

    // 出队操作
    T pop()
    {
        if (empty()) {
            throw std::out_of_range("空队列");
        }
        QueueNode<T>* temp = front;
        T dequeuedValue = front->data;
        front = front->next;
        if (front == nullptr) {
            rear = nullptr;
        }
        delete temp;
        count--;
        return dequeuedValue;
    }

    void swap(Queue& other) {
        using std::swap;
        swap(front, other.front);
        swap(rear, other.rear);
        swap(count, other.count);
    }

    Queue& operator=(const Queue& other)
    {
            if (this != &other)
            {
                Queue temp(other); // 临时对象，用于深拷贝
                swap(temp); // 与临时对象交换内容
            }
            return *this;
        }

};
#endif // QUEUE_H