链表List

最新推荐文章于 2024-09-10 21:54:53 发布
最新推荐文章于 2024-09-10 21:54:53 发布
阅读量1.9k 收藏 30
点赞数 42
文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Frenemy__/article/details/140938313
版权

简介 

STL中的List与顺序表vector类似，同样是一种序列式容器，其原型是带头节点的双向循环链表。

List的使用

        list中的接口比较多，此处类似，只需要掌握如何正确的使用，然后再去深入研究背后的原理，已达到可扩展的能力。以下为list中一些常见的重要接口。

List的构造

构造的使用 

list<int> l1;  无参构造
list<int> l2(5, 10);//放5个值为10的数据
list<int> l3(l2.begin(), l2.end());   迭代器构造
list<int> l4(l3);  拷贝构造

构造的实现 

无参构造
template<class T>
struct list_node
{
	T _data;
	list_node<T>* _next;
	list_node<T>* _prev;

	list_node(const T& data = T())
		:_data(data)
		, _next(nullptr)
		, _prev(nullptr)
	{}
};

template<class T>
typedef list_node<T> Node;
typedef list_iterator<T> Self;
Node* _node;

list()
{
	_head = new Node;
	_head->_next = _head;
	_head->_prev = _head;
	_size = 0;
}


private:
	Node* _head;
	size_t _size;

迭代器iterator

概念

此处我们可以将iterator理解为指针，指向list中的某一个节点。

 

以图示为例，list头节点的begin()迭代器扮演了指针的角色指向了下一个节点，依次往后。

注意
1. begin与end为正向迭代器，对迭代器执行++操作，迭代器向后移动
2. rbegin(end)与rend(begin)为反向迭代器，对迭代器执行++操作，迭代器向前移动 

iterator的使用

由于链表节点之间不连续的性质，我们对其进行遍历时也必须使用迭代器或范围for.

我们以链表的遍历打印（顺序和倒序）为例，代码如下：

正序
int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
list<int> l(array, array + sizeof(array) / sizeof(array[0]));
// 使用正向迭代器正向list中的元素
// list<int>::iterator it = l.begin();   // C++98中语法
auto it = l.begin();                     // C++11之后推荐写法
while (it != l.end())
{
    cout << *it << " ";
    ++it;
}
cout << endl;

倒序
// 使用反向迭代器逆向打印list中的元素

// list<int>::reverse_iterator rit = l.rbegin();
auto rit = l.rbegin();//此句是现代写法，C++11后才支持

while (rit != l.rend())
{
    cout << *rit << " ";
    ++rit;
}
cout << endl;

 iterator的实现

begin() 与 end()
iterator begin()
{
	/*	iterator it(_head->_next);
		return it;*/
		//return iterator(_head->_next);
	return _head->_next; 最直接的写法
}

iterator end()
{
	return _head;
}

list接口

list capacity（容量）

目录

empty判空
bool empty() const
{
	return _size == 0;
}
size
size_t size() const
{
	return _size;
}

 list element access（成员访问）

目录

front 
void pop_front()
{
	erase(begin());
}
back
void pop_back()
{
	erase(--end());
}

list modifiers（链表调整）

目录

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

	Node* newnode = new Node(x);

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

	++_size;
}

接下来的插入复用insert代码即可。

push_front
void push_front(const T& x)
{
	insert(begin(), x);
}
push_back
void push_back(const T& x)
{
	insert(end(), x);
}
erase
void erase(iterator pos)
{
	assert(pos != end());

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

	prev->_next = next;
	next->_prev = prev;
	delete pos._node;

	--_size;
}

同理，头删尾删代码复用删除代码即可。

pop_front
void pop_front()
{
	erase(begin());
}
pop_back
void pop_back()
{
	erase(--end());
}
clear
void clear()
{
	auto it = begin();
	while (it != end())
	{
		it = erase(it);
	}
}
swap
void swap(list<T>& lt)
{
	std::swap(_head, lt._head);
	std::swap(_size, lt._size);
}
使用
插入和删除
void TestList3()
{
    int array[] = { 1, 2, 3 };
    list<int> L(array, array + sizeof(array) / sizeof(array[0]));

    // 在list的尾部插入4，头部插入0
    L.push_back(4);
    L.push_front(0);
    PrintList(L);

    // 删除list尾部节点和头部节点
    L.pop_back();
    L.pop_front();
    PrintList(L);
}
clear
~list()
{
	clear();
	delete _head;
	_head = nullptr;
}
swap 
list<T>& operator=(list<T> lt)
{
	swap(lt);
	return *this;
}

