数据结构与STL：list的实现（双向链表）

已于 2023-02-06 15:46:03 修改
阅读量91 收藏 1
点赞数 1
分类专栏： 类库与数据结构 文章标签： 链表 数据结构 c++
于 2023-02-06 15:33:48 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_60634555/article/details/128902531
版权

声明：
list.h

#pragma once

template<class T>
class list {//list类
	struct node {
		T data;
		node* next;
		node* pre;
	};
	node* head = NULL;
	node* tail = NULL;
	unsigned len;
public:
	class iterator//iterator类
	{
		friend class list<T>;
	private:
		node* nodePtr;
	public:
		iterator() {
			nodePtr = NULL;
		}
		iterator(node* x) {
			nodePtr = x;
		}
		iterator& operator++();
		iterator operator++ (int);
		iterator& operator--();  //pre-decrement
		iterator operator--(int); //post-decrement
		T& operator*();
		bool operator== (const iterator& x);
	};

	list();
	~list();
	list(const list<T>& x);
	void push_front(const T& x);	//头入
	void push_back(const T& x);	//尾入
	iterator insert(iterator position, const T& x);	//按位置插入
	void pop_front();	//头出
	void pop_back();	//尾出
	void erase(iterator position);	//移除某位置
	void erase(iterator first, iterator last);	//移除一段位置
	unsigned size() const;	//返回size
	bool empty() const;	//判断是否为空
	iterator begin();	//指向头部的指针
	iterator end();	//指向结尾的指针
	void splice(iterator position, list<T>& x);	//在position前，插入一段元素
	list<T>& operator=(const list<T>& x);
};

定义
list.cpp

#include<iostream>
#include"list.h"
using namespace std;


template<class T>
typename list<T>::
iterator& list<T>::iterator:: operator++()
{
	nodePtr = nodePtr->next;
	return *this;
}

template<class T>
typename list<T>::
iterator list<T>::iterator::operator++(int)
{
	iterator p = *this;
	nodePtr = nodePtr->next;
	return p;
}

template<class T>
typename list<T>::
iterator& list<T>::iterator::operator--()
{
	nodePtr = nodePtr->pre;
	return *this;
}

template<class T>
typename list<T>::
iterator list<T>::iterator::operator--(int)
{
	iterator temp = *this;
	nodePtr = nodePtr->pre;
	return temp;
}

template<class T>
T& list<T>::iterator::operator*()
{
	return nodePtr->data;
}

template<class T>
bool list<T>::iterator::operator==(const iterator& x)
{
	return nodePtr == x.nodePtr;
}

template<class T>
list<T>::list()
{
	len = 0;
}

template<class T>
list<T>::~list()
{
	node* temp = head;
	while (temp != tail)
	{
		head = head->next;
		delete temp;
		temp = head;
	}
	len = 0;
}

template<class T>
list<T>::list(const list<T>& x)
{
	if (x.head == NULL)
		head = tail = NULL;
	else
	{
		node* p = x.head;
		head = new node();
		head->data = p->data;
		node* s = head;
		while (p != x.tail)
		{
			p = p->next;
			s->next = new node();
			s->next->pre = s;
			s = s->next;
			s->data = p->data;
			len++;
		}
	}
}

template<class T>
void list<T>::push_front(const T& x)
{
	node* newhead = new node();
	newhead->data = x;
	newhead->next = head;
	newhead->next->pre = head;
	newhead->pre = NULL;
	len++;
	if (head == NULL)
	{
		head = newhead;
		tail = head;
	}
	else
	{
		head->pre = newhead;
		head = newhead;

	}
}

template<class T>
void list<T>::push_back(const T& x)
{
	node* newtail = new node();
	newtail->data = x;
	newtail->next = NULL;
	newtail->pre = tail;
	len++;
	if (tail == NULL)
	{
		tail = newtail;
		head = tail;
	}
	else
	{
		tail->next = newtail;
		tail = newtail;
	}
}

