C++模板实现顺序表+双向链表+栈+队列

最新推荐文章于 2025-04-04 17:28:58 发布
原创 最新推荐文章于 2025-04-04 17:28:58 发布 · 436 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#C++ #模板 #适配器
本文介绍了一个简单的自定义容器类库实现，包括Vector、List、Stack和Queue等基本数据结构的模板类定义与功能实现。这些类提供了常用的数据操作方法，如插入、删除、查找等，并通过模板机制支持多种数据类型。

Vector.h

#pragma once

//类名 Vector
//类型 Vector<T>
template<class T>
class Vector
{
public:
    Vector()      //构造函数函数名与类名相同
        :_start(NULL)
        , _finish(NULL)
        , _endofstorage(NULL)
    {}

    Vector<T>(Vector<T>& v)
    {
        if (v.Size() > 0)
        {
            _start = new T[v.Size()];      //只开辟原有数据所占空间大小，节省空间
            memcpy(_start, v._start, sizeof(T)*v.Size());
            if (_start)
            {
                _finish = _start + v.Size();
                _endofstorage = _start + v.Size();
            }
            else
            {
                _start = _finish = _endofstorage = NULL;
            }
        }
    }

    Vector<T>& operator=(Vector<T>& v)
    {
        if (this != &v)
        {
            ////传统写法
            //size_t size = v.Size();
            //T* tmp = new T[v.Size()];
            //memcpy(tmp, _start, sizeof(T)*size);
            //delete[] _start;
            //_start = tmp;
            //_finish = _start + size;
            //_endofstorage = _start + size;

            //现代写法
            swap(_start, v._start);
            swap(_finish, v._finish);
            swap(_endofstorage, v._endofstorage);
        }
        return *this;
    }

    ~Vector()
    {
        delete[] _start;
        _start = _finish = _endofstorage = NULL;
    }

    void PushBack(const T& x);
    void PopBack();
    void Insert(size_t pos, const T& x);
    void Erase(size_t pos);
    size_t Size();
    size_t Capacity();
    bool Empty();
    size_t Find(const T& x);
    void Print()
    {
        T* cur = _start;
        while (cur != _finish)
        {
            cout << *cur << " ";
            ++cur;
        }
        cout << endl;
    }

    const T& Back() const
    {
        return *(_finish - 1);
    }

    T& operator[] (size_t index)
    {
        return _start[index];
    }

protected:
    void Expand(size_t n);

protected:
    T* _start;
    T* _finish;
    T* _endofstorage;
};

//template<class T>
//Vector<T>::Vector()
//  :_start(NULL)
//  , _finish(NULL)
//  , _endofstorage(NULL)
//{}

template<class T>
void Vector<T>::Expand(size_t n)
{
    if (Empty())
    {
        _start = new T[3];
        _finish = _start;
        _endofstorage = _start + 3;
    }
    else if (n > Capacity())
    {
        size_t size = Size();
        T* tmp = new T[n];
        //memcpy(tmp, _start, sizeof(T)*size);
        for (size_t i = 0; i < size; ++i)
        {
            tmp[i] = _start[i];
        }

        delete[] _start;
        _start = tmp;
        _finish = _start + size;
        _endofstorage = _start + n;
    }
}

template<class T>
size_t Vector<T>::Size()
{
    return _finish - _start;
}

template<class T>
size_t Vector<T>::Capacity()
{
    return _endofstorage - _start;
}

template<class T>
bool Vector<T>::Empty()
{
    return _start == _finish;
}

template<class T>
void Vector<T>::PushBack(const T& x)
{
    Insert(Size(), x);
}

template<class T>
void Vector<T>::PopBack()
{
    Erase(Size() - 1);
}

template<class T>
void Vector<T>::Insert(size_t pos, const T& x)
{
    assert(pos <= Size());
    if (Size() >= Capacity())
    {
        Expand(Capacity() * 2);
    }
    T* end = _finish - 1;
    while (end >= _start + pos)
    {
        *(end + 1) = *end;
        --end;
    }
    _start[pos] = x;
    ++_finish;
}

template<class T>
void  Vector<T>::Erase(size_t pos)
{
    assert(pos < Size());
    T* cur = _start + pos + 1;
    while (cur != _finish)
    {
        *(cur - 1) = *cur;
        ++cur;
    }
    --_finish;
}

template<class T>
size_t Vector<T>::Find(const T& x)
{
    T* cur = _start;
    while (cur != _finish)
    {
        if (*cur == x)
        {
            return cur - _start;
        }
        ++cur;
    }
    return (size_t)-1;
}


