C++语言 STL容器list总结

在使用std::list<>链表时,难免会对数据进行添加删除操作。而遍历链表则有两种方式:通过索引访问,象数组一样处理;通过std::list<>::iterator链表遍历器进行访问

STL 中的list 就是一 双向链表,可高效地进行插入删除元素。

list不支持随机访问。所以没有 at(pos)和operator[]。

list 对象list1, list2 分别有元素list1(1,2,3),list2(4,5,6) 。list< int>::iterator it;

构造,析构

list<Elem> c //创建一个空的list 

list<Elem> c1(c2) //复制另一个同类型元素的list 

list<Elem>c(n) //创建n个元素的list,每个元素值由默认构造函数确定 

list<Elem>c(n,elem) //创建n个元素的list,每个元素的值为elem 

list<Elem>c(begin,end) //由迭代器创建list,迭代区间为[begin,end) 

c.~list();       // 销毁所有元素,释放内存

### 其他###

c.size() //返回容器的元素个数 

c.swap(c2) //将c2和c的元素互换 

c.empty() //判断容器是否为空 

c.max_size() //返回容器中最大数据的数量 

c.resize(num) //重新指定链表的长度 

c.reverse() //反转链表 

c.sort() //对列表进行排序,默认升序,可以自定义回调函数
//示例
list 对象L1(4,3,5,1,4)
L1.sort( );         // L1(1,3,4,4,5)
L1.sort( greater <int >() ); // L1(5,4,4,3,1) 

c.merge() //合并两个有序列表使之有序
//示例
// 升序
list1.merge(list2); // list1(1,2,3,4,5,6) list2 现为空
// 降序
L1( 3,2,1), L2(6,5,4)
L1.merge(L2, greater <int >() );
// list1(6,5,4,3,2,1) list2 现为空 

c.splice()
//对两个链表进行结合( 三个重载函数) 结合后第二个链表清空 

//示例
list1.splice( ++list1.begin(),list2);
// list1(1,4,5,6,2,3) list2 为空
 list1.splice( ++list1.begin(),list2,list2.begin());
// list1( 1,4,2,3); list2(5,6)
list1.splice( ++list1.begin(),list2,++list2.begin(),list2.end());
//list1( 1, 5,6, 2,3); list2(4)

### 赋值###

c.assign(begin,end) //将[begin,end)区间中的数据赋值给c 

c.assign(n,Elem) //将n个Elem的拷贝赋值给c 

c.swap(c2) //将c2和c的元素互换

### 数据访问###

c.front() //返回第一个数据 

c.back() //返回最后一个数据 

c.begin() //返回指向第一个元素的迭代器(指针) 

c.end() //返回指向最后一个数据的下一个位置的迭代器(指针) 

c.rbegin()
//返回逆向队列的第一个数据,也就是返回容器中倒数第一个元素的迭代器 

c.rend()
//返回指向逆向队列的最后一个数据的下一个位置的迭代器,
//也就是返回容器中倒数最后一个元素之后的迭代器

### 插入数据###

c.push_back(Elem) //list元素尾部增加一个元素x 

c.push_front(Elem) //list元素首元素钱添加一个元素X 

c.insert(pos,Elem) //在pos位置插入一个Elem拷贝,返回新数据的位置 

c.insert(pos,n,Elem) //在pos位置插入n个Elem数据,无返回值 

c.insert(pos,begin,end)
//在pos位置插入在[begin,end)区间的数据,无返回值

### 删除数据###

c.pop_back() //删除容器尾元素,当且仅当容器不为空  

c.pop_front() //删除容器首元素,当且仅当容器不为空  

c.remove(Elem) //删除容器中所有元素值等于x的元素  

/**
 remove_if()删除条件满足的元素(会遍历一次链表)
*/
void remove_if_test(){
ShowList(g_list1);
g_list1.remove_if(myFun);
ShowList(g_list1);
}  

c.clear() //删除容器中的所有元素  

c.erase(pos) //删除pos位置的数据,返回下一个数据的位置  

c.erase(begin,end)
//删除[begin,end)区间的数据,返回下一个数据的位置  

