list容器的C++代码实现

最新推荐文章于 2023-04-02 19:56:27 发布
最新推荐文章于 2023-04-02 19:56:27 发布
阅读量1.7k 收藏 2
点赞数 1
分类专栏： C++ 文章标签： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yantingtao_sunny/article/details/51231988
版权

//list容器的C++代码实现

这是几个月前写的代码,那时候忘加备注了吐舌头

#include <iostream>
using namespace std;

template  <class T> 
class mylist;//前置声明

template <class T>
class node
 {
 	friend class mylist<T>;//友元
 	template <class T1>
 	friend ostream& operator <<(ostream & out , node<T1> _node);
    public:
    	node(T _data)
    	{
    		data = _data;
    		next = NULL;
    		prev = NULL;
    	}

    private:
    	T data;
    	node<T> *next;//指向下一个节点
    	node<T> *prev;//指向前一个节点
 };

//输出符号 << 的重载
 template <class T>
ostream& operator <<(ostream & out , node<T> _node)
{
	out<<_node.data<<'\t';
	return out;
}
/*类名:mylist*/
template<class T>
class mylist
{
public:
	typedef bool (*Unperd)(T value);
	typedef bool (*BinPred)(T value);
	typedef bool (*Comp)(T a,T b);//排序的函数指针
	/*类名:iterator
    作用:迭代器
    */
      class iterator
      {
          public:
          	iterator()
          	{
          		ptr = NULL;
          	}
          	iterator(node<T>* _ptr)
          	{
          		ptr = _ptr;
          	}
             /*符号 = 重载*/
          	void operator =(iterator it)
          	{
               this->ptr = it.ptr;
          	}
             /*符号 != 重载*/
          	bool operator !=(iterator it)
          	{
               return this->ptr != it.ptr;
          	}
             /*符号 == 重载*/
          	bool operator == (iterator it)
          	{
          		return this->ptr == it.ptr;
          	}
             /*符号 ++ 重载*/
          	iterator operator ++(int i)//这里的 int i 是无意义的只是区别前++
          	{
          		iterator tmp;//中间迭代器变量tmp
          		tmp = *this;
          		this->ptr = this->ptr->next;
          		return tmp;
          	}
             /*符号 * 重载*/
          	node<T> operator *()
          	{
          		return *(this->ptr);
          	}

          private:
          	node<T> *ptr;
      };
       /*反向迭代器*/
      //反向迭代器就是++的重载不一样,其他是一样的
    class reserve_iterator
    {
           public:
          	reserve_iterator()
          	{
          		ptr = NULL;
          	}
          	reserve_iterator(node<T>* _ptr)
          	{
          		ptr = _ptr;
          	}

          	void operator =(reserve_iterator it)
          	{
               this->ptr = it.ptr;
          	}
          	bool operator !=(reserve_iterator it)
          	{
               return this->ptr != it.ptr;
          	}
          	bool operator == (reserve_iterator it)
          	{
          		return this->ptr == it.ptr;
          	}
          	reserve_iterator operator ++(int i)
          	{
          		reserve_iterator tmp;
          		tmp = *this;
          		this->ptr = this->ptr->prev;
          		return tmp;
          	}
          	node<T> operator *()
          	{
          		return *(this->ptr);
          	}
          private:
          	node<T> *ptr;
    };
    /*无参缺省构造*/
	mylist()
	{
		head = NULL;
		curr = NULL;
	}
	/*list(int num,T value)
  函数名:mylist
  作用:创造一个list容器里面初始就有num个value值
  参数:int num,T value
  返回值:无
  */
	mylist(int num,T value)
	{
	    head = new node<T>(value);
	    curr = head;
	    int i;
	    node<T>* newnode = NULL;
	    for (i = 0; i < num;i++)
	    {
	        newnode = new node<T>(value);
	        curr->next = newnode;
	        newnode->prev = curr;
	    	 curr = newnode; 
	   	    newnode = NULL;    	
	    }
	    curr->next = head;//构成循环
	    head->prev = curr;
	}
  /*list<T>(list)
  函数名:mylist
  作用:创造一个list容器里面拷贝另一个list容器的所有内容
  参数:mylist & list
  返回值:无
  */
    mylist(mylist & list)
    {
    	node<T>* point = list.head->next;
        this->head = new node<T>(point->data);
        this->curr = this->head;
        node<T> * newnode = NULL;
        while (point != list.head)
        {
           newnode = new node<T>(point->data);
           this->curr->next = newnode;
           newnode->prev = this->curr;
           this->curr = newnode;
           newnode = NULL;
           point = point->next;
        }
        this->curr->next = this->head;
        this->head->prev = this->curr; 
    }


