C++ 模板实现Vector和双向链表

最新推荐文章于 2024-01-20 14:55:30 发布
原创 最新推荐文章于 2024-01-20 14:55:30 发布 · 1.1k 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

本文介绍了一种使用模板来实现Vector类和双向链表的具体方法。Vector类支持多种操作，如插入、删除、调整大小等，并且适用于内置类型和自定义类型。双向链表则实现了基本的链表操作，包括前插、后插、查找和删除等。这两个数据结构均采用泛型编程以提高代码复用率。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

模板实现Vector

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <assert.h>
using namespace std;

template<class T>
class Vector
{
public:
    Vector()
        :_pData(new T[3])
        ,_size(0)
        ,_capacity(3)
    {}

    Vector(size_t n, const T& data)
    {
        while(n--)
        {
            Check_capacity();
            _pData[_size++] = data;
        }
    }

    Vector(const Vector& v)
        :_pData(new T[strlen(v._pData)+1])
        ,_size(v._size)
        ,_capacity(v._capacity)
    {
        strcpy(_pData, v._pData);
    }

    Vector& operator =(Vector v)
    {
        Swap(*this, v);
        return *this;
    }

    ~Vector()
    {
        if(_pData != NULL)
        {
            delete[] _pData;
            _pData = NULL;
        }
    }

    void Swap(Vector& v)
    {
        std::swap(_pData, v._pData);
        std::swap(_size, v._size);
        std::swap(_capacity, v._capacity);
    }

    void PushBack(const T& data)
    {
            Check_capacity();
            _pData[_size++] = data;
    }

    void PopBack()
    {
        if(_size != 0)
            _size--;
    }

    void PushFront(const T& data)
    {
        Check_capacity();
        for(size_t i = _size; i > 0; i--)
        {
            _pData[i] = _pData[i-1];
        }
        _pData[0] = data;
        _size++;
    }

    void PopFront()
    {
        assert(_size);
        for(size_t i = 1; i < _size-1; i++)
        {
            _pData[i-1] = _pData[i];
        }
        _size--;
    }

    void Insert(size_t pos, const T& data)
    {
        assert(_size && pos>=0 && pos<=_size);
        Check_capacity();
        for(size_t i = _size; i > pos; i--)
        {
            _pData[i] = _pData[i-1];
        }
        _pData[pos] = data;
        _size++;
    }

    void Erase(size_t pos)
    {
        assert(_size);
        assert(_size && pos>=0 && pos<_size);
        for(size_t i = pos; i < _size-1; i++)
        {
            _pData[i] = _pData[i+1];
        }
        _size--;
    }

    void Assign(size_t n, const T& data)
    {
        _size = 0;
        while(n--)
        {
            Check_capacity();
            _pData[_size++] = data;
        }
    }
    void Clear()
    {
        delete[] _pData;
        _pData = NULL;
    }

    T& operator [](size_t index)
    {
        assert(index < _size);
        return _pData[index];
    }

    const T& operator [](size_t index)const
    {
        assert(indec < _size);
        return _pData[index];
    }

    T& Front()
    {
        return _pData[0];
    }

    const T& Front()const
    {
        return _pData[0];
    }

    T& Back()
    {
        return _pData[_size-1];
    }

    const T& Back()const
    {
        return _pData[_size-1];
    }

    size_t Size()const
    {
        return _size;
    }

    size_t Capacity()const
    {
        return _capacity;
    }

    bool Empty()const
    {
        return _size == 0;
    }
    void ReSize(size_t sz, const T& data = T())
    {
        if(_size > sz)
        {
            _size = sz;
        }
        else if(_size < sz)
        {
            while(sz > _size)
            {
                Check_capacity();
                _pData[_size++] = T();
            }
        }
    }

    void Reserve(size_t n)
    {
        size_t tmp = _size;
        while(_size < n)
        {
            Check_capacity();
            _size++;
        }
        _size = tmp;
    }

    void Print()const
    {
        if(_pData != NULL)
        {
            for(size_t i = 0; i < _size; i++)
            {
                cout<<_pData[i]<<"  ";
            }
            cout<<endl;
        }
        else
            cout<<"NULL"<<endl;
    }

    void Print_String()const
    {
        if(_pData != NULL)
        {
            for(size_t i = 0; i < _size; i++)
            {
                cout<<(*(_pData+i)).Pri()<<"  ";
            }
            cout<<endl;
        }
        else
            cout<<"NULL"<<endl;
    }

private:
    void Check_capacity()
    {
        if(_size >= _capacity)
        {
            T* newpData = new T[_size*2];

            //1.深拷贝，调用的时赋值运算符重载operator=
            for(size_t i = 0; i < _size; i++)
            {
                newpData[i] = _pData[i];
            }
            delete[] _pData;
            _pData = newpData;
            _capacity = _size*2;

            ////2.浅拷贝，自定义类型设计资源时，可能会出错，思考
            //memcpy(_pData, newpData, sizeof(T)*_size);
            //_pData = newpData;
        }
    }