void TestVector()
{
    Vector<int> v;
    v.PushBack(1);
    v.PushBack(2);
    v.PushBack(3);
    v.PushBack(4);
    v.Print();

    Vector<int> v1(v);
    v1.Insert(2, 5);
    v1.Print();

    Vector<int> v2;
    v2 = v1;
    v2.Insert(3, 6);
    v2.Print();
}

List.h

#pragma once

template<class T>
struct ListNode
{
    ListNode<T>* _next;
    ListNode<T>* _prev;
    T _data;

    ListNode(const T& x)
        :_data(x)
        , _next(NULL)
        , _prev(NULL)
    {}
};

template<class T>
class List
{
    typedef ListNode<T> Node;
public:
    List()
    {
        _head = new Node(T());
        _head->_next = _head;
        _head->_prev = _head;
    }

    List(const List<T>& l)
        :_head(new Node(T()))
    {
        _head->_next = _head;
        _head->_prev = _head;
        Node* cur = l._head->_next;
        while (cur != l._head)
        {
            PushBack(cur->_data);
            cur = cur->_next;
        }
    }

    List<T>& operator=(const Vector<T>& l)
    {
        if (this != &l)
        {
            swap(_head, l._head);
        }
        return *this;
    }

    ~List()
    {
        Clear();
        delete _head;
        _head = NULL;
    }

    void Clear()    //清理函数
    {
        Node* cur = _head->_next;
        while (cur != _head)
        {
            Node* next = cur->_next;
            delete cur;
            cur = next;
        }
        _head->_next = _head;
        _head->_prev = _head;
    }

    void PushBack(const T& x);
    void PopBack();
    void PushFront(const T& x);
    void PopFront();

    void Insert(Node* pos, const T& x);
    void Erase(Node* pos);
    Node* Find(const T& x)
    {
        Node* cur = _head->_next;
        while (cur != _head)
        {
            if (cur->_data == x)
            {
                return cur;
            }
            cur = cur->_next;
        }
        return NULL;
    }
    void Print() const;

    const T& Back() const
    {
        return _head->_prev->_data;
    }

    const T& Front() const
    {
        return _head->_next->_data;
    }

    size_t Size()
    {
        size_t size = 0;
        Node* cur = _head->_next; 
        while (cur != _head)
        {
            ++size;
            cur = cur->_next;
        }
        return size;
    }

    bool Empty() const
    {
        return _head->_next == _head;
    }

protected:
    Node* _head;
};

template<class T>
void List<T>::Print() const
{
    Node* cur = _head->_next;
    cout << "head";
    while (cur != _head)
    {
        cout << "->" << cur->_data;
        cur = cur->_next;
    }
    cout << endl;
    Node* tail = _head->_prev;
    while (tail != _head)
    {
        cout << tail->_data << "->";
        tail = tail->_prev;
    }
    cout << "head" << endl;
}

template<class T>
void List<T>::PushBack(const T& x)
{
    Insert(_head, x);
}

template<class T>
void List<T>::PopBack()
{
    Erase(_head->_prev);
}

template<class T>
void List<T>::PushFront(const T& x)
{
    Insert(_head->_next, x);
}

template<class T>
void List<T>::PopFront()
{
    Erase(_head->_next);
}

template<class T>
void List<T>::Insert(Node* pos, const T& x)
{
    assert(pos);
    Node* prev = pos->_prev;
    Node* new_node = new Node(x);
    prev->_next = new_node;
    new_node->_prev = prev;
    new_node->_next = pos;
    pos->_prev = new_node;
}

template<class T>
void List<T>::Erase(Node* pos)
{
    assert(pos && pos != _head);
    Node* prev = pos->_prev;
    Node* next = pos->_next;
    prev->_next = next;
    next->_prev = prev;
    delete pos;
}

void TestList()
{
    List<int> l;
    l.PushBack(1);
    l.PushBack(2);
    l.PushBack(3);
    l.PushBack(4);
    l.Print();
    ListNode<int>* cur = l.Find(4);
    l.Insert(cur, 5);
    l.Print();

    List<int> l1(l);
    l1.Print();
}

Stack.h

#pragma once

//适配器模式
//模板的模板参数

template<class T, class Container>
class Stack
{
public:
    void Push(const T& x)     //入栈
    {
        _con.PushBack(x);
    }

    void Pop()                //出栈
    {
        _con.PopBack();
    }

    const T& Top() const      //取栈顶元素
    {
        return _con.Back();
    }

    size_t Size()
    {
        _con.Size();
    }

    bool Empty()
    {
        return _con.Empty();
    }

protected:
    Container _con;
};