  /*list<T>(list.begin(),list.end())
  函数名:mylist
  作用:创造一个list容器里面拷贝另一个list容器的所有内容
  参数:mylist & list
  返回值:无
  */
    mylist(iterator start,iterator end)
    {
    	 iterator point = start;
        head = new node<T>(*point);
        curr = head;
        node<T> * newnode = NULL;
        while (point != end)
        {
           newnode = new node<T>(*point);
           curr->next = newnode;
           newnode->prev = curr;
           curr = newnode;
           newnode = NULL;
           point++;
        }
        curr->next = head;
        head->prev = curr; 
    }

	/*void assign( input_iterator start, input_iterator end );
	assign()函数以迭代器start和end指示的范围为list赋值*/
      void assign(iterator start,iterator end)
      {
         iterator point = start;
         if (NULL == head)
         {
             this->head = new node<T>(*point);
             curr = head;
         }
         else
         {
             curr = head->prev;
         }
           
            node<T> * newnode = NULL;
            while (point != end)
           {
             newnode = new node<T>(*point);
             curr->next = newnode;
             newnode->prev = curr;
             curr = newnode;
             newnode = NULL;
             point++;
           }
           curr->next = head;
           head->prev = curr;
      }
     /*void assign( size_type num, const TYPE &val );*/
      void assign(int num,const T & value)
      {
         if (NULL == head)
         {
         	head = new node<T>(value);
	        curr = head;
         }
         else
         {
         	curr = head->prev;
         }
	    int i;
	    node<T>* newnode = NULL;
	    for (i = 0; i < num;i++)
	    {
	        newnode = new node<T>(value);
	        curr->next = newnode;
	        newnode->prev = curr;
	    	curr = newnode; 
	   	    newnode = NULL;    	
	    }
	    curr->next = head;
	    head->prev = curr;
      }
   /*back()函数返回一个引用，指向list的最后一个元素*/
     T& back()
    {
      return head->prev->data;
    }
    /*clear()函数删除list的所有元素*/
    void clear()
    {
    	curr = head->next;
    	head->next = NULL;
    	node<T>* tmp;
    	while (curr != head)
    	{
    		tmp = curr;
    		curr = curr->next;
    		head->next = curr;
    		if (NULL != curr)
    		{
    			curr->prev = head;
    		}
    		free(tmp); 
    		tmp = NULL;
    	}
    }
    /*empty()函数返回真(true)如果链表为空，否则返回假*/
    bool empty()
    {
    	if (head->next == head)
    		return true;
    	return false;
    }
   /*起始位置*/
	iterator begin()
	{
       return  iterator(head->next);
	}
	/*末尾的下一个*/
	iterator end()
	{
       return  iterator(head);
	}

	/*rbegin()函数返回一个逆向迭代器，指向链表的末尾。*/
	reserve_iterator rebegin()
	{
		return reserve_iterator(head->prev);
	}

	/*rend()函数迭代器指向链表的头部。*/
	reserve_iterator rend()
	{
		return reserve_iterator(head);
	}

	/*find查找指定元素的第一个位置没找到则返回NULL*/
	iterator find(const T &value)
	{
		curr = head->next;
		int flag = 0;
        while (curr != head)
        {
        	if (curr->data == value)
        	{   
        		flag = 1;
        		return iterator(curr);
        		break;
        	}
        	curr = curr->next;
        }
        if (flag == 0)
        {
        	return iterator();
        }
	}


