【C++篇】list模拟实现

实现接口:

  1. list的无参构造、n个val构造、拷贝构造

  2. operator=重载

  3. 实现迭代器

  4. push_back()

  5. push_front()

  6. erase()

  7. insert()

  8. 头尾删

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

    namespace liu
    {
    //定义list节点
    template<class T>
    struct list_node
    {
    T _data;
    list_node<T>* _prev;
    list_node<T>* _next;

    复制代码
     	list_node(const T& x=T())
     		:_data(x)
     		,_prev(nullptr)
     		,_next(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;
     	}
    
     	bool operator!=(const Self& s)
     	{
     		return _node != s._node;
     	}
    
     	bool operator==(const Self& s)
     	{
     		return _node == s._node;
     	}
     };
    
    
    
     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;
     	void empty_init()
     	{
     		_head = new Node();
     		_head->_prev = _head;
     		_head->_next = _head;
     	}
    
     	list()//无参构造
     	{
     		empty_init();
     	}
    
     	list(size_t n,const T& val=T())//n个val
     	{
     		empty_init();
     		for (int i=0;i<n;i++)
     		{
     			push_back(val);
     		}
     	}
    
     	list(const list<T>& i1)
     	{
     		empty_init();
     		for(auto& x:i1)
     		{
     			push_back(x);
     		}
     	}
    
     	~list()
     	{
     		clear();
    
     		delete _head;
     		_head = nullptr;
     	}
    
     	void clear()
     	{
     		auto it = begin();
     		while (it!=end())
     		{
     			it=erase(it);
     		}
     	}
    
     	iterator begin()
     	{
     		return iterator(_head->_next);
     	}
    
     	const_iterator begin()const
     	{
     		return const_iterator(_head->_next);
     	}
    
     	iterator end()
     	{
     		return iterator(_head);
     	}
    
     	const_iterator end()const
     	{
     		return const_iterator(_head);
     	}
    
    
     	iterator insert(iterator pos,const T&val)
     	{
     		
    
     		Node* new_node = new Node(val);
     		Node* cur = pos._node;
     		Node* prev = cur->_prev;
    
     		prev->_next = new_node;
     		new_node->_prev = prev;
    
     		cur->_prev = new_node;
     		new_node->_next = cur;
    
     		return iterator(new_node);
     	}
    
     	iterator erase(iterator pos)
     	{
     		assert(pos!=end());
    
     		Node* del = pos._node;
     		Node* prev = del->_prev;
     		Node* next = del->_next;
    
     		prev->_next = next;
     		next->_prev = prev;
     		delete del;
    
     		return iterator(next);
    
     	}
    
     	void pop_front()
     	{
     		erase(begin());
     	}
    
    
     	void pop_back()
     	{
     		erase(--end());
     	}
    
     	void swap(list<T>& i1)
     	{
     		std::swap(_head,i1._head);
     	}
    
     	
    
     	list<T>& operator=(list<T> il)
     	{
     		swap(il);
     		return *this;
     	}
    
     	void push_back(const T& x)
     	{
     		/*Node* new_node = new Node(x);
     		Node* tail = _head->_prev;
    
     		tail->_next = new_node;
     		new_node->_prev = tail;
    
     		new_node->_next = _head;
     		_head->_prev = new_node;*/
     		insert(end(),x);
     	}
    
     	void push_front(const T& x)
     	{
     		/*Node* new_node = new Node(x);
     		Node* prev = _head->_next;
    
     		_head->_next = new_node;
     		new_node->_prev = _head;
    
     		prev->_prev = new_node;
     		new_node->_next = prev;*/
     		insert(begin(), x);
     	}
     private:
     	Node* _head;//双端链表,哨兵位
     };
    
     template<class T>
     void swap(T&a,T& b)
     {
     	T c(a);
     	a = b;
     	b = c;
     }
     template<class T>
     void swap(list<T>& a, list<T>& b)
     {
     	a.swap(b);
     }
     
    
     void test1()
     {
     	/*liu::list<int>i1;
     	i1.push_back(1);
     	i1.push_back(2);
     	i1.push_back(3);
     	i1.push_back(4);
    
     	i1.push_front(5);
     	i1.push_front(6);
     	i1.push_front(7);
    
     	liu::list<int>::iterator it1 = i1.begin();
     	while (it1!=i1.end())
     	{
     		cout << *it1 << " ";
     		++it1;
     	}
     	cout << endl;
     	liu::list<int>::iterator it2 = i1.begin();
     	it2=i1.erase(it2);
     	while (it2 != i1.end())
     	{
     		cout << *it2 << " ";
     		++it2;
     	}*/
    
     	liu::list<int>i1(10,1);
     	liu::list<int>i2(10,2);
     	liu::swap(i1, i2);
    
     	for (auto x : i2)
     	{
     		cout << x << " ";
     	}
     	cout << endl;
    
     	for (auto x : i1)
     	{
     		cout << x << " ";
     	}
     	cout << endl;
     }

    }

相关推荐
nbsaas-boot1 小时前
Java 正则表达式白皮书:语法详解、工程实践与常用表达式库
开发语言·python·mysql
岁忧1 小时前
(LeetCode 面试经典 150 题 ) 11. 盛最多水的容器 (贪心+双指针)
java·c++·算法·leetcode·面试·go
乌托邦的逃亡者1 小时前
Docker的/var/lib/docker/目录占用100%的处理方法
运维·docker·容器
chao_7891 小时前
二分查找篇——搜索旋转排序数组【LeetCode】两次二分查找
开发语言·数据结构·python·算法·leetcode
ldj20201 小时前
Jenkins 流水线配置
运维·jenkins
风无雨1 小时前
GO 启动 简单服务
开发语言·后端·golang
斯普信专业组1 小时前
Go语言包管理完全指南:从基础到最佳实践
开发语言·后端·golang
秋说3 小时前
【PTA数据结构 | C语言版】一元多项式求导
c语言·数据结构·算法
我是苏苏3 小时前
C#基础:Winform桌面开发中窗体之间的数据传递
开发语言·c#
古希腊数通小白(ip在学)3 小时前
stp拓扑变化分类
运维·服务器·网络·智能路由器