list容器学习

STL整理

使用STL的时候很需要注意的一点是, STL的区间都是左闭右开的.

e.g. [start, end) 表示从start开始到end之前一个位置

1. list

头文件: #include<list>

实例化： list<类型>ListName

原型：

   namespace std {

       template <class T, class Allocator = allocator<T> >

       class list;

   }

成员函数：

构造函数(使得可以在定义时赋初值) list (); list (size_type n, const TYPE &v) list (const list &from) list ( input_iterator start, input_iterator end)	·无初值 ·给出n个初值 ·由另一个list初始化 ·由[start, end)区间内的值初始化
void assign(input_iterator start, input_iterator end); void assign(size_type num, const TYPE &val);	·清空链表，插入区间[start, end)的内容到list中 ·清空链表，插入num个值为val的元素
TYPE &back()	返回对最后一个元素的引用
TYPE &front()	返回对第一个元素的引用
iterator begin()	返回指向第一个元素的迭代器
iterator end()	返回指向链表末尾(最后一个元素之后的那个位置)的迭代器
void clear()	清空链表
bool empty()	如果链表为空返回true, 否则返回false
iterator erase(iterator pos); iterator erase(iterator start, iterator end);	·删除pos所指元素并返回下一元素迭代器 ·删除[start, end)之间的元素，并返回最后一个被删除元素的下个元素的迭代器
iterator insert( iterator pos, const TYPE &val ); void insert( iterator pos, size_type num, const TYPE &val); void insert( iterator pos, input_iterator start, input_iterator end );	·插入一个值为value的元素在pos位置并返回其迭代器，原pos及以后的元素后移。 ·插入num个值为value的元素在pos位置，原pos及以后元素后移。 ·插入[start, end)之间的元素到pos位置，原pos及以后元素后移
void merge(list &lst ); void merge(list &lst, bool Cmpfunc) // bool Cmpfunc(Type &a, Type &b)	将链表lst有序地合并到原链表中，默认使用小于号进行比较插入, 可指定比较函数Cmpfunc, 对两个TYPE类型元素进行比较
void pop_back();	删除链表的最后一个元素。
void pop_front();	删除链表的第一个元素。
void push_back( const TYPE &val );	将val连接到链表的最后。
void push_front( const TYPE &val );	将val连接到链表的头部。
void remove( const TYPE &val );	删除链表中所有值为val的元素。
void remove_if(bool testfunc) // bool testfunc(TYPE &val)	用testfunc一元函数来判断是否删除元素 如果testfunc返回true则删除该元素。
size_type size()	返回list中元素的数量。
void resize( size_type n,  TYPE val = 0)	将链表大小重置为n, 若n < size()只保留前面n个元素，否则最后size() - n个元素置为value(如果不给出，默认为0)
void reverse();	将链表所有元素倒转。
void sort(); void sort(Comp compfunc);	提供nlog2n的排序效率，默认使用小于号排序，可以自己指定排序函数。
void splice( iterator pos, list &lst ) void splice( iterator pos, list &lst, iterator del ); void splice(iterator pos, list &lst, iterator start, iterator end)	·将lst链表插入到这个链表的pos位置(pos及其后元素后移) ·将lst链表中del所指元素插入到这个链表的pos位置 ·将lst链表中[start, end)之间的元素插入到这个链表的pos位置
void swap( list &lst );	交换两个链表中的元素
void unique();	去除链表中重复元素(离散化)。
reverse_iterator rbegin();	返回一个逆向迭代器，指向链表的末尾
reverse_iterator rend();	返回一个指向开头之前位置的逆向迭代器

  

调试的一些代码：