	/*erase()函数删除以pos指示位置的元素
	  iterator erase( iterator pos );*/
	iterator erase(iterator pos)
	{
	    node<T>* tmp = head;
	    curr = head->next;
	    while (curr != head)
	    {
	    	 if (iterator(curr) == pos)
	    	 {
	    	 	tmp->next = curr->next;
	    	 	curr->next->prev = tmp;
	    	 	return iterator(curr->next);
	    	 	free(curr);
	    	 	curr = NULL;
	    	 	break;
	    	 }
	    	 else
	    	 {
	    	 	tmp = curr;
	    	 }
	    	 curr = curr->next;
	    }
	}
     /* iterator erase( iterator start, iterator end );
     删除start和end之间的元素。 返回值是一个迭代器，
     指向最后一个被删除元素的下一个元素*/
     iterator erase(iterator start,iterator end)
     {
     	node<T>* tmp = head;
     	curr = head->next;
     	while (curr != head)
     	{
     		if (iterator(tmp) == start)
     		{
                while (iterator(curr) != end)
                {
                	tmp->next = curr->next;
                	curr->next->prev = tmp;
                	free(curr);
                	curr = NULL;
                	curr = tmp->next;
                }
                return iterator(curr);
                break;
     		}
     		else
     		{
              tmp = curr;
     		}
     		curr = curr->next;
     	}
     }

     /*front()函数返回一个引用，指向链表的第一个元素。*/
     T & front()
     {
     	return head->next->data;
     }