    T* _pData;
    size_t _size;
    size_t _capacity;
};

class String
{
public:
    String(const char* str = "")
        :_str(new char[strlen(str)+1])
    {
        strcpy(_str, str);
    }

    String(const String& s)
        :_str(new char[strlen(s._str)+1])
    {
        strcpy(_str, s._str);
    }

    String& operator =(String s)
    {
        swap(_str, s._str);
        return *this;
    }

    char* Pri()const
    {
        return _str;
    }

    ~String()
    {
            delete[] _str;
            _str = NULL;
    }
private:
    char* _str;
};

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

    v.PopBack();
    v.Print();

    v.PushFront(0);
    v.Print();

    v.PopFront();
    v.Print();

    v.Insert(0, 5);
    v.Print();

    v.Erase(0);
    v.Print();

    cout<<v.Front()<<endl;
    cout<<v[1]<<endl;
    cout<<v.Back()<<endl;

    cout<<v.Size()<<endl;
    cout<<v.Capacity()<<endl;
    cout<<v.Empty()<<endl;

    v.ReSize(2);
    v.Print();

    v.ReSize(10, 0);
    v.Print();

    v.Reserve(5);
    v.Print();

    v.Assign(5, 0);
    v.Print();

    v.Clear();
    v.Print();
}

void Test2()
{
    Vector<String> v;
    v.PushBack("aaaa");
    v.PushBack("bbbb");
    v.PushBack("cccc");
    v.PushBack("dddd");
    v.Print_String();

    v.PopBack();
    v.Print_String();

    v.PushFront("1111");
    v.Print_String();

    v.PopFront();
    v.Print_String();

}

int main()
{
    Test1();//内置类型
    Test2();//类类型
    return 0;
}

这里写图片描述

模板实现双向链表

（头节点不保存数据，不记作有效节点）
#include <iostream>
#include <assert.h>
using namespace std;

template<class T>
struct Node
{
public:
    Node(const T& data = T())
        :_Next(NULL)
        ,_Pre(NULL)
        ,_data(data)
    {}
public:
    Node<T>* _Next;
    Node<T>* _Pre;
    T _data;
};

template<class T>
class List
{
public:
    List()
        :_pHead(new Node<T>)//构造给出头节点(没有有效data)
    {
        _pHead->_Next = _pHead;
        _pHead->_Pre = _pHead;
    }

    List(size_t n, const T& data)
        :_pHead(new Node<T>)//头节点(没有有效data)
    {
        while(n--)
        {
            PushBack(data);
        }
    }

    List(const List& L)
        :_pHead(new Node<T>)
    {
        _pHead->_Next = _pHead;
        _pHead->_Pre = _pHead;
        Node<T>* tmp = L._pHead->Next;
        while(tmp != _pHead)
        {
            PushBack(tmp->_data);
            tmp = tmp->_Next;
        }
    }

    ~List()
    {
        if(_pHead->_Next != _pHead)
        {
            Clear();
        }
        delete[] _pHead;
    }

    void PushBack(const T& data)
    {
        Node<T>* newEnd = CreatNode(data);
        _pHead->_Pre->_Next = newEnd;
        newEnd->_Pre = _pHead->_Pre;
        _pHead->_Pre = newEnd;
        newEnd->_Next = _pHead;
    }

    void PopBack()
    {
        if(_pHead->_Next != _pHead)
        {
            Node<T>* end = _pHead->_Pre;
            _pHead->_Pre = end->_Pre;
            end->_Pre->_Next = _pHead;
            delete[] end;
        }
    }

    void PushFront(const T& data)
    {
        Node<T>* newFront = CreatNode(data);
        _pHead->_Next->_Pre = newFront;
        newFront->_Next = _pHead->_Next;
        _pHead->_Next = newFront;
        newFront->_Pre = _pHead;
    }

    void PopFront()
    {
        if(_pHead->_Next != _pHead)
        {
            Node<T>* tmp = _pHead->_Next;
            _pHead->_Next = tmp->_Next;
            tmp->_Next->_Pre = _pHead;
            delete[] tmp;
        }
    }

    Node<T>* Find(const T& data)
    {
        Node<T>* tmp = _pHead->_Next;
        while(tmp != _pHead)
        {
            if(tmp->_data == data)
                return tmp;
            tmp = tmp->_Next;
        }
        return NULL;
    }

