`
mmdev
  • 浏览: 12846597 次
  • 性别: Icon_minigender_1
  • 来自: 大连
文章分类
社区版块
存档分类
最新评论

C++【STL】list基础

 
阅读更多

各个容器有很多的相似性。先学好一个,其它的就好办了。先从基础开始。

先看看他们的分类吧

  • 标准STL序列容器:vector、string、deque和list。
  • 标准STL关联容器:set、multiset、map和multimap。
  • 非标准序列容器slist和rope。slist是一个单向链表,rope本质上是一个重型字符串。
  • 非标准关联容器hash_set、hash_multiset、hash_map和hash_multimap。

    先看看list。

    list

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

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


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


    list成员

    说明

    constructor

    构造函数

    destructor

    析构函数

    operator=

    赋值重载运算符

    assign

    分配值

    front

    返回第一个元素的引用

    back

    返回最后一元素的引用

    begin

    返回第一个元素的指针(iterator)

    end

    返回最后一个元素的下一位置的指针

    rbegin

    返回链表最后一元素的后向指针(reverse_iterator or const)

    rend

    返回链表第一元素的下一位置的后向指针

    push_back

    增加一元素到链表尾

    push_front

    增加一元素到链表头

    pop_back

    pop_back()删除链表尾的一个元素

    pop_front

    删除链表头的一元素

    clear

    删除所有元素

    erase

    删除一个元素或一个区域的元素(两个重载)

    remove

    删除链表中匹配值的元素(匹配元素全部删除)

    remove_if

    删除条件满足的元素(遍历一次链表),参数为自定义的回调函数

    empty

    判断是否链表为空

    max_size

    返回链表最大可能长度

    size

    返回链表中元素个数

    resize

    重新定义链表长度(两重载函数)

    reverse

    反转链表

    sort

    对链表排序,默认升序

    merge

    合并两个有序链表并使之有序

    splice

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

    insert

    在指定位置插入一个或多个元素(三个重载函数)

    swap

    交换两个链表(两个重载)

    unique

    删除相邻重复元素

    1.list构造函数

    list<int>L0;//空链表

    list<int>L1(9);//建一个含个默认值是的元素的链表

    list<int>L2(5,1);//建一个含个元素的链表,值都是

    list<int>L3(L2);//建一个L2copy链表

    list<int>L4(L0.begin(),L0.end());//建一个含L0一个区域的元素

    2. assign()分配值,有两个重载

    L1.assign(4,3); // L1(3,3,3,3)

    L1.assign(++list1.beging(), list2.end());//L1(2,3)

    3.operator=赋值重载运算符

    L1 = list1;//L1(1,2,3)

    4.front()返回第一个元素的引用

    intnRet = list1.front()// nRet = 1

    5.back()返回最后一元素的引用

    intnRet = list1.back()// nRet = 3

    6.begin()返回第一个元素的指针(iterator)

    it= list1.begin();// *it = 1

    7.end()返回最后一个元素的下一位置的指针(list为空时end()=begin())

    it= list1.end();

    --it;// *it = 3

    8.rbegin()返回链表最后一元素的后向指针(reverse_iterator or const)

    list<int>::reverse_iteratorit=list1.rbegin();// *it = 3

    9.rend()返回链表第一元素的下一位置的后向指针

    list<int>::reverse_iterator it =list1.rend(); // *(--riter) = 1

    10.push_back()增加一元素到链表尾

    list1.push_back(4)// list1(1,2,3,4)


    11.push_front()增加一元素到链表头

    list1.push_front(4)// list1(4,1,2,3)

    12.pop_back()删除链表尾的一个元素

    list1.pop_back()// list1(1,2)

    13.pop_front()删除链表头的一元素

    list1.pop_front() // list1(2,3)

    14.clear()删除所有元素

    list1.clear();// list1空了,list1.size() =0

    15.erase()删除一个元素一个区域的元素(两个重载函数)

    list1.erase(list1.begin());// list1(2,3)

    list1.erase(++list1.begin(),list1.end()); // list1(1)

    16.remove()删除链表中匹配值的元素(匹配元素全部删除)

    list对象L1(4,3,5,1,4)

    L1.remove(4);// L1(3,5,1);

    17.remove_if()删除条件满足的元素(遍历一次链表),参数为自定义的回调函数

    //小于2的值删除

    boolmyFun(constint&value) {return(value< 2); }

    list1.remove_if(myFun);// list1(3) 

    18.empty()判断是否链表为空

    bool bRet = L1.empty(); //若L1为空,bRet = true,否则bRet = false。

    19.max_size()返回链表最大可能长度

    list<int>::size_typenMax=list1.max_size();//nMax=1073741823

    20.size()返回链表中元素个数

    list<int>::size_type nRet = list1.size();// nRet = 3

    21.resize()重新定义链表长度(两重载函数)

    list1.resize(5)// list1 (1,2,3,0,0)用默认值填补

    list1.resize(5,4)// list1 (1,2,3,4,4)用指定值填补

    22.reverse()反转链表:

    list1.reverse();// list1(3,2,1)

    23.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)

    24.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现为空

    25.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)

    26.insert()在指定位置插入一个或多个元素(三个重载函数)

    list1.insert(++list1.begin(),9);// list1(1,9,2,3)

    list1.insert(list1.begin(),2,9);// list1(9,9,1,2,3);

    list1.insert(list1.begin(),list2.begin(),--list2.end());//list1(4,5,1,2,3);

    27.swap()交换两个链表(两个重载)

    list1.swap(list2);// list1(4,5,6)list2(1,2,3)

    28.unique()删除相邻重复元素

    L1(1,1,4,3,5,1)

    L1.unique();// L1(1,4,3,5,1)

    http://www.bcwhy.com/thread-13881-1-1.html

    boolsame_integral_part(doublefirst,doublesecond)

    {return(int(first)==int(second) ); }

    L1.unique(same_integral_part);


    C++代码


    // ------------------------------------------------------------------------- 
    //    文件名        :     list1.cpp
    //    功能描述    :    STL中的list就是一双向链表,可高效地进行插入删除元素。
    //                
    // -------------------------------------------------------------------------
    #include "stdafx.h"
    #include <iostream>
    #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 _tmain(int argc, _TCHAR* argv[])
    {
        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;
    }


  • 分享到:
    评论

    相关推荐

      c++ stl list总结

      c++ stl list总结

      C++ STL list操作

      本文档展示了STL List的基本操作方法,希望对学C++的人有些帮助

      c模拟c++ stl list

      实现c++ list部分功能,内存自管理 函数的使用和c++ stl list类似,并不完全相同 简单测试过,并不保证完全无错,仅供参考

      C++ STL list 遍历删除出错解决方案

      主要介绍了C++ STL list 遍历删除出错解决方案的相关资料,这里对出错进行分析,并给出正确的解决方法,需要的朋友可以参考下

      c++ stl list实现简单的学生信息管理系统

      c++ stl list实现简单的学生信息管理系统

      C++ STL 参考手册Cpp_STL_ReferenceManual.pdf

      STL 是 C++ 标准库的一部分,不用单独安装。 C++ 对模板(Template)支持得很好,STL 就是借助模板把常用的数据结构及其算法都实现了一遍,并且做到了数据结构和算法的分离。例如,vector 的底层为顺序表(数组),...

      [C++][STL] C++ STL 之 List

      NULL 博文链接:https://jacky-dai.iteye.com/blog/692604

      C++ STL 开发技术导引(随书源码)

      第二篇 C++STL泛化技术基础 第4章 C++STL泛型库概述 第5章 C++STL泛化技术分析 第三篇 C++STL容器技术 第7章 deque双端队列容器 第8章 list双向链表容器 第9章 slist单向链表容器 第10章 bit_vector位向量容器 第11...

      C++STL 一些实例

      一些C++STL 用法的实例。如vector list.

      C++ STL 开发技术导引(第6章)

      第二篇 C++ STL泛化技术基础 第4章 C++ STL泛型库概述 48 4.1 C++ STL的发展历程 48 4.2 C++ STL的各种实现版本 49 4.2.1 HP STL 49 4.2.2 SGI STL 50 4.2.3 STLport 50 4.2.4 P.J.Plauger STL 50 ...

      C++STL vector list map set dqueue 等应用举例及PPT讲解示例,代码演示

      C++STL vector list map set dqueue 等应用举例及PPT讲解示例,代码演示

      SGI STL list相关代码

      SGI STL list相关代码

      心希盼 c++ STL Stack(栈)

      心希盼 c++ STL Stack(栈) 包含了用List和Vector来实现的Stack 详细说明请看“心希盼 Stack.doc”

      C++ STL 中文版

      迭代器,utility,iterator,memory,算法,algorithm,numeric,functional,vector,list,deque,set,map,stack,queue逐章介绍

      C++_STL范例大全_教程

      C++_STL范例大全_教程,主要讲STL的容器部分,对初学者有很大的帮助。里面有源码文件。 Vector、 Deque、List、Set等容器。

      C++ STL开发技术导引(第5章)

      第二篇 C++ STL泛化技术基础 第4章 C++ STL泛型库概述 48 4.1 C++ STL的发展历程 48 4.2 C++ STL的各种实现版本 49 4.2.1 HP STL 49 4.2.2 SGI STL 50 4.2.3 STLport 50 4.2.4 P.J.Plauger STL 50 ...

      STL---list 的实现原理中间过程

      stl 的list 的C实现的中间过程,剩下的问题不解释。看不懂,说明不具有了解STL的基础前提!

      C++_STL_示例

      C++ STL_示例word 格式 提供例程 string vector list等数据结构示例 #include #include using namespace std; void main() { //用const char * 构造strText对象 string strText("This is a test"); //在strText...

      C++STL库.pdf

      里面包含vector,map,list,set等用法

      【STL源代码】C++标准库STL源代码下载

      【STL源代码】中包含了许多常用的数据结构(如vector、list、map等)和算法(如排序、查找、遍历等)。通过阅读代码可以仔细研究这些数据结构和算法的实现,了解它们的内部工作原理和使用方式。

    Global site tag (gtag.js) - Google Analytics