     /*  iterator insert( iterator pos, const TYPE &val );*/
      iterator insert(iterator pos,const T& value)
      {
      	 node<T>* newnode = new node<T>(value);
      	 curr = head->next;
      	 while (curr != head)
      	 {

      	 	if (iterator(head) == pos)
      	 	{
                 head->prev->prev->next = newnode;
                 newnode->prev = head->prev->prev;
                 head->prev->prev = newnode;
                 newnode->next = head->prev;
                 return iterator(head->prev);
                 break;
      	 	}
      	 	if (iterator(curr) == pos)
      	 	{
      	 		curr->prev->next = newnode;
      	 		newnode->prev = curr->prev;
      	 		curr->prev = newnode;
      	 		newnode->next = curr;
      	 		break;
      	 	}
      	 	curr = curr->next;
      	 }
      }
      /*  void insert( iterator pos, size_type num, const TYPE &val );*/
      void insert(iterator pos,int num,const T &value)
      {
      	 node<T>* newnode;
      	 curr = head->next;
      	 node<T>* tmp = head;
      	 if (iterator(head) == pos)
      	 {   
      	 	 tmp = head->prev->prev;
      	 	 curr = head->prev;
             while (0 != num)
             {
                newnode = new node<T>(value);
                tmp->next = newnode;
                newnode->prev = tmp;
                tmp = newnode;
                newnode = NULL;
                num--; 
             }
             tmp->next = curr;
             curr->prev = tmp;
      	 }
      	 else
      	 {
      	   while (curr != head)
      	   {    	 	
      	 	  if (iterator(curr) == pos)
      	 	 {
      	 	    while (0 != num)
      	 	    {
      	 	    	newnode = new node<T>(value);
      	 	    	tmp->next = newnode;
      	 	    	newnode->prev = tmp;
      	 	    	tmp = newnode;
      	 	    	newnode = NULL;
      	 	    	num--;
      	 	    }
      	 	    tmp->next = curr;
      	 	    curr->prev = tmp;
      	 	    break;
      	 	 }
      	 	 else
      	 	 {
      	 		tmp =curr;
      	 	 }
      	 	curr = curr->next;
      	  }
      	 }
      }
      /*pop_back()函数删除链表的最后一个元素。*/
      void pop_back()
      {
      	 curr = head->prev;
      	 node<T>* tmp = head->prev->prev;
      	 tmp->next = head;
      	 head->prev = tmp;
      	 free(curr);
      	 curr = NULL;
      }
      /*pop_front()函数删除链表的第一个元素。*/
      void pop_front()
      {
      	 curr = head->next;
      	 node<T>* tmp = head->next->next;
         head->next = tmp;
         tmp->prev = head;
         free(curr);
         curr = NULL;
      }
     /* push_back()将val连接到链表的最后*/
      void push_back(const T& value)
      {
      	node<T>* newnode = new node<T>(value) ;
      	if (head == NULL)
      	{
           head = new node<T>(value);
           curr = head;
      	}
      	else
      	{
      		curr = head->prev;
      	}
      	 curr->next = newnode;
         newnode->prev = curr;
         curr = newnode;
         newnode = NULL;
         curr->next = head;
         head->prev = curr;
      }
      /*push_front函数将val连接到链表的头部。*/
      void push_front(const T& value)
      {
      	node<T>* newnode = new node<T>(value) ;
      	if (head == NULL)
      	{
           head = new node<T>(value);
           curr = head;
           curr->next = newnode;
           newnode->next = curr;
           curr = newnode;
           newnode = NULL;
           curr->next = head;
           head->prev = curr;
      	}
        else
        {
           curr = head;
           newnode->next = curr->next;
      	   curr->next = newnode;
      	   curr = newnode;
      	   newnode = NULL;
           curr->prev = head;
           curr->next->prev = curr;
        }
      }
      /*remove()函数删除链表中所有值为val的元素*/
      void remove(const T & value)
      { 
          node<T>* tmp = head;
          curr = head->next;
          while (curr != head)
          {
          	if (curr->data == value)
          	{
                tmp->next = curr->next;
                curr->next->prev = tmp;
                free(curr);
                curr = NULL;
                curr = tmp;
          	}
          	else
          	{
          		tmp = curr;
          	}
          	curr = curr->next;
          }
      }
      /*remove_if()以一元谓词pr为判断元素的依据，遍历整个链表
      如果pr返回true则删除该元素。*/
      void remove_if(Unperd pr)
      {
      	   node<T>* tmp = head;
          curr = head->next;
          while (curr != head)
          {
          	if (pr(curr->data))
          	{
                tmp->next = curr->next;
                curr->next->prev = tmp;
                free(curr);
                curr = NULL;
                curr = tmp;
          	}
          	else
          	{
          		tmp = curr;
          	}
          	curr = curr->next;
          }
      }

      /*resize()函数把list的大小改变到num。被加入的多余的元素都被赋值为val*/
      void resize(int num,T value)
      {      	
        int record = 0;
        curr = head->next;
        iterator point;
        while (curr != head)
        {
        	 ++record;
        	if (record == num)
        	{
        		point = iterator(curr);
        	}
           curr = curr->next;
        }
        if (record < num)
        {  	
        	while (record != num)
        	{
        		node<T>* newnode = new node<T>(value);
        		curr = head->prev;
        	    curr->next = newnode;
                newnode->prev = curr;
                curr = newnode;
                newnode = NULL;
                curr->next = head;
                head->prev = curr;
                record++;
        	}
        }
        if (record > num)
        {
           erase(point,iterator(head));
        }
      }

      /*reverse()函数把list所有元素倒转。*/
      void reverse()
      { 
         mylist<T> list(*this);
        node<T>* tmp = list.head->prev;
         this->curr = this->head->next;
         while (this->curr != this->head)
         {
         	this->curr->data = tmp->data;
         	tmp = tmp->prev;
         	this->curr = this->curr->next;
         }
      }

      /*size()函数返回list中元素的数量。*/
      int size()
      {
      	curr = head->next;
      	int num = 0;
      	while (curr != head)
      	{
      		num++;
      		curr = curr->next;
      	}
      	return num;
      }

