Cpp || list实现

最新推荐文章于 2023-10-03 17:26:48 发布
最新推荐文章于 2023-10-03 17:26:48 发布
阅读量376 收藏
点赞数
分类专栏： Cpp基础学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jack_wang128801/article/details/105180307
版权

  • 关于list的学习点击下面链接
    list

  • 今天我们来模拟实现一下List这个序列式容器

一:节点定义和迭代器实现

1.每个结点结构的定义
  • list底层实现方式是采用双链表.

在这里插入图片描述

  • 代码如下
template <class T>
struct ListNode{

  ListNode(const T& val=T())
    :_prev(nullptr)
     ,_next(nullptr)
     ,_data(val)
  {

  }

  ListNode<T>* _prev;
  ListNode<T>* _next;
  T _data;
};
2.迭代器的定义
  • 由于list是双向链表,其迭代器必须具备前移、后移的能力。
  • 并且insert(插入)和splice(接合操作)都不会造成原有的list迭代器失效所以需要重新进行定义.

在这里插入图片描述

  • 代码如下
template <class T,class Ref,class Ptr>
struct ListIterator{
  typedef ListNode<T>* pNode;
  typedef ListIterator<T,Ref,Ptr>  self;
  pNode _node;
  ListIterator(pNode node)
  :_node(node)
  {}

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

  //iterator++ 
  self& operator++(int){
    self tmp(*this);
    _node=_node->_next;
    return *tmp;
  }

  self& operator--(){
    _node=_node->_prev;
    return *this;
  }

  self& operator--(int){
    self tmp(*this);
    _node=_node->_prev;
    return tmp;
  }
  bool operator!=(const self& it){
    return _node!=it._node;
  }

  Ref operator*(){
    return _node->_data;
  }
  Ptr operator->(){
    return &_node->_data;
  }
};

二:list的数据结构

在这里插入图片描述

  • list示意图,是环状链表只需要一个标记,即可完全表示整个链表,只要刻意在环状链表的尾端加上一个空白的节点,便符合STL规范之"前闭后开" 区间

三:整体实现List

  • 代码如下
#include<iostream>

using namespace std;

template <class T>
struct ListNode{

  ListNode(const T& val=T())
    :_prev(nullptr)
     ,_next(nullptr)
     ,_data(val)
  {

  }

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

template <class T,class Ref,class Ptr>
struct ListIterator{
  typedef ListNode<T>* pNode;
  typedef ListIterator<T,Ref,Ptr>  self;
  pNode _node;
  ListIterator(pNode node)
  :_node(node)
  {}

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

  //iterator++ 
  self& operator++(int){
    self tmp(*this);
    _node=_node->_next;
    return *tmp;
  }

  self& operator--(){
    _node=_node->_prev;
    return *this;
  }

  self& operator--(int){
    self tmp(*this);
    _node=_node->_prev;
    return tmp;
  }
  bool operator!=(const self& it){
    return _node!=it._node;
  }

  Ref operator*(){
    return _node->_data;
  }
  Ptr operator->(){
    return &_node->_data;
  }
};

template <class T>

class List{
  public:
    typedef   ListNode<T> Node;
    typedef  ListNode<T>* pNode;
    typedef ListIterator<T,T&,T*> iterator;
    typedef ListIterator<T,const T&,const T*> const_iterator;

    //const对象不能调用非const成员函数只能调用const成员函数operator++,
//operator--就不能执行了,不能修改成员_node的值
//导致const迭代器无法执行++，--操作,故这样定义const迭代器不可行
    List(const T& val=T())
      :_head(new Node(val))
    {
      _head->_prev=_head;
      _head->_next=_head;
    }

    List(const List<T>& lst){
      _head=new Node;
      _head->_next=_head;
      _head->_prev=_head;

      pNode cur=lst._head->_next;

      while(cur!=lst._head){
        Push_Back(cur->_data);
        cur=cur->_next;
      }
    }


    ~List(){
      Clear();
      if(_head){
        delete[] _head;
        _head=nullptr;
      }
    }
    void Push_Back(const T& val){
     // pNode new_node=new Node(val);
     // _head->_prev->_next=new_node;
     // new_node->_prev=_head->_prev;
     // new_node->_next=_head;
     // _head->_prev=new_node;
     Insert(end(),val);
    }
 
    void Print(const List<T>& l){
    
      pNode cur=l._head->_next;
      while(cur!=_head){
        cout<<cur->_data<<" ";
        cur=cur->_next;
      }
      cout<<endl;
    }

    List<T>& operator=( List<T>& lst){
      if(this!=&lst){
        pNode cur=lst._head->_next;
        while(cur!=lst._head){
          Push_Back(cur->_data);
          cur=cur->_next;
        }
      }
      return *this;
    }
    void Push_Front(const T& val){
     // pNode new_node=new Node(val);
     // pNode cur=_head->_next;
     // cur->_prev=new_node;
     // new_node->_prev=_head;
     // new_node->_next=cur;
     // _head->_next=new_node;
     
      Insert(begin(),val);
    }

