list——C++

已于 2022-10-02 19:58:17 修改
阅读量1k 收藏 20
点赞数 29
分类专栏： C++ 文章标签： c++ 链表 算法
于 2022-10-02 19:54:55 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Ll_R_lL/article/details/127145634
版权

文章目录

模拟实现list

框架大致与源代码保持一致：

namespace haha
{
template<class T>
class list_node
{
T _data;
list_node<T>* _next;
list_node<T>* _prev;
};

template<class T>
class list
{
//需要一个哨兵位的头结点
typedef list_node<T> Node;
public:


private:
Node* _head;

};
}

先搭架子，再修改
 

需要自己写构造函数：

public:
//构造函数
list()
{
//自己指向自己
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}

 

尾插：

不需要去传哨兵位的头结点，因为默认就传了
this可以访问成员

  1. 找到尾结点 tail head 的prev
  2. 创建一个新结点newnode new可以直接调构造函数
template<class T>
class list_node
{
T _data;
list_node<T>* _next;
list_node<T>* _prev;
               
               //构造函数
list_node(const T& x = T())//尽量使用引用& 提供全缺省值
:_data(x)
, _next(nullptr)
, _prev(nullptr)
{}
   
};
  1. 链接4步
    _head tail newnode
void push_back(const T& x)
{
Node* tail = _head->_prev;
Node* newnode = new Node(x);

tail->_next = newnode;
newnode->_prev = tail;
newnode->_neaxt = _head;
_head->_prev = newnode;
}

 

迭代器遍历

注意：不能向之前给一个原生指针去解决

//原生指针
it = lt.begin();
while (it != lt.end())
{
    *it *= 2;
    ++it;
    }
    cout << endl;
}

以上方式需要连续的物理空间
but：
node* 解引用是node 不是数据
我们需要解引用之后是数据

C++的优势：封装+运算符重载（精华设计）
我们用一个类去封装，将node*封装进去
c++不太喜欢用内部类 ，Java比较喜欢
 

源代码分析
链表迭代器的核心：

typedef _list_iterator<T, T&, T*>           iterator;
typedef _list_iterator<T, const T&, const T*>const_iterator;

link_type node; //结点的指针

用一个结点的指针就可以构造一个迭代器
 
 

运算符重载

将it 转换为 operator

reference operator*() const { return (*node).data;}

初步结构

template<class T>
struct __list_iterator
{
typedef list_node<T> Node;
typedef __list_iterator<T> iterator;
Node* _node;

__list_iterator(Node* node)
:_node(node)
{}


//迭代器控制等还是不等  用结点的指针比较
bool operator != (const iterator& it) const
{
return _node != it._node;
}
  //解引用：修改或打印

//*it 被转换为 it.opertor*（）
T& operator*()//加& 可读可写
{
return _node->_data;
}

//++it
//迭代器++返回值就是迭代器
iterator& operator++()
{
_node = _node->_next;
return *this;
}

};
 
 public:
__list_iterator<T> iterator;

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

iterator end()//最后一个结点的下一个位置
{
return  iterator(_head);
}
  
  
  void test_list1()
{
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lt.push_back(5);

//迭代器遍历
list<int>::iterator it = lt.begin();
while (it != lt.end())
{
cout << *it << " ";
++it;
}
cout << endl;


it = lt.begin();
while (it != lt.end())
{
*it *= 2;
++it;
}
cout << endl;

for (auto e : lt)
{
cout << e << " ";
}
cout << endl;

}

指针什么时候会用箭头？
结构体指针，用来访问结构体成员

 T* operator->() 
{
return &(operator*());//&(_node->data);
}
  
   
    
     void test_list2()
{
int x = 10;
int* p1 = &x;

cout << *p1 << endl;

Pos aa;
Pos* p2 = &aa;
p2->_a1;
p2->_a2;

list<Pos> lt;
lt.push_back(Pos(10, 20));
lt.push_back(Pos(10, 21));

//遍历
list<Pos>::iterator it = lt.begin();
while (it != lt.end())
{
//cout << *it << " ";//会报错
//*it 是结点里的数据 pos pos是结构体 可以去写一个重载

//cout << (*it)._a1 << ":" << (*it)._a2 << endl;
cout << it->_a1 << ":" << it->_a2 << endl;//结构可以用箭头访问，重载一个operator->就可以
//隐藏了一个箭头 it->->_a1  编译器为了语法可读性，做了处理省略了一个->


++it;
}
cout << endl;
}

 
 

const迭代器

不能修改，只读不写
const与普通迭代器的区别在于能否修改数据