      /*sort()函数为链表排序，默认是升序*/
      void sort()
      {
      	curr = head->next;
      	node<T>* tmp;
      	tmp =  head->next->next;
      	int temp = 0;
      	int n = size();
      	int i = 0;
      	int flag = 0;
        while (tmp != head)
        {              
        	if (curr->data > tmp->data)
        	{
        		flag = 1;
        		temp = tmp->data;
        		tmp->data = curr->data;
        		curr->data = temp;
        	}
        	i++;
        	curr = curr->next;
        	tmp = tmp->next;
            if ((i == n-1)&&(flag == 1))
        	{
        		flag = 0;
        		i = 0;
        		curr = head->next;
                tmp = head->next->next;
        	} 
        }
      }

      /* void sort( Comp compfunction );
      如果指定compfunction的话，就采用指定函数来判定两个元素的大小*/
      void sort(Comp compfunction)
      {
      	curr = head->next;
      	node<T>* tmp;
      	tmp =  head->next->next;
      	int temp = 0;
      	int n = size();
      	int i = 0;
      	int flag = 0;
        while (tmp != head)
        {              
        	if (compfunction(curr->data,tmp->data))
        	{
        		flag = 1;
        		temp = tmp->data;
        		tmp->data = curr->data;
        		curr->data = temp;
        	}
        	i++;
        	curr = curr->next;
        	tmp = tmp->next;
            if ((i == n-1)&&(flag == 1))
        	{
        		flag = 0;
        		i = 0;
        		curr = head->next;
                tmp = head->next->next;
        	} 
        }
     }
      /*void splice( iterator pos, list &lst );splice()函数把lst连接到pos的位置*/
     void splice(iterator pos,mylist & list)
     {
     	this->curr = this->head->next;
     	node<T>* tmp = this->head;
     	while (this->curr != this->head)
     	{
     		if (iterator(this->curr) == pos)
     		{
                tmp->next = list.head->next;
                list.head->prev->next = this->curr->next;
                this->curr->next->prev = list.head->prev;
                list.head->prev = tmp;
                free(this->curr);
                this->curr = NULL;
                free(list.head);
                list.head = NULL;
                break;
     		}
     		else
     		{
     			tmp = this->curr;
     		}
     		this->curr = this->curr->next;
     	}
     }

     /* void splice( iterator pos, list &lst, iterator del );*/
     void splice(iterator pos,mylist & list,iterator del)
     {
     	this->curr = this->head->next;
     	list.curr = list.head->next;
     	node<T>* tmp = list.head;
     	while (this->curr != this->head)
     	{
     		if (iterator(this->curr) == pos)
     		{
                 while (list.curr != list.head)
                 {
                 	if (iterator(list.curr) == del)
                 	{
                         this->curr->data = list.curr->data;
                         tmp->next = list.curr->next;
                         curr->next->prev = tmp;
                         free(list.curr);
                         list.curr;
                         break;
                 	}
                 	else
                 	{
                 		tmp = list.curr;
                 	}
                  list.curr = list.curr->next;
                 }
                 break;
     		}
     		this->curr = this->curr->next;
     	}
     }

     /* void splice( iterator pos, list &lst, iterator start, iterator end );*/
     void splice(iterator pos,mylist & list,iterator start,iterator end)
     {  
     	list.curr = list.head;
        node<T>* point = list.head;
        node<T>* point1 = list.head;
        iterator it = this->erase(pos);
     	while (iterator(list.curr) != start)
     	{
            list.curr = list.curr->next;
     	}
     	point = list.curr->prev;
     	while(iterator(list.curr->prev) != end)
     	{
           this->insert(it,list.curr->data);
           list.curr = list.curr->next;
     	}
     	point1 = list.curr;
     	list.erase(point,point1);
     }
     /*swap()函数交换lst和现链表中的元素*/
     void swap(mylist & list)
     {
     	int flag1 = 0;//记录交换时那个链表过长需要删除
     	int flag2 = 0;//这里其实只要一个标志  但是为了方便故设置两个
        mylist<T> tmp(list);
        list.curr = list.head->next;
        this->curr = this->head->next;
        while (this->curr != this->head)
        {   
        	if (list.curr != list.head)
        	{
        	  list.curr->data =  this->curr->data;
        	  list.curr = list.curr->next;
        	}
        	else
        	{
        		flag1 = 1;
               list.push_back(this->curr->data);
        	}	
        	this->curr = this->curr->next;
        }
        if ((list.curr != list.head)&& (flag1 == 0))
        {
        	list.erase(iterator(list.curr->prev),iterator(list.head));
        }
         tmp.curr = tmp.head->next;
        this->curr = this->head->next;
       while (tmp.curr != tmp.head)
        {   
        	if (this->curr != this->head)
        	{
        	  this->curr->data =  tmp.curr->data;
        	  this->curr = this->curr->next;
        	}
        	else
        	{
        		flag2 = 1;
               this->push_back(tmp.curr->data);
        	}	
        	tmp.curr = tmp.curr->next;
        }
        if ((this->curr != this->head)&& (flag2 == 0))
        {
        	this->erase(iterator(this->curr->prev),iterator(this->head));
        }
     }