    //迭代器实现
    
    iterator begin(){
      return iterator(_head->_next);
    }

    iterator end(){
      return iterator(_head);
    }

    iterator rbegin(){
      return iterator(_head);
    }

    iterator rend(){
      return iterator(_head->_next);
    }

    const_iterator cbegin() const{
      return const_iterator(_head->_next);
    }

    const_iterator cend() const{
      return const_iterator(_head);
    }

    void Insert(iterator pos,const T& val){
      pNode new_node=new Node(val);
      pNode cur=pos._node;
      pNode prev=cur->_prev;
      prev->_next=new_node;
      new_node->_prev=prev;
      new_node->_next=cur;
      cur->_prev=new_node;
    }

    void Clear(){
      if(_head){
        pNode cur=_head->_next;
        while(cur!=_head){
          pNode next=cur->_next;
          delete cur;
          cur=next;
        }
        _head->_next=_head;
        _head->_prev=_head;
      }
    }

    //Erase:迭代器失效
    //获取Erase的返回值,更新迭代器
    //返回的是当前被删除节点的下一个节点
    iterator Erase(iterator pos){
      if(pos!=end()){
        pNode cur=pos._node;
        pNode prev=cur->_prev;
        pNode next=cur->_next;
        prev->_next=next;
        next->_prev=prev;
        delete cur;
        pos=iterator(next);
      }
      return pos;
    }


    void PopFront(){
      Erase(begin());
    }

    void PopBack(){
      Erase(end());
    }
 
