list(链表)常用成员(顺序容器)----插入push_back,push_front,insert删除pop_back,pop_front,erase,clear遍历begin,end判空empt

list头文件:

#include <list>

using namespace std;

 

list和vector的不同在于,vector采用的顺序存储,即vector中的元素像数组一样,一个紧挨着一个存放。

所以vector可以进行随机存取。(通常情况下使用vector是最优的选择)。但是每当从vector中删除一个元素或向vector中插入一个元素时,代价都比较高。

而list则不一样。list采用链式存储方法,所以list不能随机存取,但是在list插入和删除元素的代价都非长笑。

 

list的常用接口:


                                                      判空                                 empty

empty
语法:

  bool empty();  

empty()函数返回真(true)如果链表为空,否则返回假。例如:

    list<int> the_list;      for( int i = 0; i < 10; i++ )        the_list.push_back( i );        while( !the_list.empty() ) {        cout << the_list.front() << endl;        the_list.pop_front();      }  

                       获取list中元素的个数             size              
size
语法:
  size_type size();  

size()函数返回list中元素的数量。


                                                      增                    push_back          push_front           insert

        在链表的尾部插入元素:           push_back

push_back
语法:

  void push_back( const TYPE &val );  

push_back()将val连接到链表的最后。例如:

list<int> the_list;
       for( int i = 0; i < 10; i++ ){
             the_list.push_back( i );

}

在链表的首部插入元素:         push_front
push_front
语法:

  void push_front( const TYPE &val );  

push_front()函数将val连接到链表的头部。

在链表的指定位置上插入元素:          insert
insert
语法:

  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 );  

insert()插入元素val到位置pos,或者插入num个元素val到pos之前,或者插入start到end之间的元素到pos的位置。返回值是一个迭代器,指向被插入的元素。


                                                   删                     pop_back            pop_front       erase       clear

        删除链表的最后一个元素,但不返回链表最后一个元素的值:                pop_back

pop_back
语法:

  void pop_back();  

pop_back()函数删除链表的最后一个元素。

删除链表首部的元素,但不返回链表第一个元素的值:                pop_front
pop_front
语法:

  void pop_front();  

pop_front()函数删除链表的第一个元素。

删除链表指定位置上的元素:          erase

erase
语法:

  iterator erase( iterator pos );    iterator erase( iterator start, iterator end );  

erase()函数删除以pos指示位置的元素, 或者删除start和end之间的元素。 返回值是一个迭代器,指向最后一个被删除元素的下一个元素。

删除链表中的所有元素              clear

clear
语法:

  void clear();  

clear()函数删除list的所有元素。


                                               获取链表最后一个元素back    和      第一个元素front

        获取list的最后一个元素,但不删除最后一个元素: 

back
语法:

  reference back();  

back()函数返回一个引用,指向list的最后一个元素。

获取list的第一个元素,但不删除第一个元素:
front
语法:

  reference front();  

front()函数返回一个引用,指向链表的第一个元素。

    list<int> the_list;      for( int i = 0; i < 10; i++ )        the_list.push_back( i );        while( !the_list.empty() ) {        cout << the_list.front() << endl;        the_list.pop_front();      }  


                                                 遍历链表            begin                 end
获取指向list第一个元素的迭代器:

begin
语法:

  iterator begin();  

begin()函数返回一个迭代器,指向list的第一个元素。例如,

    // 创建一个元素类型是字符的链表      list<char> charList;      for( int i=0; i < 10; i++ )        charList.push_front( i + 65 );  
    // 显示这个链表      list<char>::iterator theIterator;      for( theIterator = charList.begin(); theIterator != charList.end(); theIterator++ )        cout << *theIterator;
获取指向list末尾的迭代器:
end 
语法: 
 
 
  iterator end();  

end()函数返回一个迭代器,指向链表的末尾。


                                                         链表合并                merge
merge
语法:

  void merge( list &lst );    void merge( list &lst, Comp compfunction );  

merge()函数把自己和lst链表连接在一起,产生一个整齐排列的组合链表。如果指定compfunction,则将指定函数作为比较的依据。


                                                          将list中的元素逆序                  reverse
reverse
语法:

  void reverse();  

reverse()函数把list所有元素倒转。


                                                           对list中的元素进行排序           sort

排序(sort)
语法:

  void sort();    void sort( Comp compfunction );  