     /* void unique();unique()函数删除链表中所有重复的元素。*/
        void unique()
        {
           curr = head->next->next;
           node<T>* tmp = head->next;
           while (curr != head)
           {
              if (tmp->data == curr->data)
              {
              	   tmp->next = curr->next;
              	   curr->next->prev = tmp;
              	   free(curr);
              	   curr = NULL;
              	   curr = tmp->next;
              }
              tmp = tmp->next;
              curr = curr->next;
           }
        }
        /* void unique( BinPred pr );
     指定pr，则使用pr来判定是否删除*/
        void unique(BinPred pr)
        {
           curr = head->next->next;
           node<T>* tmp = head->next;
           while (curr != head)
           {
              if ((tmp->data == curr->data)&&pr(curr->data))
              {
              	   tmp->next = curr->next;
              	   curr->next->prev = tmp;
              	   free(curr);
              	   curr = NULL;
              	   curr = tmp->next;
              }
              tmp = tmp->next;
              curr = curr->next;
           }
        }
private:
    node<T> *head;
    node<T> *curr;
};

template <class T>
bool dis_tinet( T value)
{
	if (9 == value)
		return true;
	return false;
}
template <class T>
bool sortfunction(T a,T b)
{
	if (a < b)
		return true;
	return false;
}
template <class T>
bool unique_t( T value)
{
	if (8 == value)
		return true;
	return false;
}