template<class T>
typename list<T>::
iterator list<T>::insert(iterator position, const T& x)//从后insert
{
	node* s = new node();
	s->data = x;
	s->pre = position.nodePtr;
	s->next = position.nodePtr->next;
	position.nodePtr->next->pre = s;
	position.nodePtr->next = s;
	if (position.nodePtr == tail)
	{
		tail = s;
	}
	len++;
	return position;
}

template<class T>
void list<T>::pop_front()
{
	len--;
	node* temp = head->next;
	delete head;
	head = NULL;
	if(temp == NULL) 
	{
		tail = NULL;
		return;
	}
	head = temp;
	head->pre = NULL;
}

template<class T>
void list<T>::pop_back()
{
	if (!empty())
	{
		len--;
		node* temp = tail;
		tail->pre->next = NULL;
		tail = tail->pre;
		delete temp;
	}
}

template<class T>
void list<T>::erase(iterator position)
{
	node* p = position.nodePtr;
	if (p != NULL)
	{
		if (p->next != NULL)
		{
			p->pre->next = p->next;
			p->next->pre = p->pre;
		}
		else
		{
			p->pre->next = NULL;
			p = p->pre;
			tail = p;
		}
		len--;
	}

}

template<class T>
void list<T>::erase(iterator first, iterator last)
{
	node* p = first.nodePtr;
	if (first == head)
	{
		head = last.nodePtr->next;
	}
	if (last == tail)
	{
		tail = tail->pre;
	}
	if(!(first == last))
	{
		first++;
		delete p;
		p = first.nodePtr;
	}

}

template<class T>
unsigned list<T>::size() const
{
	return len;
}

template<class T>
bool list<T>::empty() const
{
	return len == 0;
}

template<class T>
typename list<T>::
iterator list<T>::begin()
{
	return iterator(head);
}

template<class T>
typename list<T>::
iterator list<T>::end()
{
	return iterator(tail);
}

template<class T>
void list<T>::splice(iterator position, list<T>& x)
{
	node* p = position.nodePtr;
	len = len + x.len;
	if (head == NULL && tail == NULL)
	{
		head = x.head;
		tail = x.tail;
	}
	else if (p->pre == NULL && p != NULL)
	{
		x.tail->next = p;
		p->pre = x.tail;
		head = x.head;
	}
	else if (p == NULL && p->pre != NULL)
	{
		x.head->pre = p->pre;
		p->pre->next = x.head;
		x.tail->next = p;
		p->pre = x.tail;
		tail = x.tail;
	}
	else
	{
		x.head->pre = p->pre;
		x.tail->next = p;
		p->pre->next = x.head;
		p->pre = x.tail;
	}
	
}

template<class T>
list<T>& list<T>::operator=(const list<T>& x)
{
	node* s = head;
	head->data = x.head->data;
	iterator first = x.begin();
	iterator last = x.last();
	while (!(first->next == last))
	{
		first++;
		s->next->data = first->data;
		s = s->next;
	}
	/*
	node* p = x.head;
	node* s = head;
	while (p != x.tail)
	{
		s->data = p->data;
		s->next = new node();
		s->next = p->next;
		s->pre = p->pre;
		s = s->next;
		p = p->next;
	}
	head = x.head;
	tail = x.tail;
	len = x.len;
	*/
	tail = x.tail;
	len = x.len;
	return *this;
}

测试类
main.cpp

#include<iostream>
#include"list.cpp"
using namespace std;