    void Insert(Node<T>* pos, const T& data)
    {
        assert(pos);

        Node<T>* tmp = CreatNode(data);
        tmp->_Next = pos;
        tmp->_Pre = pos->_Pre;
        pos->_Pre->_Next = tmp;
        pos->_Pre = tmp;
    }

    void Erase(Node<T>* pos)
    {
        assert(pos);

        pos->_Pre->_Next = pos->_Next;
        pos->_Next->_Pre = pos->_Pre;
        delete[] pos;
    }

    void Clear()
    {
        while(_pHead->_Next != _pHead)
        {
            PopFront();
        }
    }

    void Assign(size_t n, const T& data)
    {
        Node<T>* tmp = _pHead->_Next;
        while(n--)
        {
            if(tmp != _pHead)
            {
                tmp->_data = data;
                tmp = tmp->_Next;
            }
            else
            {
                PushBack(data);
            }
        }
    }

    bool Empty()const
    {
        return _pHead->_Next == _pHead;
    }

    size_t Size()const
    {
        size_t size = 0;
        Node<T>* tmp = _pHead->_Next;
        while(tmp != _pHead)
        {
            size++;
            tmp = tmp->_Next;
        }
        return size;
    }

    void Print()
    {
        Node<T>* tmp = _pHead->_Next;
        while(tmp != _pHead)
        {
            cout<<tmp->_data<<"  ";
            tmp = tmp->_Next;
        }
        cout<<endl;
    }

private:
    Node<T>* CreatNode(const T& data)
    {
        return new Node<T>(data);
    }

private:
    Node<T>* _pHead;
};

int main()
{
    List<int> L;
    L.PushBack(1);
    L.PushBack(2);
    L.PushBack(3);
    L.PushBack(4);
    L.PushBack(5);
    L.Print();

    L.PopBack();
    L.Print();

    L.PushFront(10);
    L.Print();

    L.PopFront();
    L.Print();

    Node<int>* tmp = L.Find(4);
    L.Insert(tmp, 4);
    L.Print();

    L.Erase(tmp);
    L.Print();

    cout<<L.Empty()<<endl;
    L.Clear();
    cout<<"Size = "<<L.Size()<<endl;

    L.Assign(10, 5);
    L.Print();

    return 0;
}

这里写图片描述