sort()函数为链表排序,默认是升序。如果指定compfunction的话,就采用指定函数来判定两个元素的大小。


                                                          修改链表的长度               resize

 修改链表的大小,多余元素用val填充:     resize

resize
语法:

  void resize( size_type num, TYPE val );  

resize()函数把list的大小改变到num。被加入的多余的元素都被赋值为val


                                                          删除链表中的重复元素                unique
unique
语法:

  void unique();    void unique( BinPred pr );  

unique()函数删除链表中所有重复的元素。如果指定pr,则使用pr来判定是否删除。

 

  • 7
    点赞
  • 31
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
好的,这是一个比较大的项目,需要一定的时间和精力来完成。我可以帮您提供一些思路和代码实现,但是具体的实现和测试还需要您自己完成。以下是一些基本的思路和代码实现: 1. 定义链表节点的数据结构 首先需要定义链表节点的数据结构,包括节点的值、前驱节点和后继节点。这里可以使用模板类来实现支持所有数据类型的数据处理。 ```cpp template <typename T> struct ListNode { T value; ListNode* prev; ListNode* next; ListNode(const T& v): value(v), prev(nullptr), next(nullptr) {} }; ``` 2. 定义 list 类 定义 list 类,包括构造函数、拷贝构造函数、析构函数、判空函数、获取 list 大小函数等基本函数。其中,构造函数需要初始化头节点和尾节点,拷贝构造函数需要实现深拷贝,析构函数需要释放链表中所有节点的内存。 ```cpp template <typename T> class List { public: List(): head(new ListNode<T>(T())), tail(head), length(0) {} List(const List<T>& other); ~List(); bool empty() const; int size() const; void insert(ListNode<T>* node, const T& value); void push_back(const T& value); void pop_back(); void push_front(const T& value); void pop_front(); void erase(ListNode<T>* node); List<T>& operator=(const List<T>& other); private: ListNode<T>* head; ListNode<T>* tail; int length; }; ``` 3. 实现迭代器类 实现迭代器类,包括重载 *、++、--、==、!= 等运算符,以实现元素的遍历。 ```cpp template <typename T> class ListIterator { public: ListIterator(ListNode<T>* node): current(node) {} T& operator*() const { return current->value; } ListIterator& operator++() { current = current->next; return *this; } ListIterator& operator--() { current = current->prev; return *this; } bool operator==(const ListIterator& other) const { return current == other.current; } bool operator!=(const ListIterator& other) const { return current != other.current; } private: ListNode<T>* current; }; ``` 4. 实现 list 类的各种函数 实现 list 类的各种函数,包括从指定位置插入函数、从 list 后面插入删除元素(push_back,pop_back)、从 list 前面插入删除元素(push_front,pop_front)、删除指定位置元素 (erase)等。 ```cpp template <typename T> void List<T>::insert(ListNode<T>* node, const T& value) { ListNode<T>* new_node = new ListNode<T>(value); new_node->prev = node->prev; new_node->next = node; node->prev->next = new_node; node->prev = new_node; ++length; } template <typename T> void List<T>::push_back(const T& value) { insert(tail, value); } template <typename T> void List<T>::pop_back() { if (tail != head) { ListNode<T>* node = tail; tail = node->prev; tail->next = nullptr; delete node; --length; } } template <typename T> void List<T>::push_front(const T& value) { insert(head->next, value); } template <typename T> void List<T>::pop_front() { if (head->next != tail) { ListNode<T>* node = head->next; head->next = node->next; node->next->prev = head; delete node; --length; } } template <typename T> void List<T>::erase(ListNode<T>* node) { if (node != head && node != tail) { node->prev->next = node->next; node->next->prev = node->prev; delete node; --length; } } template <typename T> bool List<T>::empty() const { return length == 0; } template <typename T> int List<T>::size() const { return length; } ``` 5. 实现 list 类的排序函数和交换函数 可以选做 list 类的排序函数和交换函数。排序函数可以使用快速排序、归并排序等算法实现,交换函数可以交换两个节点的值。 6. 编写测试代码 编写测试代码,验证设计的正确性。可以测试 list 类的各种函数、迭代器的使用、排序函数和交换函数的正确性等。 这是一个比较大的项目,需要一定的时间和精力来完成。如果您需要更详细的代码实现或者有其他问题,可以告诉我。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值