list迭代器失效

        与顺序表类似，list的迭代器失效也是由于iterator指向的节点发生了变化，可能不是我们想要的节点。迭代器失效即迭代器所指向的节点的无效，即该节点被删除了。因为list的底层结构为带头结点的双向循环链表，因此在list中进行插入时是不会导致list的迭代器失效的，只有在删除时才会失效，并且失效的只是指向被删除节点的迭代器，其他迭代器不会受到影响。

        在这里，我们仍然举个例子：

void TestListIterator1()
{
    int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    list<int> l(array, array + sizeof(array) / sizeof(array[0]));
    auto it = l.begin();
    while (it != l.end())
    {
        // erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给
        //其赋值
        l.erase(it);
        ++it;
    }
}

同样地，我们只要将l.erase(it)前加上“it = ”即可：

void TestListIterator1()
{
    int array[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
    list<int> l(array, array + sizeof(array) / sizeof(array[0]));
    auto it = l.begin();
    while (it != l.end())
    {
        // erase()函数执行后，it所指向的节点已被删除，因此it无效，在下一次使用it时，必须先给
        //其赋值
        it = l.erase(it);
        ++it;
    }
}

list与vector的对比 

        vector与list都是STL中非常重要的序列式容器，由于两个容器的底层结构不同，导致其特性以及应用场景不同，其主要不同如下：

List实现总代码 

#pragma once
#include <iostream>
#include <list>
#include <assert.h>
using namespace std;

namespace Frenemy
{
	template<class T>
	struct list_node
	{
		T _data;
		list_node<T>* _next;
		list_node<T>* _prev;

		list_node(const T& data = T())
			:_data(data)
			, _next(nullptr)
			, _prev(nullptr)
		{}
	};

	template<class T, class Ref, class Ptr>
	struct list_iterator
	{
		typedef list_node<T> Node;
		typedef list_iterator<T, Ref, Ptr> Self;
		Node* _node;

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

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

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

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

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

		Self operator++(int)
		{
			Self tmp(*this);
			_node = _node->_next;

			return tmp;
		}

		Self& operator--(int)
		{
			Self tmp(*this);
			_node = _node->_prev;

			return tmp;
		}

		bool operator!=(const Self& s) const
		{
			return _node != s._node;
		}

		bool operator==(const Self& s) const
		{
			return _node == s._node;
		}
	};


	template<class T>
	class list
	{
		typedef list_node<T> Node;
	public:
		/*typedef list_iterator<T> iterator;
		typedef list_const_iterator<T> const_iterator;*/

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

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

		iterator end()
		{
			return _head;
		}

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

		const_iterator end() const
		{
			return _head;
		}

		void empty_init()
		{
			_head = new Node;
			_head->_next = _head;
			_head->_prev = _head;
			_size = 0;
		}

		list()
		{
			empty_init();
		}

		list(initializer_list<T> il)
		{
			empty_init();
			for (auto& e : il)
			{
				push_back(e);
			}
		}

		// lt2(lt1)
		list(const list<T>& lt)
		{
			empty_init();

			for (auto& e : lt)
			{
				push_back(e);
			}
		}

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

		~list()
		{
			clear();
			delete _head;
			_head = nullptr;
		}

		void clear()
		{
			auto it = begin();
			while (it != end())
			{
				it = erase(it);
			}
		}

		// 16:18继续
		void swap(list<T>& lt)
		{
			std::swap(_head, lt._head);
			std::swap(_size, lt._size);
		}

		void push_back(const T& x)
		{

			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
			newnode->_next = cur;
			cur->_prev = newnode;
			newnode->_prev = prev;
			prev->_next = newnode;

			++_size;

			return newnode;
		}

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

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

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

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

			prev->_next = next;
			next->_prev = prev;
			delete pos._node;

			--_size;

			return next;
		}

		size_t size() const
		{
			return _size;
		}

		bool empty() const
		{
			return _size == 0;
		}
	private:
		Node* _head;
		size_t _size;
	};

	struct AA
	{
		int _a1 = 1;
		int _a2 = 1;
	};

	// 按需实例化
	// T* const ptr1
	// const T* ptr2
	template<class Container>
	void print_container(const Container& con)
	{
		// const iterator -> 迭代器本身不能修改
		// const_iterator -> 指向内容不能修改,不能进行权限放大，只能进行权限缩小
		typename Container::const_iterator it = con.begin();
		//auto it = con.begin();
		while (it != con.end())
		{
			//*it += 10;

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

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

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

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

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

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

		list<AA> lta;
		lta.push_back(AA());
		lta.push_back(AA());
		lta.push_back(AA());
		lta.push_back(AA());
		list<AA>::iterator ita = lta.begin();
		while (ita != lta.end())
		{
			//cout << (*ita)._a1 << ":" << (*ita)._a2 << endl;
			// 特殊处理，本来应该是两个->才合理，为了可读性，省略了一个->
			cout << ita->_a1 << ":" << ita->_a2 << endl;
			cout << ita.operator->()->_a1 << ":" << ita.operator->()->_a2 << endl;

			++ita;
		}
		cout << endl;
	}

	void test_list2()
	{
		list<int> lt1;
		lt1.push_back(1);
		lt1.push_back(2);
		lt1.push_back(3);
		lt1.push_back(4);

		list<int> lt2(lt1);

		print_container(lt1);
		print_container(lt2);

		list<int> lt3;
		lt3.push_back(10);
		lt3.push_back(20);
		lt3.push_back(30);
		lt3.push_back(40);

		lt1 = lt3;
		print_container(lt1);
		print_container(lt3);
	}

	void func(const list<int>& lt)
	{
		print_container(lt);
	}

	void test_list3()
	{
		// 直接构造
		list<int> lt0({ 1,2,3,4,5,6 });
		// 隐式类型转换
		list<int> lt1 = { 1,2,3,4,5,6,7,8 };
		const list<int>& lt3 = { 1,2,3,4,5,6,7,8 };

		func(lt0);
		func({ 1,2,3,4,5,6 });

		print_container(lt1);		
	}
}

Frenemy__
关注
  • 42
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
双向链表List模板类（模拟STL容器中的list）
02-07
双向链表List模板类（模拟STL容器中的list），提供插入删除，清空，获取链表长度，判断链表是否为空等操作，内置了迭代器类型
把Linux下的链表List移植到Win32上
12-16
### 把Linux下的链表List移植到Win32上的详细说明 #### 一、引言 链表是一种常见的数据结构，被广泛应用于操作系统内核、应用程序等场景中。在Linux系统中，链表操作十分常见且高效。然而，将这些链表操作从Linux...
Linux内核中的双向链表list_head
04-09 1626
双向链表结构体很简单，有prev和next两个指针，分别指向链表的前一节点和后一节点。这里专门讲下空链表，空链表指链表的的 prev 和 next 均指向自身，非空链表指除表头外，至少还有一个节点。可用用函数 list_empty 判断是否为空链表，用 list_is_singular 判断是否只有一个 entry 节点（除表头外）。return!如：LIST_HEAD(mylist);
C语言 list 链表
SauryN的博客
04-25 8516
目录一、list简介二、list 包含方法2.1. push_front2.2. push_back2.3. begin2.3. end2.2. pop_front2.2. pop_back2.2. size2.2. empty2.2. clear三、源码list.clist.h 一、list简介 这里用双向链表实现，包含插入头、插入尾、删除头、删除尾等操作。 二、list 包含方法 2.1. push_front 功能 插入数据到 list 头部 参数 list：list指针，data：插入数据指
C++ STL 如何快速合并两个链表list——splice方法
benobug的博客
04-20 5140
众所周知，在链表上进行插入操作所需要的时间为固定时间，只需要修改几个指针便可以完成插入操作，C++ 的STL为我们提供了list容器，当然也少不了合并两个list的方法，不是使用merge，而是使用list的方法splice，函数原型为 void splice ( iterator position, list<T,Allocator>& x ); void splice ( ...
list（链表）——STL
mankeywang的博客
08-02 1820
List有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。结点的组成一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。由于链表的存储方式并不是连续的内存空间，因此链表。将容器中的元素反转，以及将容器中的数据进行排序。//返回最后一个元素。对list容器进行数据的插入和删除。返回第一个元素—front。返回最后一个元素—back。...
list链表的使用
卑鄙的我
04-13 2859
一、简介 STL中封装了链表的容器list，内部实现是一个双向链表 不同于vector，list中每个元素在内存中的地址是不连续且没有规律的，所以用list进行插入和删除时间复杂度比vector低很多， 例如在vector插入一个元素之后，这个元素后面的地址全部会改变，而list不会，地址不会连续 由于地址不是连续的，所以当用迭代器访问元素时，不能使用迭代器++、+1之类的操作 二...
linux 应用层编程之内核链表list的使用
fuyuande的博客
06-11 5689
linux内核提供了一个经典通用的双向循环链表list的实现，任何模块都可以借助该接口实现自己的内部循环链表。因为是通用的，可以直接移植到用户态中使用，下面介绍相关的接口与一个简单操作例子，包括链表的插入、查询、修改和删除操作。想深入了解的话直接阅读内核list源代码，代码不是很多，只有list.h 和 types.h。内核源码可以直接下载也可以使用下文给出的链接。内核定义了链表的结构体，任何链表...
双向循环链表list（C++）
那年聪聪
05-20 1963
双向循环链表list（C++）
深入理解Linux内核之链表 list.h 功能实现原理、接口说明及示例代码
猪哥的专栏
08-11 6054
目录 一、双向链表接口函数及相关宏定义分析 0、list_head 结构体 1、offsetof(TYPE, MEMBER) 宏 2、ontainer_of(ptr, type, member) 宏 3、LIST_HEAD_INIT 宏 4、LIST_HEAD 宏 5、INIT_LIST_HEAD 函数 6、LIST_HEAD 和INIT_LIST_HEAD 的区别 7、lis...
c++容器链表list的使用
qq_43514659的博客
12-18 2082
链表和list 咳咳，不是每一朵鲜花都能代表爱情，但是玫瑰做到了；不是每一颗树都能耐的住干渴，但是白杨做到了；也不是每一个人都会追求上进，挑战自我，但是我相信我们也能做到。今天给大家带来的是c++容器，list链表。 list作为c++里面的容器哈，它是一个双向链表，空间可以不连续，通过指针进行数据的访问哈，他可以高效率的完成在任意地方的删插改。 但是list链表不支持随机访问哦！ 然后我们来看看他的用法： 写法 说明 list < int > mlist; 定义一个链表
C语言演示链表操作.rar_C语言_双向循环链表_数据结构_链表 list_链表操作
09-19
双向循环链表是一种特殊类型的链表，它允许在链表的前后两个方向上进行遍历，与传统的单链表相比，具有更大的灵活性。 首先，我们要理解链表的基本概念。链表不同于数组，它不是在内存中连续存储元素，而是通过节点...
双向链表list.c
01-23
为《仿照linux内核的链表构造并遍历》一文写的测试源文件，文章链接https://blog.csdn.net/eidolon_foot/article/details/112998927。 文件里面有链表声明和初始化、判断...在linux下用gcc list.c编译，./a.out运行。
深入浅出linux内核源代码之双向链表list_head pdf codes
04-07
3. **链表操作函数**：Linux内核提供了一系列的宏和函数来操作`list_head`，如`INIT_LIST_HEAD`用于初始化一个空链表，`list_entry`用于从链表节点获取实际数据结构的指针，`list_for_each`和`list_for_each_entry`...
【数据结构】——1.1树
qq_43507078的博客
09-07 962
树，二叉树
CSP-J 算法基础 排序算法的基本概念
m0_62599305的博客
09-10 765
排序算法是计算机科学中最基础的算法之一，广泛应用于数据处理、搜索、优化等各种场景。排序的目的是将一组数据按一定的顺序（通常是升序或降序）排列，以便后续的高效处理。常见的排序算法有很多种，每种算法都有其特点和适用场景。本文将介绍排序算法的基本概念，并总结这些算法的优缺点和应用场景。排序算法的稳定性就是看相同值的元素在排序后是否保持原来的顺序。稳定排序算法确保了相同值元素的相对位置不会改变，而不稳定排序算法则可能会改变它们的相对顺序。理解这一点可以帮助你选择合适的排序算法来满足特定的需求。有序度。
数据结构10
最新发布
m0_52024881的博客
09-10 176
假设该链表只给出了头指针list。在不改变链表的前提下，请设计一个尽可能高效的算法，查找链表中倒数第k个位置上的结点(k为正整数)。若查找成功，算法输出该结点的data域的值，并返回1;（3）根据设计思想和实现步骤，采用程序设计语言描述算法(使用C、C++或Java语言实现)，关键之处请给出简要注释。这里需要注意一下递归出现的位置。（1）描述算法的基本设计思想。（2）描述算法的详细实现步骤。
栈—数据结构
weixin_63722559的博客
09-06 1022
6、获取栈顶元素（获取栈顶元素，在外面开一个空间，将该空间的地址传过去，进行获取元素，以便于区分元素还是返回值）入栈的方向是是增栈的方式，放入数据的是满栈的方式。入栈的方向是是减栈的方式，放入数据的是满栈的方式。入栈的方向是是增栈的方式，放入数据的是空栈的方式。入栈的方向是是减栈的方式，放入数据的是空栈的方式。3、出栈（看一下，出去的元素，所以和6一样）1、入栈：先放入输入，再移动栈顶指针。2、出栈：先移动栈顶指针，再数据弹出。1、入栈：先挪栈顶指针，再放入数据。2、出栈：先移出数据，再移动指针。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值