c.unique() //删除相邻重复元素
//示例
L1( 1, 1 ,4,3,5,1)
L1.unique( );     // L1(1,4,3,5,1)

### 示例###

#include<iostream>
#include<stdio.h>
#include<list>
using namespace std;
list < int > g_list1;
list < int > g_list2;
/**
 初始化全局列表
*/
void InitList(){
// push_back()增加一元素到链表尾
g_list1.push_back( 1 );
g_list1.push_back( 2 );
g_list1.push_back( 3 );
// push_front()增加一元素到链表头
g_list2.push_front( 6 );
g_list2.push_front( 5 );
g_list2.push_front( 4 );
}
/**
 输出一个链表
*/
void ShowList(list < int >& listTemp){
// size()返回链表中元素个数
cout << listTemp.size() << endl; 

for (list < int > ::iterator it = listTemp.begin();
it != listTemp.end(); ++ it){
  cout << * it << ' ' ;
}
  cout << endl;
}
/**
 构造函数,空链表
*/
void constructor_test0(){
list < int > listTemp;
cout << listTemp.size() << endl;
}
/**
 构造函数,建一个含三个默认值是0的元素的链表
*/
void constructor_test1(){
 list < int > listTemp( 3 );
 ShowList(listTemp);
}
/**
 构造函数,建一个含五个元素的链表,值都是1
*/
void constructor_test2(){
 list < int > listTemp( 5 , 1 );
 ShowList(listTemp);
}
/**
 构造函数,建一个g_list1的copy链表
*/
void constructor_test3(){
 list < int > listTemp(g_list1);
 ShowList(listTemp);
}
/**
 构造函数,listTemp含g_list1一个区域的元素[_First, _Last)
*/
void constructor_test4(){
 list < int > listTemp(g_list1.begin(), g_list1.end());
 ShowList(listTemp);
}
/**
 assign()分配值,有两个重载
 template <class InputIterator>
 void assign ( InputIterator first, InputIterator last );
 void assign ( size_type n, const T& u );
*/
void assign_test(){
 list < int > listTemp( 5 , 1 );
 ShowList(listTemp);
 listTemp.assign( 4 , 3 );
 ShowList(listTemp); 

 listTemp.assign( ++ g_list1.begin(), g_list1.end());
 ShowList(listTemp);
}
/**
 operator=
*/
void operator_equality_test(){
 g_list1 = g_list2;
 ShowList(g_list1);
 ShowList(g_list2);
}
/**
 front()返回第一个元素的引用
*/
void front_test7(){
 cout << g_list1.front() << endl;
}
/**
 back()返回最后一元素的引用
*/
void back_test(){
 cout << g_list1.back() << endl;
}
/**
 begin()返回第一个元素的指针(iterator)
*/
void begin_test(){
 list < int > ::iterator it1 = g_list1.begin();
 cout << *++ it1 << endl; 

 list < int > ::const_iterator it2 = g_list1.begin();
 it2 ++ ;
 // (*it2)++; // *it2 为const 不用修改
 cout << * it2 << endl; 

}
/**
 end()返回 [最后一个元素的下一位置的指针]
 (list为空时end()= begin())
*/
void end_test(){
list < int > ::iterator it = g_list1.end(); // 注意是:最后一个元素的下一位置的指针
-- it;
cout << * it << endl;
}
/**
 rbegin()返回链表最后一元素的后向指针
*/
void rbegin_test(){
 list < int > ::reverse_iterator it = g_list1.rbegin();
 for (; it != g_list1.rend(); ++ it){
 cout << * it << ' ' ;
}
 cout << endl;
}
/**
 rend()返回链表第一元素的下一位置的后向指针
*/
void rend_test(){
list < int > ::reverse_iterator it = g_list1.rend();
-- it;
cout << * it << endl;
}
/**
 push_back()增加一元素到链表尾
*/
void push_back_test(){
ShowList(g_list1);
g_list1.push_back( 4 );
ShowList(g_list1);
}
/**
 push_front()增加一元素到链表头
*/
void push_front_test(){
ShowList(g_list1);
g_list1.push_front( 4 );
ShowList(g_list1);
}
/**
 pop_back()删除链表尾的一个元素
*/
void pop_back_test(){
ShowList(g_list1);
cout << endl; 

g_list1.pop_back();
ShowList(g_list1); 

}
/**
 pop_front()删除链表头的一元素
*/
void pop_front_test(){
ShowList(g_list1);
cout << endl; 

g_list1.pop_front();
ShowList(g_list1);
}
/**
 clear()删除所有元素
*/
void clear_test(){
ShowList(g_list1);
g_list1.clear();
ShowList(g_list1);
}
/**
 erase()删除一个元素或一个区域的元素(两个重载函数)
*/
void erase_test()
{
ShowList(g_list1);
g_list1.erase(g_list1.begin());
ShowList(g_list1); 

cout << endl; 

ShowList(g_list2);
g_list2.erase( ++ g_list2.begin(), g_list2.end());
ShowList(g_list2);
}
/**
 remove()删除链表中匹配值的元素(匹配元素全部删除)
*/
void remove_test(){
ShowList(g_list1);
g_list1.push_back( 1 );
ShowList(g_list1); 

g_list1.remove( 1 );
ShowList(g_list1);
} 

