（C++）vector & list 的使用和模拟实现

最新推荐文章于 2022-08-25 16:35:55 发布
最新推荐文章于 2022-08-25 16:35:55 发布
阅读量391 收藏 5
点赞数 3
分类专栏： C++ 文章标签： c++ 迭代器 vector list
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/js_evey/article/details/78106910
版权

顺序容器（sequential container）

  • 顺序容器为程序员提供了控制元素储存和访问顺序的能力。
  • 这种顺序不依赖于元素的值，而是与元素加入容器时的位置相对应。

迭代器

  • 提供对对象的间接访问。
  • 使用迭代器可以访问某个元素，迭代器也能从一个元素移动到另外一个元素。
  • 迭代器有 有效和无效之分，
  • 有效的迭代器或指向某个元素，或指向容器中尾元素的下一位置。
  • 其他情况都属于无效。

使用

  • begin(): 负责返回指向第一个元素
  • end():负责返回只想最后一个元素的下一个位置。也就是说，该迭代器指向的是容器一个本不存在的“尾后”（off the end）元素。
  • 特殊情况下，如果容器为空，则begin和end返回的是同一个迭代器。都是尾后迭代器。

vector

特点

  • 可变大小数组。
  • 支持快速随机访问。
  • 在尾部之外的位置插入或删除元素可能很慢。

函数接口

这里写图片描述

使用

代码：