void TestStack()
{
    Stack<int, Vector<int>> s;
    s.Push(1);
    s.Push(2);
    s.Push(3);
    s.Push(4);
    while (!s.Empty())
    {
        cout << s.Top() << " ";
        s.Pop();
    }
    cout << endl;
}

Queue.h

#pragma once

template<class T, class Container>
class Queue
{
public:
    void Push(const T& x)       //入队列
    {
        _con.PushBack(x);
    }

    void Pop()                  //出队列
    {
        _con.PopFront();
    }

    const T& Front() const      //取队首元素
    {
        return _con.Front();
    }

    bool Empty() const
    {
        return _con.Empty();
    }
protected:
    Container _con;
};

void TestQueue()
{
    Queue<int, List<int>> q;
    q.Push(1);
    q.Push(2);
    q.Push(3);
    q.Push(4);

    while (!q.Empty())
    {
        cout << q.Front() << " ";
        q.Pop();
    }
    cout << endl;
}

test.cpp

#define _CRT_SECURE_NO_WARNINGS 1

#include <stdio.h>
#include <assert.h>
#include <string.h>
#include <iostream>
using namespace std;

#include "Vector.h"
#include "List.h"
#include "stack.h"
#include "Queue.h"

int main()
{
    TestVector();
    TestList();
    TestStack();
    TestQueue();
    system("pause");
    return 0;
}
如何在C++中建立一个顺序表
09-04
在使用顺序表之前，首先创建一个空的顺序表，也就是初始化顺序表。这里，在程序中只需设置顺序表的结点数量ListLen为0即可。这样，后面需要添加的数据元素将从顺序表的第一个位置存储
双向栈的基本操作和实现
05-08
/************************************************** 实验二 双向栈实现 1、 定义栈的存储结构。 2、 编写程序实现双向栈的基本操作：1）初始化；2）判断栈是否为空；3）判断栈是否已满；4）入栈；5）出栈；6）清空栈；7）取栈顶元素。 3、 所写源代码编程风格良好，有详细注释。 4、 程序运行界面良好，使用菜单实现每个基本操作。 ****************************************************/ #include #include #include #define NULL 0 #define MAX 20 #define TRUE 1 #define FALSE 0 typedef struct tagstack{ /*定义一个双向栈*/ int * pStack;/*栈底 同base指针*/ int lefttop;/*左栈栈顶*/ int righttop;/*右栈栈顶*/ }STACK;
C++——详解顺序表
imaima666的博客
05-14 1493
顺序表是一种线性表的存储结构，它是由一组连续的存储单元（通常是数组）依次存储线性表中的元素，元素之间的顺序关系由它们在存储空间中的相对位置来表示。
顺序表(c++)
sin_0119的博客
09-24 2120
数据结构 顺序表
数据结构实验（4）
zu_zhu_xia的博客
10-05 2316
数据结构实验：设计两个栈 S1、S2 都采用顺序栈方式，并且共享一个存储区[0，MaxLen-1]，为了尽量利用空间，减少溢出的可能，可采用栈顶相向、迎面增长的存储方式，如图所示。设计一个有关栈的入栈和出栈算法。
c++实现顺序表
wangpengcsdn1的博客
03-25 835
#define _CRT_SECURE_NO_WARNINGS 1 #include #include using namespace std; class Seqlist { public: Seqlist() :_a(NULL),_size(1),_capacity(1) { } Seqlist(const Seqlist& s) { if (this
用双向链表实现栈和队列
qq_74727181的博客
01-30 724
前几天发了一篇关于模板类双向链表的文章，介绍了一些链表的基本情况，同时用c++的模板类实现了双向链表的基本结构和基础功能。今天想要写一些使用双线链表实现栈和队列的内容。因为栈和队列的性质只需要在头或者尾处增减元素，所以相对于顺序表来说，链表更适合，能够轻松的实现动态的栈和队列。
链表模板、队列模板、顺序表模板、栈模板、
Sunnylunch-blog
08-26 1431
#pragma once #include #include #include using namespace std; template struct Node { public: Node(const T& d) :_next(NULL) , _prev(NULL) ,_data(d){} T _data; Node *_next; Node *_prev; };
C++实现链表、链式栈、链式队列、链表快速排序（模版）
热门推荐
concyclics的博客
04-28 3万+
C++实现链表、链式栈、链式队列、链表快速排序一、实现链表1. 什么是链表2. 单向链表和双向链表单向链表双向链表3. 代码实现头文件定义（List.hpp）实现代码(List.cpp) 一、实现链表 1. 什么是链表 百度百科 链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺
链表：顺序表、单链表、循环链表、双向链表
try_again_later的博客
06-10 1736
内部结点唯一的前驱和后继，表头 只有后继，表尾只有前驱。 1、线性结构 线性表：顺序表（数组）、链表 栈：插入和删除都限制在表的同一端进行（后入先出） 队列：插入在一端，删除在另一端（先进先出） //线性表类模板如下，是顺序表类和链表类的基类,用虚函数virtual template <class T> //value的类型是T class LinearLi...
顺序表(C++类模板实现)
zws的博客
07-28 4739
文章目录1. 用C++实现顺序表2. 代码 1. 用C++实现顺序表     本文用到C++中的类模板,用类模板的好处就是方便建立任何类型的顺序表。但类模板这里有个坑就是无法分离编译，具体原因可以百度搜索类模板无法分离编译。最后废话不多说，直接上代码。 2. 代码     sqlist.h文件实现顺序表的声明和定义 #ifndef SQLIST_H #define SQLIST_H #define INIT_SIZE 100 #
c c++ 顺序表 链表 队 栈 树类模板实现 以及例子
01-27
c/c++ 顺序表 、链表 、队 、栈 、树、类模板实现 以及例子
C++实现顺序表的14种操作
Kirk.Vito的博客
12-27 1万+
C++顺序表的操作 2017/12/27 // 顺序表.cpp: 定义控制台应用程序的入口点。 //Author:kgvito YinZongYao //Date: 2017.12.27 #include<iostream> using namespace std; #define MAXSIZE 3 #define Node ElemType #define ERRO...
C++ 顺序表的基本操作（使用模版类）
ChanJose的博客
01-04 4048
一、遇到问题：        原因：类的函数定义不能放在SeqList.cpp中，必须放在Seqlist.h(类的函数声明和定义放在同一个文件下)中，否则        会出现以下问题。         二、实现程序：    1.SeqList.h #ifndef SeqList_h #define SeqList_h #include &lt;iostream&gt; using ...
顺序表(C++实现)
qq_39559641的博客
04-07 1万+
一、实现要求 （1）求顺序表中第i个元素（函数），若不存在，报错。 （2）在第i个结点前插入值为x的结点。 （3）删除顺序表中第i个元素结点。 （4）在一个递增有序的顺序表L中插入一个值为x的元素，并保持其递增有序特性。 （5）将顺序表Ｌ中的奇数项和偶数项结点分解开（元素值为奇数、偶数），分别放入新的顺序表中，然后原表和新表元素同时输出到屏幕上，以便对照求解结果。 （6）求两个递增有序...
C/C++ 实现链式栈
最新发布
Yhame的博客
04-04 635
链栈是通过链表实现的栈，具有动态分配、无栈满限制的优点；常见的两种链栈实现方式是“带头结点”和“不带头结点”；使用哪种方式可以根据需求和个人喜好选择；掌握链栈，是为后续理解表达式求值、括号匹配、递归调用等打好基础！如有问题也欢迎留言讨论交流~
顺序表的C++实现方法
qq_51534032的博客
01-11 1154
数据结构——顺序表的C++实现 之后我会经常在这里更新我的数据结构学习成果，每天进步一点点，加油，加油，加油 如果有小伙伴一起学习就更好了hhh #include<iostream> using namespace std; template<class T> class List { }; template<class T>//线性表的元素类型为T class ArrayList :public List<T> { private: T* ar
C++实现顺序表（模板类）
晶凌玄夜的博客
10-13 1393
C++实现动态（可扩容）顺序表 .h—头文件 #pragma once #include<iostream> #include<cassert> using namespace std; template<class T> class Seqlist { private: T* _array; size_t _capacity;//容量 size_t ...
c++实现顺序表类（顺序存储）
zhangchongzc的博客
01-22 2747
类的声明 一般类的声明在头文件中进行,类中成员函数的实现在源文件中进行 #define node elemType //将node变量化，以后node如果要替换为双链表节点等，只需要修改此处即可 using namespace std; typedef int dataType; //与上同样的道理，如果数据类型有变化，只需要修改此处即可 class node{ public: d...
C++ 顺序表的类实现
qq_38236355的博客
08-30 2767
1、顺序表的定义 将表中元素一个接一个的存入一组连续的存储单元中，这种存储结构是顺序结构，采用顺序存储结构的线性表简称为“ 顺序表”。 顺序表的存储特点是：只要确定了起始位置，表中任一元素的地址都通过下列公式得到： Loc(ai)=Loc(a1)+(i−1)∗L,1≤i≤n 其中，L是元素占用存储单元的长度。 2、顺序表的基本操作 （1）初始化：建立一个空的顺序表； （2）新建：新建一个顺序表； ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值