void Func(const list<int>& l)
{
list<int>::iterator it = l.begin();
while (it != l.end())
{
//*it = 10;

cout << *it << " ";
++it;
}
cout << endl;
}

void test_list3()
{
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lt.push_back(5);

Func(lt);//权限的放大，不能遍历
}

 

通过实例化进行区分
链表迭代器的核心：

typedef _list_iterator<T, T&, T*>           iterator;
typedef _list_iterator<T, const T&, const T*>const_iterator;

后面两个参数是用来控制迭代器的解引用行为
普通迭代器和const迭代器是两个类型

//迭代器
//像指针一样
template<class T, class Ref, class Ptr>
struct __list_iterator
{
typedef list_node<T> Node;
typedef __list_iterator<T, Ref, Ptr> iterator;

typedef bidirectional_iterator_tag iterator_category;
typedef T value_type;
typedef Ptr pointer;
typedef Ref reference;
typedef ptrdiff_t difference_type;

Node* _node;

__list_iterator(Node* node)
:_node(node)
{}


//迭代器控制等还是不等  用结点的指针比较
bool operator != (const iterator& it) const
{
return _node != it._node;
}

//解引用：修改或打印

*it 被转换为 it.opertor*（）
//T& operator*()//加& 可读可写
//{
//return _node->_data;
//}

bool operator==(const iterator& it) const
{
return _node == it._node;
}

// *it  it.operator*()
// const T& operator*()
// T& operator*()
Ref operator*()
{
return _node->_data;
}

//T* operator->() 
Ptr operator->()
{
return &(operator*());//&(_node->data);
}

//++it 前置
//迭代器++返回值就是迭代器
iterator& operator++()
{
_node = _node->_next;
return *this;
}

//it++ 后置
iterator operator++(int)
{
iterator tmp(*this);
_node = _node->_next;
return tmp;
}


//--it 前置
iterator& operator--()
{
_node = _node->_prev;
return *this;
}

//it-- 后置
iterator operator--(int)
{
iterator tmp(*this);
_node = _node->_prev;
return tmp;
}




template<class T>
class list
{
//需要一个哨兵位的头结点
typedef list_node<T> Node;
public:
typedef __list_iterator<T, T&,T*> iterator;
typedef __list_iterator<T,const T&,const T*> const_iterator;

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

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

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

iterator end()//最后一个结点的下一个位置
{
return  iterator(_head);
}






private:
Node* _head;

};

insert erase
void push_back(const T& x)
{
//Node* tail = _head->_prev;
//Node* newnode = new Node(x);

 _head          tail  newnode
//tail->_next = newnode;
//newnode->_prev = tail;
//newnode->_next = _head;
//_head->_prev = newnode;

insert(end(), x);
}

void push_front(const T& x)
{
insert(begin(), x);
}

iterator insert(iterator pos, const T& x)
{
Node* cur = pos._node;
Node* prev = cur->_prev;

Node* newnode = new Node(x);

// prev newnode cur
prev->_next = newnode;
newnode->_prev = prev;
newnode->_next = cur;
cur->_prev = newnode;

return iterator(newnode);
}

void pop_back()
{
erase(--end());
}

void pop_front()
{
erase(begin());
}

iterator erase(iterator pos)
{
assert(pos != end());

Node* cur = pos._node;
Node* prev = cur->_prev;
Node* next = cur->_next;

prev->_next = next;
next->_prev = prev;
delete cur;

return iterator(next);
}


void test_list4()
{
list<int> lt;
lt.push_back(1);
lt.push_back(2);
lt.push_back(3);
lt.push_back(4);
lt.push_back(5);

list<int>::iterator it = lt.begin();
while (it != lt.end())
{
cout << *it << " ";
++it;
}
cout << endl;

it = lt.begin();
while (it != lt.end())
{
*it *= 2;
++it;
}
cout << endl;

for (auto e : lt)
{
cout << e << " ";
}
cout << endl;

lt.push_front(10);
lt.push_front(20);
lt.push_front(30);
lt.push_front(40);

lt.pop_back();
lt.pop_back();

for (auto e : lt)
{
cout << e << " ";
}
cout << endl;

auto pos = find(lt.begin(), lt.end(), 4);
if (pos != lt.end())
{
// pos是否会失效？不会
lt.insert(pos, 40);
//lt.insert(pos, 30);
*pos *= 100;
}

for (auto e : lt)
{
cout << e << " ";
}
cout << endl;
}

 

析构函数与拷贝构造

析构顺序：后定义的先析构

void empty_init()
{
// 创建并初始化哨兵位头结点
_head = new Node;
_head->_next = _head;
_head->_prev = _head;
}

//拷贝构造
list()template <class InputIterator>
list(InputIterator first, InputIterator last)
{
empty_init();

while (first != last)
{
push_back(*first);
++first;
}
}

//构造函数
list()
{
empty_init();
}

void swap(list<T>& x)
//void swap(list& x)
{
std::swap(_head, x._head);
}

// lt2(lt1)
list(const list<T>& lt)
{
empty_init();
list<T> tmp(lt.begin(), lt.end());
swap(tmp);
}

// lt1 = lt3
list<T>& operator=(list<T> lt)
{
swap(lt);
return *this;
}

//析构函数
~list()
{
clear();
delete _head;
_head = nullptr;
}

void clear()
{
iterator it = begin();
while (it != end())
{
//结点所在的迭代器失效（不能++），但是会返回下一个位置的迭代器
erase(it);
}
}

 
 

为什么算法库里已经有sort，list中还有sort？

因为list里的空间不连续
算法库sort 要求物理空间是连续的（快排）
链表sort（归并：不消耗额外空间）

N个数据排序用vector+算法sort更好

Hey pear!
关注
专栏目录
C++——STL之list详解
weixin_59055853的博客
12-22 1475
list是一个序列容器，支持常数时间（也就是O(1)）内进行任意位置的插入删除，还支持双向迭代。list容器作为双向链表实现;双向链表可以将它们包含的每个元素存储在不同且不相关的存储位置。与其他基本标准序列容器（array, vector and deque）相比，list在容器内已经获得迭代器的任何位置插入、提取和移动元素时通常表现更好，因此在大量使用这些元素的算法中也是如此，例如排序算法。与其他序列容器相比，主要缺点是它们无法通过其位置直接访问元素;
植物大战 仿函数——C++
一些七零八碎的知识点
02-21 3万+
stack和queue适配器 ， 仿函数 ，deque，list反向迭代器的适配。
C++——list容器
KevinJune的博客
06-08 3102
功能：将数据进行链式存储链表(list)是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的链表的组成：链表由一系列结点组成结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域STL中的链表是一个双向循环链表由于链表的存储方式并不是连续的内存空间，因此链表中list中的迭代器只支持前移后移，属于双向迭代器list的优点：○采用动态存储分配，不会造成内存浪费和溢出○链表执行插入和删除操作十分方便，修改指针即可，不需要移动大量元素list的缺点：○链表灵活，
C++——List
qwjy的博客
05-08 5395
  文章目录List 的能力List 构造非更易型操作List 赋值操作List 访问迭代器相关操作元素的安插和移入特殊更易型操作实例        list 包含在头文件< list >中： #include <list> 其中的 list 类型系定义于 namespace std 中，是个 class template： namespace std { template <typename T, typename Allocato
C++——list的简介及使用
qq_56663697的博客
11-13 2万+
文章目录list的简介list的使用list 的构造list 插入和删除数据push_front和pop_frontpush_back和pop_backinserteraselist 迭代器的使用list 获取数据list 容量list 相关操作函数swapclearsortresizeremoveuniquereverse list的简介 list文档 list是可以在常数范围内在任意位置进行插入和删除的序列式容器，并且该容器可以前后双向迭代。 list的底层是双向链表结构，双向链表中每个元素存储在互不
C++之STL——list类
qq_41490958的博客
10-10 955
STL——list类list简介list的使用list的构造函数list的迭代器list的capacitylist的元素提取list的插入和删除 list简介 1、list的插入和删除的时间复杂度是在常数范围内的序列式容器，并且由于list的底层是用双链表实现的，该容器支持双向迭代。 2、与其他序列式容器相比(array，vector，deque)，list在任意位置进行插入和删除的效率更高。 3、list最大的缺陷就是不支持任意位置的随机访问。 list的使用 list的构造函数 构造函数 接口
C++初阶 —— list类
NapoleonCoder的博客
11-21 2568
list是可在常数范围内，在任意位置插入和删除的双向迭代序列式容器!
《黑马》——C++提高编程
热门推荐
漏网小鱼的博客
09-05 15万+
前言 ** 配套视频： https://www.bilibili.com/video/BV1et411b73Z?from=search&seid=16795623907667609637 只是为方便学习，不做其他用途，在此发布C++基础入门部分配套讲义，原作者为黑马程序 C++提高编程 本阶段主要针对C++泛型编程和STL技术做详细讲解，探讨C++更深层的使用 1 模板 1.1 模板的概念 模板就是建立通用的模具，大大提高复用性 模板的特点： 模板不可以直接使用，它只是一个框架 模板的通用并不
C++——list和string
mdjsmg的博客
05-08 756
C++容器的学习开始啦！大家先来学习list！紧接着string和vector也会一一呈现！大家继续加油吧！这次的模拟实现就到这里啦这些只是建议的模拟，目的是让大家更充分的了解容器的使用如果对于里面一些知识不了解的话，可以看看前面的博客哟大家继续加油吧！
C++——list容器排序案例
m0_74822436的博客
01-06 926
将Person自定义数据类型进行排序，Person中属性有姓名、年龄、身高排序规则: 按照年龄进行升序，如果年龄相同按照身高进行降序。
数据结构、算法与应用——C++语言描述.rar
07-25
《数据结构、算法与应用——C++语言描述》是一本深入探讨计算机科学核心领域的经典教材。数据结构和算法是编程的基础，它们对于理解和优化程序性能至关重要。本书通过C++语言来阐述这些概念，使得读者能够更好地掌握...
Modern C++ 学习笔记——C++函数式编程
小小笑笑川的博客
07-13 3453
C++函数式编程看这一篇就够了，建议收藏~~~！！！ ModernC++学习笔记是一系列介绍现代C++新特性的文章，结合《effective modern C++》说明了如何更好的使用这些新特性。相互讨论，共同学习，不断成长
【手把手教学】使用cmake构建openvino推理程序——c++
王尼莫的博客
03-28 1196
系统：window11vs版本：visual studio 2022openvino包：2024版下载链接。
C++ 模板专题 - 静态分支(if)
GPU全栈博主-程序哥
10-31 254
模板元编程（Template Metaprogramming，简称 TMP）是一种在 C++ 中使用模板进行编程的技术，它允许在编译时执行计算、生成代码，提供类似脚本语言的功能。TMP 常用于生成高效的代码，避免运行时的计算开销。在高性能编程、类型处理、泛型编程等领域，模板元编程非常有用。模板元编程的一个使用场景就是进行编译器条件分支判断，称为“静态 if”。它允许我们在模板中根据条件编译选择不同的代码分支，而不需要实例化不符合条件的代码，这不仅可以提升编译性能，也可以简化模板代码逻辑。
第八天: C语言深度探索：指针与函数的奥秘
qq_57484399的博客
10-31 596
通过今天的学习，我们了解了字符指针和字符串在C语言中的处理方式。希望大家能够掌握这些基本概念，并在实际编程中灵活运用。好了，今天的课就到这里。希望大家能够掌握指针与函数参数的关系，以及如何通过指针来改变外部变量的值。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。希望大家能够掌握数组名作为函数参数的用法，以及如何通过函数来处理数组。如果有任何问题，或者想要更多的练习题，随时告诉我。下课！好了，今天的课就到这里。
C++之指针和引用
weixin_42300449的博客
11-04 151
在C++中，指针和引用是两种不同的机制，它们都可以用来间接访问变量。
力扣——另一个的子树（C语言）
2401_83456040的博客
10-30 199
原理：这里调用前面比较两颗树是否相同的函数（小编之前文章里面有：相同的树），将节点与subRoot传入函数，向下递归，左右节点，只要找到一个返回true，说明存在子树，即最后返回true。具有相同结构和节点值的子树。的某个节点和这个节点的所有后代节点。也可以看做它自身的一棵子树。
c++之 stack(栈)和queue(队列)
2301_80028974的博客
11-04 629
文档stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行 元素的插入与提取操作。stack是作为容器适配器被实现的，容器适配器即是对特定类封装作为其底层的容器，并提供一组特定 的成员函数来访问其元素，将特定类作为其底层的，元素特定容器的尾部(即栈顶)被压入和弹出。标准容器vector、deque、list均符合这些需求，默认情况下，如果没有为stack指定特定的底层容器， 默认情况下使用deque。
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java
最新发布
参考书籍：《C语言程序设计》《数据结构》《C++ Primer》《Effective C++》《STL源码剖析》《现代操作系统》《UNIX环境高级编程》《图解TCP/IP》《图解HTTP》《Linux高性能服务器编程》《剑指Offer》《算法导论》
11-04 203
每日OJ题_牛客_相差不超过k的最多数_滑动窗口_C++_Java（排序容易想，但是滑动窗口不容易想到，核心思想：使用滑动窗口算法通过动态调整窗口的大小，遍历所有符合条件的连续子序列，求得最大连续子序列的长度。）
数据结构与算法分析——C++版
例如，C++标准库提供了容器类（如std::vector、std::list、std::set等），这些容器实现了各种数据结构，允许程序员高效地管理和操作数据。 在C++中，理解数据结构的重要性在于它直接影响程序的性能和可维护性。例如...
评论 22
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Hey pear!

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值