int main()
{
    vector<int>::iterator it;
    vector<int> v1;

    v1.push_back(1);
    v1.push_back(2);
    v1.push_back(3);
    v1.push_back(4);

    for (auto it = v1.begin(); it != v1.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    v1.pop_back();
    v1.pop_back();
    v1.pop_back();

    for (auto it = v1.begin(); it != v1.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    it = v1.begin();
    it = v1.insert(it, 100);

    for (it = v1.begin(); it != v1.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    v1.push_back(12);
    v1.push_back(13);
    v1.push_back(14);
    v1.push_back(15);

    for (it = v1.begin(); it != v1.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    it = v1.begin();
    v1.erase(it + 3);

    for (it = v1.begin(); it != v1.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    vector<int> v2(3, 30);
    vector<int> v3(6, 60);

    for (it = v2.begin(); it != v2.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    for (it = v3.begin(); it != v3.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    v2.swap(v3);
    for (it = v2.begin(); it != v2.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    for (it = v3.begin(); it != v3.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    getchar();
    return 0;
}

运行结果：

这里写图片描述

实现

代码：

#include<iostream>
#include<vector>
#include<list>
#include<assert.h>

using namespace std;

template<class T>
class MyVector
{
public:
    MyVector()
        :_data(NULL)
        , _size(0)
        , _capacity(0)
    {}

    MyVector(const MyVector<T> &s)
    {
        _data = new T[s._size];
        for (size_t i = 0; i < _size; ++i)
        {
            _data[i] = s._data[i];
        }
        _size = s._size;
        _capacity = s._capacity;
    }

    ~MyVector()
    {
        if (_data)
        {
            delete[] _data;
            _data = NULL;
            _size = 0;
            _capacity = 0;
        }
    }

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

    void PopBack()
    {
        assert(_size);
        --_size;
    }

    void Insert(size_t n, const T& data)
    {
        assert(n < _size);
        CheckCapacity();
        T cur = _size - 1;
        for (size_t i = n; i <_size; ++i)
        {
            _data[cur+1] = _data[cur];
            cur--;
        }
        _data[n] = data;
        ++_size;
    }

    void Erase(size_t n)
    {
        assert(n < _size);
        for (size_t i = n-1; i < _size; ++i)
        {
            _data[i] = _data[i + 1];
        }
        --_size;
    }

    void CheckCapacity()
    {
        if (_size == _capacity)
        {
            size_t NewCapacity =_capacity * 2 + 3;
            T* pData = new T[NewCapacity];

            for (size_t i = 0; i < _size; ++i)
            {
                pData[i] = _data[i];
            }

            delete[] _data;
            _data = pData;
            _capacity = NewCapacity;
        }
    }

    void Print()
    {
        assert(_size);
        for (size_t i = 0; i < _size; ++i)
        {
            cout << _data[i] << " ";
        }
        cout << endl;
    }

    void clear()
    {
        _size = 0;
    }

    void Swap(MyVector<T> v)
    {
        swap(_data, v._data);
        swap(_size, v._size);
        swap(_capacity, v._capacity);
    }

    T& operator[](size_t pos)
    {
        assert(pos<_size);
        return _data[pos];
    }

    size_t Size()
    {
        return _size;
    }

    size_t Capacity()
    {
        return _capacity;
    }

    bool Empty()
    {
        return (_size == 0);
    }
private:
    T* _data;
    size_t _size;
    size_t _capacity;
};

测试代码：

int main()
{
    MyVector<int> v1;
    v1.PushBack(1);
    v1.PushBack(2);
    v1.PushBack(3);
    v1.PushBack(4);
    v1.Print();

    v1.PopBack();
    v1.PopBack();
    v1.Print();

    v1.Insert(1, 2);
    v1.Insert(1, 2);
    v1.Insert(1, 2);
    v1.Print();

    v1.Erase(1);
    v1.Erase(1);
    v1.Erase(1);

    v1.Print();


    getchar();
    return 0;
}

运行结果：

这里写图片描述

list

特点

  • 双向链表。
  • 只支持双向顺序访问。
  • 在list中任何位置进行插入/删除操作速度都很快。

函数接口

这里写图片描述

使用

代码：

int main()
{
    list<int> l1;
    list<int>::iterator it;

    l1.push_back(1);
    l1.push_back(2);
    l1.push_back(3);
    l1.push_back(4);

    for (auto it = l1.begin(); it != l1.end();++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    l1.pop_front();
    l1.pop_front();


    for (auto it = l1.begin(); it != l1.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    it = l1.begin();
    ++it;

    l1.insert(it, 10);
    l1.insert(it, 3, 30);

    for (auto it = l1.begin(); it != l1.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    it = l1.begin();
    advance(it,3);
    l1.erase(it);

    for (auto it = l1.begin(); it != l1.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    list<int> l2(3, 12);
    list<int> l3(5, 16);

    for (auto it = l2.begin(); it != l2.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;
    for (auto it = l3.begin(); it != l3.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    l2.swap(l3);
    for (auto it = l2.begin(); it != l2.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;
    for (auto it = l3.begin(); it != l3.end(); ++it)
    {
        cout << *it << " ";
    }
    cout << endl;

    getchar();
    return 0;
}

运行结果：

这里写图片描述

实现

代码：

#include<iostream>
#include<vector>
#include<list>
#include<assert.h>

using namespace std;

template<class T>
struct ListNode
{
    ListNode(const T& data = T())
    :_pre(NULL)
    , _next(NULL)
    , _data(data)
    {}

    ListNode<T>* _pre;
    ListNode<T>* _next;
    T _data;
};

//迭代器
template<class T, class Ref>
class ListIterator
{
    template<class T>//声明友元函数类
    friend class MyList;

    typedef ListIterator<T, Ref> self;
public:
    ListIterator()
        :_pNode(NULL)
    {}

    ListIterator(ListNode<T>* pNode)
        :_pNode(pNode)
    {}

    Ref operator*()
    {
        return _pNode->_data;
    }

    self& operator++()
    {
        _pNode = _pNode->_next;
        return *this;
    }

    self operator++(int)//后置
    {
        self tmp(*this);
        _pNode = _pNode->_next;
        return tmp;
    }

    self operator--()
    {
        _pNode = _pNode->_pre;
        return *this;
    }

    self& operator--(int)//后置
    {
        self tmp(*this);
        _pNode = _pNode->_pre;
        return tmp;
    }

    bool operator == (const self& s)
    {
        return _pNode == s._pNode;
    }

    bool operator != (const self& s)
    {
        return _pNode != s._pNode;
    }

private:
    ListNode<T>* _pNode;

};

template<class T>
class MyList
{
public:
    typedef ListIterator<T, T&> Iterator;

public:
    Iterator begin()
    {
        return Iterator(_pHead->_next);
    }

    Iterator end()
    {
        return Iterator(_pHead);
    }

    /*Iterator Find(const T& data)
    {
        ListNode<T>* pCur = _pHead->_next;
        while (pCur != _pHead)
        {
            if (data == pCur->_data)
                return Iterator(pCur);
            pCur = pCur->_next;
        }
    }*/

    MyList()
    {
        CreateHead();
    }

    MyList(size_t n, const T& data)
    {
        CreateHead();
        for (size_t = i; i < n; ++i)
        {
            PushBack(data);
        }
    }

    ~MyList()
    {
        Clear();
        delete _pHead;
        _pHead = NULL;
    }

    void Clear()
    {
        ListNode<T>* pCur = _pHead->_next;
        ListNode<T>* pPre = NULL;

        while (pCur != _pHead)
        {
            pPre = pCur;
            pCur = pCur->_next;
            delete pPre;
        }

        _pHead->_next = _pHead;
        _pHead->_pre = _pHead;

    }

    void PushBack(const T& data)
    {
        ListNode<T>* pTail = _pHead->_pre;
        ListNode<T>* pTmp = new ListNode<T>(data);
        pTail->_next = pTmp;
        pTmp->_next = _pHead;
        pTmp->_pre = pTail;
        _pHead->_pre = pTmp;
    }

    void PopBack()
    {
        if (_pHead == _pHead->_next)
        {
            assert(false);
            return;
        }

        ListNode<T>* pTmp = _pHead->_pre;
        pTmp->_pre->_next = _pHead;
        _pHead->_pre = pTmp->_pre;
        delete pTmp;
    }

    void PushFront(const T& data)
    {
        ListNode<T>* pTmp = _pHead->_next;
        ListNode<T>* pNew = new ListNode<T>(data);

        _pHead->_next = pNew;
        pNew->_next = pTmp;
        pTmp->_pre = pNew;
        pNew->_pre = _pHead;
    }

    void PopFront()
    {
        ListNode<T>* pTmp = _pHead->_next;
        _pHead->_next = pTmp->_next;
        pTmp->_next->_pre = _pHead;
        delete pTmp;
    }

    void Insert(const Iterator position, const T& data)
    {
        ListNode<T>* pTmp = _pHead->_next;

        while (pTmp != _pHead)
        {
            if (pTmp->_data == data)
                break;
            pTmp = pTmp->_next;
        }

        ListNode<T>* pNew = new ListNode<T>(data);
        pNew->_next = pTmp->_next;
        pNew->_pre = pTmp;
        pTmp->_next = pNew;
    }

    void Erase(const Iterator position)
    {
        ListNode<T>* pCur = _pHead->_next;

        while (pCur != _pHead)
        {
            if (pCur == position._pNode)
            {
                break;
            }
            pCur = pCur->_next;
        }

        pCur->_pre->_next = pCur->_next;
        pCur->_next->_pre = pCur->_pre;
        delete pCur;
    }

    bool Empty()
    {
        return _pNext->next == _pHead;
    }

    size_t Size() const
    {
        size_t count = 0;
        ListNode<T>* pCur = _pHead->_next;
        while (pCur != _pHead)
        {
            pCur = pCur->_next;
            count++;
        }
        return count;
    }

    void Print()
    {
        ListNode<T>* pTmp = _pHead->_next;
        while (pTmp != _pHead)
        {
            cout <<pTmp->_data<<" ";
            pTmp = pTmp->_next;
        }
        cout << endl;
    }

protected:
    void CreateHead()
    {
        _pHead = new ListNode<T>;
        _pHead->_next = _pHead;
        _pHead->_pre = _pHead;
    }
private:
    ListNode<T>* _pHead;
};

测试代码：

int main()
{
    MyList<int> l1;
    l1.PushBack(1);
    l1.PushBack(2);
    l1.PushBack(3);
    l1.PushBack(4);
    l1.Print();



    l1.PopBack();
    l1.PopBack();
    l1.Print();

    l1.PushFront(10);
    l1.PushFront(20);
    l1.PushFront(30);
    l1.Print();

    l1.PopFront();
    l1.PopFront();
    l1.PopFront();
    l1.PopBack();
    l1.PopBack();

    l1.Print();

    l1.PushBack(10);
    l1.PushBack(20);
    l1.PushBack(30);

    MyList<int>::Iterator it;
    //for (auto it = l1.begin(); it != l1.end(); ++it)
    //{
    //cout << *it << " ";
    //}
    //cout << endl;

    it = l1.begin();
    it++;

    l1.Insert(it, 2);
    l1.Print();

    it = l1.begin();

    l1.Erase(it);
    l1.Print();

    getchar();
    return 0;
}

运行结果：

这里写图片描述

JS-js
关注
  • 3
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
android jni中使用std::vector
安卓兼职framework和app工程师的博客
11-02 1896
在jni开发中 std::vector可以理解为动态数组，其特点和基本操作方式与array相似，但vector可以动态调整大小。 vector中的元素是连续存储的，这意味着我们不仅可以通过迭代器std::vector::iterator，还可以像array一样使用下标来访问任意位置的元素。 它和c++中的用法一样的 现在就用jni来写个案例来实现使用std:vector 案例如下: 头文件 Study_One.h #ifndef JNITEST_STUDY_ONE_H #define JNITEST_STU
STL8:vector和list的简单实现
k0512的博客
04-18 214
1、vector.cpp 实现了vector类的基本功能函数，迭代器等。 #include <iostream> #include<algorithm> #include <numeric> using namespace std; //迭代器操作就是指针的操作 namespace miniSTL{ //miniSTL命名空间 template<typename T> class vector{ public: typedef T value_t
将一个list容器的所有元素赋值给一个vector容器。
hannea的专栏
03-28 1486
#include #include #include #include using namespace std; int main() { char* pchar[]= {"what", "is", "your", "name"}; list clist(pchar , pchar+4); //注意这里初始化存储指向c风格字符串的char*指针的容器的方法。 vector svec; s
刷题的一天——链表结构
Hollowbrain的博客
04-09 1194
1、给定一个头结点为head的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。 示例： 输入：[1,2,3,4,5] 输出：此列表中的结点 3 (序列化形式：[3,4,5]) 返回的结点值为 3 。 (测评系统对该结点序列化表述是 [3,4,5])。 注意，我们返回了一个 ListNode 类型的对象 ans，这样： ans.val = 3, ans.next.val = 4, ans.next.next.val = 5, 以及 ans.next.next.next = ...
模拟实现vector和list 并用list适配出栈，用vector适配出队列
Misszhoudandan的博客
06-18 370
您要的代码已经备好，请准备查收,——————- MyVector的实现 #pragma once #include &amp;lt;stdio.h&amp;gt; #include &amp;lt;string&amp;gt; #include &amp;lt;string.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; #include &amp;lt;assert.h&amp;
c++ vector模拟实现代码
08-25
vector是C++ STL中一个非常重要的容器，了解 vector 的底层实现原理，可以很好的帮助我们更加熟练的使用vector。这篇文章通过实例代码给大家介绍c++ vector模拟实现，感兴趣的朋友跟随小编一起看看吧
C++ 使用模板实现一个List的实例
08-30
主要介绍了 C++ 使用模板实现一个List的实例的相关资料,需要的朋友可以参考下
C++模拟实现vector
03-07
C++模拟实现vector
C++ vector使用的一些注意事项
08-25
主要给大家介绍了关于C++ vector使用的一些注意事项，文中通过示例代码介绍的非常详细，对大家学习或者使用C++具有一定的参考学习价值，需要的朋友们下面来一起学习学习吧
vector和list的使用
qqkb1016的博客
11-04 1313
vector是C++标准模板库中的部分内容，是一种容器。它是一个多功能的，能够操作多种数据结构和算法的模板类和函数库。vector之所以被认为是一个容器，是因为它能够像容器一样存放各种类型的对象，简单地说，vector是一个能够存放任意类型的动态数组，能够增加和压缩数据。 使用它时需要包含头文件：#include vector类型的初始化： vector a ; //声明一个int
C++ 自定义单向链表 ListNode
qq_43799400的博客
02-15 1256
直接上代码： #include <iostream> #include <assert.h> #include <vector> #include <algorithm> using namespace std; /* * 链表有两种： * 1、带头结点，头结点存放的是链表的长度，从第二个节点开始存放数据。 * 2、不带头结点，没有存放链表长度的节点，从头结点开始就存放数据。 * 我这里定义的链表是第二种。 */ struct ListNode {
STL中Vector和List的底层数据结构
木牛的博客
08-25 534
摘要：本文列出几个基本的STL map和STL set的问题，通过解答这些问题讲解了STL关联容器内部的数据结构，最后提出了关于UNIX/LINUX自带平衡二叉树库函数和map, set选择问题，并分析了map, set的优势之处。对于希望深入学习STL和希望了解STL map等关联容器底层数据结构的朋友来说，有一定的参考价值。vector（向量）——STL中标准而安全的数组。只能在vector 的“前面”增加数据。 deque（双端队列double-ended queue）——在功能上和vector相似
【数据结构】STL中的vector和list
Damu
09-19 1024
表的ADT有两种流行的实现方法，vector提供表ADT的一种可增长的数组实现。使用vector的有点在与它是以常数时间可索引（indexabel）的。缺点是插入新项和删除现有项的代价高昂，除非变化发生在vector的尾端。而list则提供表ADT的双向链表实现。使用list的有点事插入新项和删除现有项代价地炼，但是假设变动的位置是已知的。缺点是list不用一被索引，vector和list两者在执行
【C++】vectorList类的实现
清风微醺的博客
01-26 172
**vectorList.h : ** #pragma once #include<vector> #include<iostream> using namespace std; template<class T> class vectorList { protected: void checkIndex(int theIndex) const; vector<T>* element;//存储线性表元素的向量 public: vectorList(int
C++:Vector和List的实现
qq_41027326的博客
07-16 657
Vector的实现 //test.h #pragma once #include &amp;lt;iostream&amp;gt; #include &amp;lt;cstdio&amp;gt; #include &amp;lt;string.h&amp;gt; #include &amp;lt;assert.h&amp;gt; using namespace std; typedef int DataType; #define TE
C++——实现Vector&List
Tianzez的博客
04-20 382
1. Vector &lt; Vector.h &gt; #ifndef __VECTOR_H__ #define __VECTOR_H__ #include &lt;iostream&gt; #include &lt;stdlib.h&gt; #include &lt;string.h&gt; typedef int DataType; class Vector { public: ...
c++数据结构与算法(1)——链表（双指针）
qq_32008381的博客
01-17 489
方法归纳，dummy节点、双指针 代表题型 21. 合并两个有序链表（简单） 23. 合并K个升序链表（困难） 141. 环形链表（简单） 142. 环形链表 II（中等） 876. 链表的中间结点（简单） 160. 相交链表（简单） 19. 删除链表的倒数第 N 个结点（中等） ----------------------------------------------------------------------------------------------------------
vector和list的使用及其模拟实现
Sakuramyb马永博的博客
11-11 468
一.vector使用及模拟实现。1.vector简介。 vector和数组类似，拥有一段连续的内存空间，并且起始地址不变。 因此能高效的进行随机存取，时间复杂度为o(1); 但因为内存空间是连续的，所以在进行插入和删除操作时，会造成内存块的拷贝，时间复杂度为o(n)。 另外，当数组中内存空间不够时，会重新申请一块内存空间并进行内存拷贝。注：vector相当于一个动态增长的数组。2.vecto
C++——合并k个有序链表
一抹阳光的博客
06-16 1395
对于合并k个有序链表，可以先看一下合并两个有序链表的思想，（点这里） 对于k个链表的合并，我们可以基于两个有序链表的合并思想，先将两个链表合并为一个链表，再将得到的结果链表与第三个链表合并为一个链表，以此类推，最终将k个链表合并为一个有序链表。 本篇不在累述这种方法，对于k个有序链表，我们可以考虑优先队列，首先将所有链表入队，然后重载比较操作符，用于构建链表节点的小根堆，依次取出队首节点，得到的新的链表就是一个有序的链表。 这里有两个点需要注意： 1.我们优先队列中的是一个个链表，而每次队首最..
c++模拟实现vector
最新发布
09-01
可以使用预留空间和逐个添加元素的方式，也可以使用动态数组和复制数据的方式来实现vector类。具体的实现方式可以根据需求和实际情况选择。<span class="em">1</span><span class="em">2</span><span class="em">3 #...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值