bool myFun( const int & value) { return (value < 2 ); }
/**
 remove_if()删除条件满足的元素(会遍历一次链表)
*/
void remove_if_test(){
ShowList(g_list1);
g_list1.remove_if(myFun);
ShowList(g_list1);
}
/**
 empty()判断是否链表为空
*/
void empty_test()
{
list < int > listTemp;
if (listTemp.empty())
cout << " listTemp为空 " << endl;
else
cout << " listTemp不为空 " << endl;
}
/**
 max_size()返回链表最大可能长度:1073741823
*/
void max_size_test(){
list < int > ::size_type nMax = g_list1.max_size();
cout << nMax << endl;
}
/**
resize()重新定义链表长度(两重载函数):
*/
void resize_test(){
ShowList(g_list1);
g_list1.resize( 9 ); // 用默认值填补
ShowList(g_list1);
cout << endl; 

ShowList(g_list2);
g_list2.resize( 9 , 51 ); // 用指定值填补
ShowList(g_list2);
}
/**
reverse()反转链表
*/
void reverse_test(){
ShowList(g_list1);
g_list1.reverse();
ShowList(g_list1);
}
/**
 sort()对链表排序,默认升序(两个重载函数)
*/
void sort_test(){
list < int > listTemp;
listTemp.push_back( 9 );
listTemp.push_back( 3 );
listTemp.push_back( 5 );
listTemp.push_back( 1 );
listTemp.push_back( 4 );
listTemp.push_back( 3 ); 

ShowList(listTemp);
listTemp.sort();
ShowList(listTemp); 

listTemp.sort(greater < int > ());
ShowList(listTemp);
}
/**
 merge()合并两个升序序链表并使之成为另一个升序.
*/
void merge_test1(){
list < int > listTemp2;
listTemp2.push_back( 3 );
listTemp2.push_back( 4 ); 

list < int > listTemp3;
listTemp3.push_back( 9 );
listTemp3.push_back( 10 ); 

ShowList(listTemp2);
cout << endl;
ShowList(listTemp3);
cout << endl; 

listTemp2.merge(listTemp3);
ShowList(listTemp2);
} 