  private:
    ListNode<T>* _head;
};



template <class T>
void Print(const  List<T>& l){
  auto it=l.cbegin();
  while(it!=l.cend()){
    cout<<*it<<" ";
    ++it;
  }
  cout<<endl;
}

void Test(){
  List<int> l;
  l.Push_Back(1);
  l.Push_Back(2);
  l.Push_Back(3);
  l.Push_Front(5);
  l.Print(l);


  cout<<"l.begin():"<<l.begin()._node->_data<<endl;
  cout<<"l.end():"<<l.end()._node->_data<<endl;
  cout<<"l.rbegin():"<<l.rbegin()._node->_data<<endl;
  cout<<"l.rend():"<<l.rend()._node->_data<<endl;
  Print(l);
}


void Test1(){
  List<int> l;
  l.Push_Back(9);
  l.Push_Front(1);
  l.Push_Back(1);
  l.Push_Back(2);
  l.Push_Back(3);
  l.Push_Front(5);
  l.Print(l);
  cout<<"l.begin():"<<l.begin()._node->_data<<endl;
  cout<<"l.end():"<<l.end()._node->_data<<endl;
  cout<<"l.rbegin():"<<l.rbegin()._node->_data<<endl;
  cout<<"l.rend():"<<l.rend()._node->_data<<endl;
  l.Print(l);

  l.Insert(l.begin(),7);
  l.Insert(l.end(),6);
  l.Print(l);
 
  List<int> l1;
  l1=l;
  cout<<"l1:";
  Print(l1);

  List<int> l2(l);
  cout<<"l:";
  Print(l);
  cout<<"l2:";
  Print(l2);
}
int main(){
  Test();
  Test1();
  return 0;
}
  • 测试结果

在这里插入图片描述

iTXCode
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
skiplist跳表C++实现
03-04
skiplist的C++实现，包含test程序
Skiplist-CPP-master.zip
最新发布
05-22
A tiny KV storage based on skiplist written in C++ language| 使用C++开发，基于跳表实现的轻量级键值数据库
C++中的list
CurryCoder的个人博客
04-13 639
1.Cpp中的list双向链表 list是顺序容器的一种，list是一个双向链表。使用list需要包含头文件list。双向链表的每个元素中都有一个指针指向后一个元素，也有一个指针指向前一个元素，如图1所示。 在list容器中，在已经定位到要增删元素的位置的情况下，增删元素能在常数时间内完成。如图2所示，在ai和ai+1之间插入一个元素，只需要修改ai和ai+1中的指针即可。 list容器不支...
C++——list（线性双向链表）
jay_zzs的博客
06-09 1407
1. 基本概念 list也是C++ STL中提供的一种容器，是线性的双向链表的数据结构。拥有链式结构的特征：支持元素的快速插入和删除，但是元素随机访问较慢（相较于vector容器），不提供[]运算符的重载。C++中使用list容器需要包含头文件<list>，把list当做双向链表来看，可以记住list的常用操作，如下： push_back()：添加元素到list尾部。 push_back()：添加元素到list头部。 pop_back()：从list尾部删除元素。 pop_front(
cpp中的list（下）
m0_74202684的博客
08-12 83
我们想到析构函数可以用多个erase（）函数来清理干净，但是用于清理空间的成员函数不仅仅只有析构函数，因此我们单独写出一个clear（）来表示多个erase（）1、在迭代器类中的任何成员函数只用写一个即可，不用像class list一样需要写非const版本和const版本两种，使得代码更加精简起来。2、将迭代器独立封装起来可以更好的区分迭代器可以做的行为（迭代器相关函数）和非迭代器可以做的行为，为了更好的理解。const_iterator中的const T*和Ptr的关系也是互通的。
从零开始的Cpp（2）STL容器：链表list与匿名函数lambda
m0_69248655的博客
10-03 153
list是一个双向链表，可以在任意位置高效地进行元素插入和删除操作。它不支持随机访问，只能通过迭代器进行顺序访问。插入和删除操作对于任意位置的元素都是高效的，不会导致重新分配内存。2.list的主要功能通过一段代码展示list的主要功能在上面的示例中，我们首先创建了一个空的list容器 `myList`。然后，我们使用 `push_back` 和 `push_front` 方法在尾部和头部插入元素。
Cpp || list学习
Template Code
03-28 771
底层是通过循环双链表实现的奥
ListCtrlSet.cpp
08-04
ListCtrl资源文件，实现ListCtrl控件标题及单元格设置颜色，并实现ListCtrl控件单元格可编辑。
Skiplist-CPP:A tiny KV storage based on skiplist written in C++ language| 使用C++开发，基于跳表实现的轻量级键值数据库:fire::fire: :rocket:
08-04
main.cpp 包含skiplist.h使用跳表进行数据操作 skiplist.h 跳表核心实现 README.md 中文介绍 README-en.md 英文介绍 bin 生成可执行文件目录 makefile 编译脚本 store 数据落盘的文件存放在这个文件夹 stress_test_...
container-macros:使用 CPP 实现的 C 容器模板
06-26
容器宏使用 C 预处理器的常见容器类型的通用模板实现列表包括数组列表（向量）和链接列表模板。常用列表方法（NAME 是列表的名称，TYPE 是其元素的类型）： 定义的类型： NAME - 列表，用作指针； 公共领域： NAME_...
cpp学习笔记：STL list容器
ohhjack的博客
11-18 578
cpp
STL容器-list的使用&简单C++实现
Ego_Bai的博客
05-05 939
1.容器是STL的重要组成部分之一,分为关联容器和顺序容器 c++中两种类型的容器：顺序容器和关联容器，　 顺序容器主要有：vector、list、deque等。 　　其中 1.vector表示一段连续的内存地址，基于数组的实现 2.list表示非连续的内存，基于链表实现。 3.deque与vector类似，但是对于首元素提供删除和插入的双向支持。 关...
CPP 容器vector和list的区别
wade1010的专栏
12-03 360
c++
C++ list讲解
qq_54178958的博客
05-17 398
C++STL中list的讲解
C++List详解
m0_53889456的博客
05-11 6592
list容器详解，学我这一篇就够了。你写的C++list到底有什么不一样？都让人写烂的东西了你怎么还写？你比别人强？点进来看看你就知道有什么不一样了。
【Cpp】第七章-STL_listl类
qq_41669298的博客
07-29 274
list类 基础介绍   list类是STL中封装的链表模板类，并且底层实现是以双向链表作为基础进行封装的。在数据结构中，线性存储结构中主要分为顺序表和链表，前者在物理结构上拥有连续的内存空间和地址，在STL中vector和string都是使用了这种结构，其最大的特点就是方便进行随机访问并且尾插和尾删都能达到O1的时间复杂度并且使用方便，而链表作为物理结构上内存空间不连续的数据结构，其最大的特点就...
【CPP】List自我实现
quchen528的博客
04-20 162
#pragma once #include<cassert> template<class T> struct _ListNode { T _data; _ListNode<T>* _prev; _ListNode<T>* _next; _ListNode(const T& x = T()) //T() 带缺省值的T调用它的默认构...
一个简单的cpp list
Jack_Li
01-02 790
list.h #ifndef _list_h_ #define _list_h_ #include #include #include using namespace std; void Exception(int _condition, const char* _error_msg); template class list { public:  
cpp的STL之list
逐梦如风-毕康
10-28 975
cpp的STL之list特点就是个双向链表基本操作// // main.cpp // use_stl_list // // Created by bikang on 16/10/28. // Copyright (c) 2016年 bikang. All rights reserved. //#include <iostream> #include <list> using namespac
顺序表基本操作cpp实现
09-26
在C++中，可以使用数组来实现顺序表。 首先，我们需要定义一个顺序表的结构体，其中包含数组和长度变量。 ```cpp const int MAX_SIZE = 100; // 假设顺序表的最大容量为100 struct ArrayList { int data[MAX_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值