#include<iostream>
#include<stack>
#include<queue>
#include<cstdio>
#include<list>
#include<cstring>
#include<string>
#include<cstdlib>
#include<algorithm>
using namespace std;
int main(int argc, char *argv[])
{
	int a[10]={1, 5, 6, 6, 4, 8, 9, 2, 1, 0};
	list<int> lis(1);
	lis.push_back(1);
	lis.push_back(2);
	lis.push_back(3);
	lis.push_back(4);
	lis.push_back(5);
	lis.push_back(6);
	//lis.push_back(7);
	//lis.push_front(8);
	cout<<lis.size()<<endl;
	list<int>::iterator it;
	for(it=lis.begin(); it!=lis.end(); it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
	int i;
//	for(it=lis.begin(), i=0; it!=lis.end() && i<5; it++, i++);
//	lis.insert(it, 15);
//	if( !lis.empty() )
//	{
//		lis.clear();
//		cout<<"do empty\n";
//	}
//	else cout<<"blank\n";
//	lis.push_back(4);
//	list<int>::iterator *it;
//	for(it=lis.begin(); it!=lis.end(); it++)
//	{
//		cout<<*it<<" ";
//	}
//	cout<<endl;
//    cout<<lis.front()<<endl;
//	cout<<lis.back()<<endl;
//	cout<<lis.size()<<endl;
//	lis.pop_front();
//	lis.pop_back();
//    list<int>::iterator st, ed, pos;
//	for(st=lis.begin(), i=0; st!=lis.end() && i<3; st++, i++);
//    for(ed=lis.begin(), i=0; ed!=lis.end() && i<6; ed++, i++);
//	for(pos=lis.begin(), i=0; pos!=lis.end() && i<5; pos++, i++);
//    /*将 st to ed 迭代器位置的元素复制插入到pos迭代器的位置，pos
//    之后的元素向后移动，元素个数增加 ed subtract st 个
//    加减乘除 ： add , subtract , multiply and divide
//    */
//	lis.insert(pos, st, ed);
//	cout<<lis.size()<<endl;
//	for(it=lis.begin(); it!=lis.end(); it++)
//	{
//		cout<<*it<<" ";
//	}
//	cout<<endl;
//	cout<<lis.size()<<endl;
//	for(it=lis.begin(); it!=lis.end(); it++)
//	{
//		cout<<*it<<" ";
//	}
//	cout<<endl;
//    list<int>::reverse_iterator rit;
//	for(rit=lis.rbegin(); rit!=lis.rend(); rit++)
//	{
//		cout<<*rit<<" ";
//	}
//	cout<<endl;
//    list<int> lis2;
//    lis2.clear();
//    for(i=0; i<4; i++)
//    {
//        int num;
//        cin>>num;
//        lis2.push_back(num);
//    }
//    list<int>::iterator it2;
//    for(it2=lis2.begin(); it2!=lis2.end(); it2++)
//    {
//        cout<<*it2<<" ";
//    }
//    cout<<endl;
//	cout<<"lis_size="<<lis.size()<<endl;
//	cout<<"lis2_size="<<lis2.size()<<endl;
	//bool comp(lis, lis2);
	/*默认使用小于号进行比较插入，但是要注意的是这里不是排序
	而是看lis2第 i 个比lis第几个小就插进去但是lis的迭代器指针
	回溯，也就是每次lis2的第i个比较之后比较到的位置，第i+1个
	元素就是从第i个元素比较到的位置开始比，所以不会是插入之后
	lis2在lis之中就是按大小排了序的，不是，
	比如 lis：1 2 3 4 5 6
         lis2： 4 5 1 3
    merge之后lis：1 2 3 4 4 5 5 1 3 6
    就是因为lis2第一个元素为4，与lis比较之后lis的迭代器到了
    第五个位置，也就是第二个4的位置，之后5比较时就是从第五个
    位置开始比，而后lis的迭代器到了第7个位置，lis2的元素 1
    插入的时候因为是从lis的第7个位置开始比较，1 < 6 ，所以
    1插入到6之前，而后lis2的元素3也是这样的比较方式。
	*/
//	lis.merge(lis2);
//    for(it=lis.begin(); it!=lis.end(); it++)
//	{
//		cout<<*it<<" ";
//	}
//	cout<<endl;
//	cout<<lis.size()<<endl;
//	/*移除与lis中与元素3相等的元素
//	*/
//    lis.remove(3);
    it=find(lis.begin(), lis.end(), 3);
    if( it!=lis.end() )
    {
        cout<<"find it"<<endl;
    }
    else
    {
        cout<<"not find it\n";
    }
    lis.sort();//默认升序排列
    lis.push_back(3);
    lis.push_front(4);
    lis.push_front(4);
    lis.push_front(4);
    for(it=lis.begin(); it!=lis.end(); it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
	cout<<lis.size()<<endl;
	/*提出连续重复元素，只保留一个，看清楚是连续重复的元素
	才会剔除，并且会保留一个
	*/
	lis.unique();
    for(it=lis.begin(); it!=lis.end(); it++)
	{
		cout<<*it<<" ";
	}
	cout<<endl;
	cout<<lis.size()<<endl;
//    for(it=lis.begin(), i=0; it!=lis.end() && i<3; i++, it++);
//    lis.erase(it);
//    for(it=lis.begin(); it!=lis.end(); it++)
//	{
//		cout<<*it<<" ";
//	}
//	cout<<endl;
//	cout<<lis.size()<<endl;
	return 0;
}
//bool comp(lis, lis2)
//{
//
//}