bool myCmp ( int first, int second)
{ return ( int (first) > int (second) ); }
/**
 merge()合并两个降序链表并使之成为另一个降序.
*/
void merge_test2(){
list < int > listTemp2;
listTemp2.push_back( 4 );
listTemp2.push_back( 3 ); 

list < int > listTemp3;
listTemp3.push_back( 10 );
listTemp3.push_back( 9 ); 

ShowList(listTemp2);
cout << endl;
ShowList(listTemp3);
cout << endl; 

// listTemp2.merge(listTemp3, greater<int>()); // 第二个参数可以是自己定义的函数如下
listTemp2.merge(listTemp3, myCmp);
ShowList(listTemp2);
}
/**
  splice()对两个链表进行结合(三个重载函数),结合后第二个链表清空
  void splice ( iterator position, list<T,Allocator>& x );
  void splice ( iterator position,
  list<T,Allocator>& x, iterator i );
  void splice ( iterator position,
  list<T,Allocator>& x, iterator first, iterator last );
*/
void splice_test(){
list < int > listTemp1(g_list1);
list < int > listTemp2(g_list2); 

ShowList(listTemp1);
ShowList(listTemp2);
cout << endl; 

//
listTemp1.splice( ++ listTemp1.begin(), listTemp2);
ShowList(listTemp1);
ShowList(listTemp2); 

//
listTemp1.assign(g_list1.begin(), g_list1.end());
listTemp2.assign(g_list2.begin(), g_list2.end());
listTemp1.splice( ++ listTemp1.begin(), listTemp2, ++ listTemp2.begin());
ShowList(listTemp1);
ShowList(listTemp2); 

//
listTemp1.assign(g_list1.begin(), g_list1.end());
listTemp2.assign(g_list2.begin(), g_list2.end());
listTemp1.splice( ++ listTemp1.begin(), listTemp2, ++ listTemp2.begin(), listTemp2.end());
ShowList(listTemp1);
ShowList(listTemp2); 

}
/**
  insert()在指定位置插入一个或多个元素(三个重载函数)
  iterator insert ( iterator position, const T& x );
  void insert ( iterator position, size_type n, const T& x );
  template <class InputIterator>
  void insert ( iterator position, InputIterator first, InputIterator last );
*/
void insert_test(){
list < int > listTemp1(g_list1);
ShowList(listTemp1);
listTemp1.insert(listTemp1.begin(), 51 );
ShowList(listTemp1);
cout << endl; 

list < int > listTemp2(g_list1);
ShowList(listTemp2);
listTemp2.insert(listTemp2.begin(), 9 , 51 );
ShowList(listTemp2);
cout << endl; 

list < int > listTemp3(g_list1);
ShowList(listTemp3);
listTemp3.insert(listTemp3.begin(),g_list2.begin(), g_list2.end());
ShowList(listTemp3); 

}
/**
 swap()交换两个链表(两个重载)
*/
void swap_test(){
ShowList(g_list1);
ShowList(g_list2);
cout << endl; 

g_list1.swap(g_list2);
ShowList(g_list1);
ShowList(g_list2);
} 

bool same_integral_part ( double first, double second)
{ return ( int (first) == int (second) ); }
/**
 unique()删除相邻重复元素
*/
void unique_test(){
list < int > listTemp;
listTemp.push_back( 1 );
listTemp.push_back( 1 );
listTemp.push_back( 4 );
listTemp.push_back( 3 );
listTemp.push_back( 5 );
listTemp.push_back( 1 );
list < int > listTemp2(listTemp); 

ShowList(listTemp);
listTemp.unique(); // 不会删除不相邻的相同元素
ShowList(listTemp);
cout << endl; 

listTemp.sort();
ShowList(listTemp);
listTemp.unique();
ShowList(listTemp);
cout << endl; 

listTemp2.sort();
ShowList(listTemp2);
listTemp2.unique(same_integral_part);
ShowList(listTemp2); 

}
/**
 主函数,列表测试
*/
int main(){
InitList();
 ShowList(g_list1);
 ShowList(g_list2); 

 constructor_test0();
 constructor_test1();
 constructor_test2();
 constructor_test3();
 constructor_test4();
 assign_test();
 operator_equality_test();
 front_test7();
 back_test();
 begin_test();
 end_test();
 rbegin_test();
 rend_test();
 push_back_test();
 push_front_test();
 pop_back_test();
 pop_front_test();
 clear_test();
 erase_test();
 remove_test();
 remove_if_test();
 empty_test();
 max_size_test();
 resize_test();
 reverse_test();
 sort_test();
 merge_test1();
 merge_test2();
 splice_test();
 insert_test();
 swap_test();
 unique_test();
return 0 ;
}

感谢阅读,希望能帮助到大家,谢谢大家对本站的支持!

(0)