yantingtao_sunny
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C++——List容器
New_learner55的博客
11-28 166
List容器接口的使用 #include<list> void test_list1() { list<int> l1; list<int> l2(10,3); list<int> l3(l2.begin(),l2.end()); list<int> copy(l3); list<int>::iterator c...
c++实现list类(第一次用类) —— new对象需delete
思緒凌亂
11-22 4358
一：起因 （1）拿出自己年初实现的list，第一次用c++类实现list或者说第一次写一个工程上用到的list类，在和如今实现的list对比，心情无比复杂； （2）说明了一点，我也曾经幼稚过，现在还比较幼稚，但我相信，只要坚持最初梦想的人，终究会走向成熟； （3）更加详细的比较全的list   请看   STL list类源代码实现   （4）再次感谢自己能坚持最初的梦，相信你也有一个
【C++学习】List1.new运算符
GGGGBond的博客
01-11 242
C++学习
C++语法——超详细模拟实现list源代码
weixin_61857742的博客
10-18 1506
这篇小编将以SGI版的list为例进行模拟实现。这里小编做了一张图，它足以表明list的大致框架：对于节点node而言，我们可以按照c语言中的双向链表节点结构进行创建。首先node设为一种类由于list属于泛型编程，我们不知道链表数据类型，因此使用template将node变成泛型类。内部参数分别是node* next，node* prev，T value。通过代码我们可以发现，在结构上list_node与c语言的结构体链表节点基本无异。但是C++特性赋予了链表节点泛型编程的强大功能。当
C++源码剖析——list
梦的灰色边沿...
04-02 307
之前看过侯老师的《STL源码剖析》但是那已经是多年以前的，现在工作中有时候查问题和崩溃都需要了解实际工作中使用到的STL的实现。因此计划把STL的源码再过一遍。
数据结构-C++实现的简单List
CrazyRabbitttt
01-26 3596
本文用C++语言实现了一个简单的List，其中包括List的基本功能接口函数的实现和对于List排序的插入排序和选择排序...希望能够帮助到大家
C++容器vector实现通讯录功能
12-23
最近写了一个C++版本的通讯录，参考代码如下所示。 main.cpp /***************************************************** Copyright (C)： 2017-2018 File name ： main.cpp Author ： Zhengqijun Date ： 2017年02月...
list_list_STL_C++_
09-29
C++中标准模板库中list容器的基本概念与基本操作
c++容器list、vector、map、set区别与用法详解
08-19
主要介绍了c++容器list、vector、map、set区别与用法详解，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
list链表c++源代码
08-25
使用C++ 代码编写的一个链表，类似于C++ STL中的容器list。可以放入任何类型的数据，通过迭代器访问链表。涉及到的技术很多。
STL容器使用代码
01-05
c++ STL容器使用代码，方便学习 vector string deque queue list set map multiset multimap 容器的API使用方法等
c++list类实现
11-23
1）代码注释很详细的，非常适合学习STL的。 2）数据结构里面两种非常重要的存储结构，线性结构中的连续存储结构（代表vector数组）和非连续存储结构（代表list链表），他们两者被广泛的应用在各个领域，是最基本最基础的两种存储结构； 3）之前的友元类只是停留在理论层面，真正实现还是头一次；友元类非常像java中的内部类
标准库list源码
03-24
学习STL源码的好助手，是一个非常简化版的SLT list源码，可以让你理解stl的本质
最详细的C++单向链表实现
热门推荐
qq_41696018的博客
08-15 1万+
链表是数据结构中常见的一种数据存储形式，其在物理存储单元上是非连续的存储结构，即其数据存储的空间并非连续的内存空间。这种存储方式的优点是可以动态分配内存空间，不会造成内存的浪费和溢出，同时链表对于执行插入、删除等操作十分简便，不需要移动大量元素，但是其相对于连续空间存储的数据相比，遍历速度较慢。 1、那么链表到底长啥样呢？ 链表由多个node(节点)组成，每个节点中由两部分结构组成，data中存储需要存储的数据，next为一个指针，其指向下一个node的地址。 当...
C++容器list使用介绍和基本实现
qq_52145272的博客
03-20 960
list常用函数介绍，list的模拟实现，主要是迭代器的实现。最后实现了可适配的反向迭代器。
C++入门篇(13)之list的实现
m0_51723227的博客
11-24 4097
文章目录前言list的结构搭建两种构造函数① 默认构建函数② 迭代器区间构建函数拷贝构造函数赋值重载数据的头尾删插① 尾插push_back()② 尾删pop_back()③ 头插push_front()④ 头删pop_front()迭代器的实现迭代器接口clear()清理析构函数erase和insert的实现and简化头尾数据删除最终list代码 前言 上一节我们简单叙述了一下list的概念,知道其底层是一个带头结点的双向循环链表,并且介绍了其使用方法,**但是!**知其然未必知其所以然,我们不但应该知其
126邮箱页 html源码 单页源码 网站后台登陆界面HTML源码.zip
最新发布
04-23
126邮箱页 html源码 单页源码 网站后台登陆界面HTML源码
武汉开放数据创新大赛——烽火杯文件.zip
04-23
武汉开放数据创新大赛——烽火杯文件
mmexport1713881481676.png
04-23
mmexport1713881481676.png
c++ list容器
09-21
引用 [3] 是一段C++代码，展示了如何使用list容器来进行等号赋值和交换操作。 list容器是C++标准库中的一种序列容器，用于存储多个元素。它类似于数组，但具有更多的功能和灵活性。list容器使用双向链表实现，因此...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值