C++学习7-实现链表的类模板/vector类模板
sunshine612的博客
03-13 815
模板名+参数列表=类名 这里写自定义目录标题1.实现链表的类模板2.实现vector类模板（变量定义的三个指针）3.使用类模板写vector容器 1.实现链表的类模板 // text1.cpp : 此文件包含 "main" 函数。程序执行将在此处开始并结束。 // #include "pch.h" #include <iostream> using namespace std; //用...
【C++ STL序列容器】list 双向链表
最新发布
普罗米修斯的博客
04-22 962
普通数组，则 begin() 函数返回的是指向数组第一个元素的指针，同样 end() 返回指向数组中最后一个元素之后一个位置的指针。容器包含的 begin() 和 end() 成员函数的功能完全相同。必须保证新旧容器存储的元素类型一致。
用链表实现vector
weixin_30933531的博客
03-07 400
用链表实现vector的一些功能，部分代码如下，以后还要修改，现在先做一个修正 // keshan.cpp : 定义控制台应用程序的入口点。 // #include "stdafx.h" #include <stdio.h> #include <malloc.h> #define NULL 0 #define LEN sizeof(struct Node) struc...
C++：vector模板
qq_50426849的博客
02-08 346
C++：vector模板
c++如何用vector遍历静态链表
执念斩长河
01-25 452
本博文节选自pta的一道题目，题目上说找出两个单词的公共后缀，然后给出两个头结点地址，单词数的个数N。找出两者公共后缀。这个部分遍历成为了本道题初学者的难点，
C++模板封装Vector和带头结点的双向链表
czf的编程工坊
05-28 566
C++模板封装Vector:注意：1.在Vector的拷贝构造，扩容函数中，需要注意string的影响#pragma once #include &lt;iostream&gt; #include &lt;assert.h&gt; #include &lt;string.h&gt; #include &lt;string&gt; using namespace std; template&...
DSA_CPP.rar_向量_树的C++模板实现_链表
09-21
`list.h`文件中可能会实现单链表或双向链表，包含节点定义（包含数据和指向下一个节点的指针）和链表操作，如插入、删除、遍历等。链表的优点在于插入和删除操作通常比数组快，因为它不需要移动元素。 然后，树...
c++ 模板 双向链表 操作
11-24
在本篇文章中，我们将深入探讨如何使用C++模板来实现双向链表及其操作，如逆序建立链表和插入节点。 首先，我们需要定义一个表示双向链表节点的模板类。这个类通常包含三个部分：数据成员（用于存储数据），一个...
C++模板实现向量、链表与二叉树类及其测试
在list.h文件中，可能实现了一个双向链表（Doubly Linked List），支持在链表头部和尾部进行插入和删除操作，以及双向遍历功能。 测试文件main.cpp可能包含了对上述数据结构实现的测试代码，通过实例化这些模板类和...
算法竞赛基础：C++双向链表的结构和实现（普通链表、List、静态链表）
Royi的学习博客
01-20 1217
本文将会介绍双向链表的结构和操作，包括C++中List容器的操作，以及在算法竞赛中双向链表的实现方式，适合有一定基础的人阅读。
vector/List 实现 （顺序表与双向循环链表实现）
我喜欢雨天的清新的博客
11-19 439
实现#include&amp;lt;iostream&amp;gt; #include&amp;lt;string&amp;gt; #include&amp;lt;assert.h&amp;gt; #include &amp;lt;cstring&amp;gt; using namespace std; struct TrueType {}; struct FalseType {}; template &amp;lt;
双向链表版Vector容器(自实现代码)
qq_43788846的博客
03-02 301
Vector.h #pragma once #include<iostream> #include"errTooBigException.h" #include"errTooSmallException.h" using namespace std; class errSizeException;//下标越界异常类 class errTooBigException;//下标过大类,...
【C++】STL标准模板库（Vector容器-超详细分步实例代码讲解）
米莱虾
01-19 1476
❥主要用作自己复习，外加经验交流分享，每日一更❥ 背景 ❀库是一系列程序组件的集合，可以在不同的程序中重复使用。ANSI C++中包含了一个C++ STL（Standard Template Library），即C++标准模板库（C++泛型库），它在std命名空间中，定义了常用的数据结构和算法，使用起来十分方便。 ❀STL的代码从广义上大致分为三类：算法（algorithm）、容器（container）和迭代器（iterator）。我们一直都在大量地使用标准函数库，所有数学函数、字符串操作函...
C++ 链表，链表各种方法实现原理
WdIg-2023的博客
04-16 246
数组为我们在编程的时候提供了很大的便利，但是有时候我们定义的数组不能满足我们的需求，我们需要一个可变数组来存储我们的数据，我们存储多大数据，就为我们分配多少内存空间，这时候链表就显得尤为重要了
std::vector实现邻接链表
Yoc Lu
03-14 1952
std::vector实现邻接链表 首先定义一个结构体，包括邻接结点和边权值，用来表示一条边: struct Edge { int nextNode;//下一个结点编号 int cost;//该边的权重 }; 为每一个结点都建立一个单链表来保存与其相邻的边权值和结点的信息。使用vector来模拟这些单链表，利用如下语句为每一个结点都建立一个 vector对象（结点数量为N）。 vec...
【C++】链表(list)的使用以及与vector的区别
AAADiao的博客
06-14 4061
在 C++ 中，`std::list` 是标准库提供的一个容器类，用于将数据进行链式存储。**链表**（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。
一个双向链表+Vector查找
hitljs的专栏
03-19 1031
题目是有一堆DoubleLinkedList，然后有一个vector记录了其中的一些节点（可能是中间的某个节点），找出vector中包含的独立DoubleLinkedList的个数。 思想是利用了双链表的性质可以前后查找。因此在Vector中前后走动找到head或者tail为止时间复杂度为O（NLOGN） 代码如下： #include #include using names
【千律】C++基础：使用vector动态数组初始化list链表，并输出list链表
weixin_42704093的博客
04-09 2084
使用vector动态数组初始化list链表（构造函数的方式），并输出list链表。 #include <list> #include <vector> #include <iostream> using namespace std; int main() { // 初始化动态数组 vector<int> vec_int{ 7, 9, 4, 2, 5, 6, 1, 3 }; // 初始化列表 list<int> list_int(ve
C++ 标准模板库STL 双向链表 list 使用方法与应用介绍（一）
热门推荐
聚精会神搞建设
05-13 1万+
STL中的list就是一双向链表，可高效地进行插入删除元素。List 是C++标准程式库中的一个类，可以简单视之为双向连结串行，以线性列的方式管理物件集合。list 的特色是在集合的任何位置增加或删除元素都很快，但是不支持随机存取。list 是C++标准程式库提供的众多容器（container）之一，除此之外还有vector、set、map、…等等。list 以模板方式实现(即泛型)，可以
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值