int main()
{
	list<int>* l = new list<int>;
	for (int i = 0; i <= 5; ++i)
	{
		l->push_back(i);
	}
	list<int>::iterator first = l->begin();
	list<int>::iterator last = l->end();
	cout << *first << " ";
	while (!(first == last))
	{
		first++;
		cout << *first << " ";
	}
	cout << endl;

	for (int i = 0; i <= 5; i++)
	{
		l->push_front(i*3);
	}
	first = l->begin();
	last = l->end();
	cout << *first << " ";
	while (!(first == last))
	{
		first++;
		cout << *first << " ";
	}
	cout << endl;

	for (int i = 0; i <= 5; i++)
	{
		l->pop_front();
	}

	first = l->begin();
	last = l->end();
	cout << *first << " ";
	while (!(first == last))
	{
		first++;
		cout << *first << " ";
	}
	cout << endl;

	/*
	for (int i = 0; i < 4; i++)
	{
		l->pop_back();
	}
	first = l->begin();
	last = l->end();
	while (!(first == last))
	{
		cout << *first << endl;
		first++;
	}
	cout << endl;
	*/

	list<int>* m = new list<int>;
	for (int i = 0; i < 5; ++i)
	{
		m->push_back(i*2);
	}
	first = m->begin();
	last = m->end();
	cout << *first << " ";
	while (!(first == last))
	{
		first++;
		cout << *first << " ";
	}
	cout << endl;

	first = l->begin();

	l->splice(first, *m);
	first = l->begin();
	last = l->end();
	cout << *first << " ";
	while (!(first == last))
	{
		first++;
		cout << *first << " ";
	}
	cout << endl;

	cout << l->empty() << endl;
	cout << l->size() << endl;
	cout << endl;

	first = l->begin();
	last = l->end();


	int x;
	cin >> x;
	l->insert(first,x);
	cout << *first << " ";
	while (!(first == last))
	{
		first++;
		cout << *first << " ";
	}
	cout << endl;

	list<int>*y = new list<int>;
	y = l;
	first = y->begin();
	last = y->end();
	cout << *first << " ";
	while (!(first == last))
	{
		first++;
		cout << *first << " ";
	}
	cout << endl;

	first = l->begin();
	last = l->end();
	last--;
	last--;
	l->erase(first, last);
	first = l->begin();
	last = l->end();
	cout << *first << " ";
	while (!(first == last))
	{
		first++;
		cout << *first << " ";
	}
	cout << endl;
}
_企鹅_
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++ STL入门教程(2) list双向链表使用方法（附程序代码）
08-29
主要为大家详细介绍了C++ STL入门教程第二篇，list双向链表使用方法，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
使用C++实现双向链表List
FS's Home
11-29 1299
参考教程《数据结构与算法分析 C++描述 》第三版和第四版 这次写的过程中，发现的两个新的 问题： 第一：自己定义的数据结构UDT如果需要使用C++11中的范围for语句，需要定义begin和end函数。如果遍历的是常量对象，则要有相应的常量对象可用的begin和end函数。 声明形式如下： iterator begin(); const_iterator begin() const；
STL双向链表（list）的常用方法
Liuchenhao0620的博客
05-20 509
双向链表基本的方法讲解
c++ STL容器 --- 双向链表list
weixin_60569662的博客
12-29 1717
包含头文件<list> list<int> iNum; //创建一个list对象,存放整型数据 模板类型:存储数据类型:int 自己写链表需要写释放内存，对于标准库的list内存不需要你去处理，最后会自动释放(便捷) 用到链表的地方，都可以使用list去替换 处理基本数据类型 插入 void testList() { list<string> strNum; strNum.push_back("string1")..
STL泛型编程-list双向链表容器
zuolj的专栏
12-16 863
list双向链表容器     list容器实现了双向链表的数据结构，数据元素时通过链表指针串连成逻辑意义上的的线性表，这样，对链表的任一位置的元素进行插入，删除和查找都是极快速的。 双向链表示例 (a)结点结构；(b)空的双向循环链表；(c)非空的双向循环链表     list的每个节点都有三个域：前驱元素指针域、数据域和后继元素指针域。前驱元素指针域保存了前驱元素的首地址，数据域则是本
【C++数据结构】双向链表list实现
我的博客
01-13 268
本次实现也是练习而已，如有问题，欢迎指出！ 编译环境：GCC 7.3、vs 2005 与标准库list的差异： 1. 没有splice 2. 没有uniqe 3. 没有merge 4. 没有sort 好了，直接上代码： #ifndef __LIST_H__ #define __LIST_H__ #if __cplusplus >= 201103L #include &lt...
C++数据结构：Python风格双向链表Pylist的实现
攻城狮的博客
05-27 1260
线性顺序表（链表）已经完成了单向链表基本的插入、取值、删除等操作，本文将在前文的基础上更进一步完善其功能。参照Python的 List 列表的函数常用功能来实现。如+运算直接将两个列表合并，[] 运算赋值、取值。笔者是很喜欢python中列表这种骚操作的，本文就在C++中实现它。当然基本的C++语法规则笔者是没法改变的。赋值得用{}，类型还是要声明的，泛型自然是可以的，但你也别想着在一个列表中同时塞入 string 和 int。
C++-STL-组件(一)-容器03：list（双向链表）
u013250861的博客
06-17 1071
链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。相较于vector的连续线性空间，list就显得负责许多，它的好处是每次插入或者删除一个元素，就是配置或者释放一个元素的空间。因此，list对于空间的运用有绝对的精准，一点也不浪费。而且，对于任何位置的元素插入或元素的移除，list永远是常数时间。
STL--list容器(链表)
hjl011006的博客
07-13 1351
C++STL中list容器的介绍和使用说明，list相当于数据结构中的链表。
【数据结构(C++实现)】：单链表、双向链表、STL中的list容器
bqw的博客
08-15 2953
目录 单链表 双向链表 STL中的list 单链表 单链表的结构 头文件(List.h) /*数据结构：单链表*/ #ifndef LIST_H #define LIST_H #include &lt;iostream&gt; using namespace std; typedef int ElementType;//定义数据类型 class Node{//定义链表...
C++基础：STL之双向链表list
知行合一 止于至善
10-25 534
这篇文章介绍一下STL中list的基本使用方法。
数据结构与(STL)(collins)
01-12
数据结构与STL
数据结构与STL
07-23
资源名称：数据结构与STL资源截图： 资源太大，传百度网盘了，链接在附件中，有需要的同学自取。
STL的List链表自行实现
11-04
C++中STL的List链表容器的自行实现，自行实现迭代器、类、封装函数等
二叉树专题（有关二叉树的相关学习）
aaa114514aaaa的博客
05-14 1591
有关二叉树的学习，目前已经学习了大概2/5的样子，后面更加有难度的，比如搜索平衡二叉树，红黑树等知识，将在C++学习。
数据结构之树与二叉树
最新发布
paradiso989的博客
05-20 744
本文介绍了数据结构中树与二叉树的基础概念以及实现方式
【数据结构/C语言】深入理解 双向链表
2302_78391795的博客
05-20 735
双向链表是一种常见的数据结构，与单向链表类似，但它允许我们从两个方向遍历链表：向前和向后。每个节点包含三个部分：一个数据元素和两个指针，一个指向链表中的前一个节点，另一个指向链表中的下一个节点。 一般情况下，我们所说的双向链表指的是带头节点，双向，循环链表，以下若无特殊说明，均代表此含义。
【数据结构】单链表逆置（详解）————四种方法
lzh20040919的博客
05-17 407
逆置就是把最后一个数据提到最前面，倒数第二个放到第二个……依次类推，直到第一个到最后一个。由于链表没有下标，所以不能借助下标来实行数据的逆置，要靠空间的转移来完成链表的逆置，这里采用没有头节点的链表来实现逆置。
数据结构之链表
qq_63448996的博客
05-19 459
2.然后，从第二个节点开始，依次将每个节点插入到头节点之后。这样，原来的第二个节点就变成了新的头节点，原来的第三个节点就变成了新的第二个节点，
stl容器的底层实现的数据结构
10-11
2. list：底层使用双向链表实现，每个节点包含元素值以及指向前一个和后一个节点的指针。 3. deque：底层使用分段连续的动态数组实现，通过多个连续的内存块存储元素。 4. map/set：底层使用红黑树（一种自平衡...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值