相关推荐

  • C++中list的使用方法及常用list操作总结

    C++中list的使用方法及常用list操作总结 一.List定义: List是stl实现的双向链表,与向量(vectors)相比, 它允许快速的插入和删除,但是随机访问却比较慢.使用时需要添加头文件 #include <list> 二.List定义和初始化: list<int>lst1;          //创建空list     list<int> lst2(5);       //创建含有5个元素的list     list<int>lst3(3,2

  • C++ 使用模板实现一个List的实例

    C ++使用模板写的一个List template<class T> class List { private: struct Node { T data; Node *next; }; //head Node *head; //size int length; //process Node *p; //temp Node *q; public: List() { head = NULL; length = 0; p = NULL; } void add(T t) { if(head == N

  • C++中 STL list详解及简单实例

    C++中 STL list详解 1.List: 内部实现是一个双向链表,可以高效的进行插入删除,但不能够进行随机访问 2..示例程序: #include "stdafx.h" #include <iostream> #include <list> #include <iterator> #include <algorithm> using namespace std; const int num[5] = {1,3,2,4,5}; boo

  • C++ STL入门教程(2) list双向链表使用方法(附程序代码)

    一.简介 "Unlike other standard sequence containers, list and forward_list objects are specifically designed to be efficient inserting and removing elements in any position, even in the middle of the sequence." Lists将元素按顺序储存在链表中.与向量(vector)相比, 它允许快速

  • C++中CSimpleList的实现与测试实例

    本文实例讲述了C++简单列表类的实现方法.分享给大家供大家参考.具体方法如下: _AFXTLS.CPP文件如下: //#include "StdAfx.h #include <stddef.h> #include <stdio.h> #include "_AFXTLS_.H" struct MyThreadData{ MyThreadData* pNext; int nShortData; }; void CSimpleList::AddHead(vo

  • C++ list的实例详解

     C++ list的实例详解 Source: #include <iostream> #include <list> #include <numeric> #include <algorithm> using namespace std; typedef list<int> LISTINT; //创建一个list容器的实例LISTINT typedef list<int> LISTCHAR; //创建一个list容器的实例LISTCH

  • C++ 模拟实现list(迭代器)实现代码

    C++ 模拟实现list(迭代器) 实现代码: #pragma once; #include <assert.h> #include<iostream> #include <assert.h> using namespace std; template<class T> struct __ListNode { T _data; __ListNode<T>* _next; __ListNode<T>* _prev; __ListNode

  • C++ 中CListCtrl的每个项都显示不同的提示信息

    C++ 中CListCtrl的每个项都显示不同的提示信息 添加CToolTipCtrl成员变量m_toolTipCtrl,CListCtrl成员变量m_ListUser,CImageList成员变量m_imageList(这个可以不要) 在OnInitDialog()函数里加下面代码 m_BoradcastEnd.EnableWindow(FALSE); m_imageList.Create(32, 32, ILC_COLOR8, 2, 2); DWORD dwStyle = m_ListUse

  • C++语言 STL容器list总结

    在使用std::list<>链表时,难免会对数据进行添加删除操作.而遍历链表则有两种方式:通过索引访问,象数组一样处理:通过std::list<>::iterator链表遍历器进行访问 STL 中的list 就是一 双向链表,可高效地进行插入删除元素. list不支持随机访问.所以没有 at(pos)和operator[]. list 对象list1, list2 分别有元素list1(1,2,3),list2(4,5,6) .list< int>::iterator

  • 利用C++模拟实现STL容器:list

    目录 一.list的介绍 二.list的排序 三.迭代器 1.list的迭代器失效问题 2.迭代器的功能分类 3.list迭代器的模拟实现 4.迭代器价值 5.迭代器operator->的重载 四.模拟实现时遇到的困惑及注意点 五.vector和list的优缺点 1.vector 2.list 六.模拟实现list整体代码 一.list的介绍 列表是一种顺序容器,它允许在序列中的任何位置执行常量时间插入和删除操作,并允许在两个方向上进行迭代. 它的底层是一个带头双向循环链表.附一篇博主用C语言写

  • c++ STL容器总结之:vertor与list的应用

    STL提供六大组件,彼此可以组合套用 1.容器(containers):各种数据结构,如vertor,list,deque,set,map.从实现的角度来看,STL容器是一种class template 2.算法(algorithms):各种算法如sort,search,copy,earse.STL算法是一种 function template. 3.迭代器(iterators):扮演容器与算法之间的胶合剂,是所谓的"泛型指针".所有STL容器都有自己的专属的迭代器. 4.仿函数(fu

  • C++ STL容器适配器使用指南

    目录 适配器 stack容器适配器 ️stack的介绍 ️stack的使用 ️stack的模拟实现 queue ️queue的介绍 ️queue的使用 ️queue的模拟实现 deque容器 priority-queue ️priority-queue的使用 ️priority-queue的模拟实现 适配器 适配器是一种设计模式(设计模式是一套被反复使用的.多数人知晓的.经过分类编目的.代码设计经验的总结),该种模式是将一个类的接口转换成客户希望的另外一个接口.例如: 容器适配器让一种已存在的容

  • C++ STL容器详解之红黑树部分模拟实现

    目录 一.红黑树的概念 二.红黑树的性质 三.红黑树节点的定义 四.红黑树结构  五. 红黑树的插入操作 六.代码 总结 一.红黑树的概念 红黑树(Red Black Tree),是在计算机科学中用到的一种数据结构,是一种二叉搜索树,但在每个结点上增加一个存储位表示结点的颜色,可以是Red或Black. 通过对任何一条从根到叶子的路径上各个结点着色方式的限制,红黑树确保没有一条路径会比其他路径长出俩倍,因而是接近平衡的. 二.红黑树的性质 1. 每个结点不是红色就是黑色: 2. 根节点是黑色的:

  • C++实现STL容器的示例

    各大容器的特点: 1.可以用下标访问的容器有(既可以插入也可以赋值):vector.deque.map: 特别要注意一下,vector和deque如果没有预先指定大小,是不能用下标法插入元素的! 2. 序列式容器才可以在容器初始化的时候制定大小,关联式容器不行: 3.注意,关联容器的迭代器不支持it+n操作,仅支持it++操作. 适配器的概念 适配器的意思就是将某些已经存在的东西进行限制或者组合变成一个新的东西,这个新的东西体现一些新的特性,但底层都是由一些已经存在的东西实现的. STL中的容器

  • C++常见的stl容器与相关操作 示例解析

    目录 sort排序 vector map unordered_map set queue stack 创建容器时指定排序规则 sort排序 针对含有迭代器的容器,可以用#include<algorithm>中的sort函数进行排序. 默认排序是从小到大,可以自己写仿函数,也可以用greater<int>()或者less<int>(). #include <vector> #include <algorithm> #include <iost

  • C++ STL容器与函数谓词示例分析讲解

    目录 1.C++ vector向量 2.C++ stack 栈 3.C++ queue 队列 4.优先级队列 5.C++ list 6.c++ set 集合 7.C++ map函数 8.C++ multimap容器 9.C++ 谓词 10.C++内置预定义函数 C++ STL(Standard Template Library标准模板库),相当于java的集合模块, STL 有很多的容器. 1.C++ vector向量 (内部:封装动态大小数组作为容器,能够存放任意的动态数组) #include

  • C++模拟实现STL容器vector的示例代码

    目录 一.vector迭代器失效问题 二.模拟实现构造函数调用不明确 1.问题描述 2.解决调用不明确的方法 三.reserve中的深浅拷贝问题 1.reserve中浅拷贝发生原因 2.浅拷贝发生的图解 3.解决方法 四.模拟实现vector整体代码 一.vector迭代器失效问题 1.Visual Studio和g++对迭代器失效问题的表现 int main(){ std::vector<int>v{1,2,3,4}; std::vector<int>::iterator it

  • C++ STL容器stack和queue详解

    stack是一个比较简单的容器,它的使用也很简单,stack是LIFO容器,就是后进先出,最后添加进去的元素,第一个取出来 stack初始化 std::stack<int> first; std::stack<int> second(first); std::stack<int, std;:vector<int>> third; //使用vector初始化stack ### stack常用方法### empty();//判断是否为空 push(Elem e)

随机推荐