STL之List的一些编程练习

最新推荐文章于 2022-03-21 13:36:58 发布
最新推荐文章于 2022-03-21 13:36:58 发布
阅读量621 收藏
点赞数
分类专栏： C++ 文章标签： stl 编程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wytbno/article/details/50890561
版权 
#include<iostream>
#include<list>
#include<vector>
using namespace std;
void print(int i){
	cout<<i<<endl;
}

int main(){
	//reverse()逆序 
	list<int> s;
	for(int i=0;i<5;i++)
	s.push_back(i);
	for_each(s.begin(),s.end(),print);
	cout<<"分界"<<endl; 
	s.reverse();
 	for_each(s.begin(),s.end(),print);
	
return 0;
}
/*
问题：
1、merge（）带参数那种情况？
2、谓词，unique（谓词） 
*/ 
//empty()与vector相同 

/*****一种强大的构造函数：List（开始位置，结束位置）***********
*****************拷贝构造从开始位置的元素到结束位置前一个元素**
***************参数可以是数组的指针、vector的位置、list的位置** 
	int A[]={1,2,3};
	list<int> aList(A,A+2);
	for(list<int>::iterator it=aList.begin();it!=aList.end();it++)
 	cout<<*it<<endl;
	cout<<"分界线"<<endl;
	vector<int> a;
	a.push_back(11);
	a.push_back(22);
	list<int> tlist(a.begin(),a.end());
	for(list<int>::iterator it=tlist.begin();it!=tlist.end();it++)
 	cout<<*it<<endl;
**************************************/ 

/***********其他构造函数***********
	cout<<"分界线"<<endl;
 	list<int> hlist(tlist);
	for(list<int>::iterator it=hlist.begin();it!=hlist.end();it++)
 	cout<<*it<<endl;
 	cout<<"分界线"<<endl;
 	list<int> flist(5,0);
 	cout<<flist.size();
**************************************/ 

/***********resize()函数***********
	list<int> aList;
	aList.resize(10,10);
	for(list<int>::iterator it=aList.begin();it!=aList.end();it++)
	cout<<*it<<endl; 
**************************************/ 

/***********头尾元素的插入、删除、访问***********
	list<int> aList(5,1);
	aList.push_front(0);//在前面插入 
	aList.push_back(0);//在后面插入 
	for(list<int>::iterator it=aList.begin();it!=aList.end();it++)
	cout<<*it<<endl;
	cout<<"分界线:"<<endl;
	cout<<aList.front()<<endl;//返回最前面的元素 
	cout<<aList.back()<<endl;//返回最后一个元素 
	cout<<"分界线:"<<endl;
	aList.pop_front();//删除最前面的元素 
	for(list<int>::iterator it=aList.begin();it!=aList.end();it++)
	cout<<*it<<endl;
	cout<<"分界线:"<<endl;
	aList.pop_back();//删除最后一个元素 
	for(list<int>::iterator it=aList.begin();it!=aList.end();it++)
	cout<<*it<<endl;
**************************************/ 

/***********assign函数完全改变list中内容***********
	list<int> aList(5,1);
	for(list<int>::iterator it=aList.begin();it!=aList.end();it++)	
	cout<<*it<<endl;
	aList.assign(2,5);//assign函数完全改变list中内容 
	cout<<"分界线:"<<endl;
	for(list<int>::iterator it=aList.begin();it!=aList.end();it++)	
	cout<<*it<<endl;
	cout<<"分界线:"<<endl;
	list<int> bList(2,6);
	for(list<int>::iterator it=bList.begin();it!=bList.end();it++)	
	cout<<*it<<endl;
	cout<<"分界线:"<<endl;
 	bList.assign(aList.begin(),aList.end());//相当与拷贝部分或全部 
 	for(list<int>::iterator it=bList.begin();it!=bList.end();it++)	
	cout<<*it<<endl;
	cout<<"分界线:"<<endl;
	//数组 
	int a[]={0,1,2,3};
    bList.assign(a,a+4);
    for(list<int>::iterator it=bList.begin();it!=bList.end();it++)	
	cout<<*it<<endl;
**************************************/ 

/***********swap函数交换两个List的内容***********
	list<int> s;
	for(int i=0;i<5;i++)
	s.push_back(i);
	cout<<"S更改前:"<<endl;
	for_each(s.begin(),s.end(),print);
	list<int> c;
	for(int i=0;i<3;i++)
	c.push_back(3);
	cout<<"C更改前:"<<endl;
	for_each(c.begin(),c.end(),print);
	s.swap(c);
	cout<<"S更改后:"<<endl;
	for_each(s.begin(),s.end(),print);
	cout<<"C更改后:"<<endl;
	for_each(c.begin(),c.end(),print);

**************************************/ 

/***********insert函数与erase函数（可参考vector）***********
	list<int> s;
	for(int i=0;i<5;i++)
 	s.push_front(i);
	for_each(s.begin(),s.end(),print);
	list<int> c;
	for(int i=0;i<4;i++)
	c.push_back(i);
	cout<<"更改后："<<endl; 
	s.insert(s.end(),c.begin(),c.end());
	for_each(s.begin(),s.end(),print);
	cout<<"再度更改："<<endl;
	s.erase(s.begin(),++s.begin());
	//s.begin()+4 出错，因为list随机存储 
	for_each(s.begin(),s.end(),print);

**************************************/ 

/***********list之间的比较***********
	list<int> s;
	for(int i=0;i<5;i++)
 	s.push_front(i);
	for_each(s.begin(),s.end(),print);
	//Wrong
	//cout<<"随机："<<endl;
	//cout<<s[1]; 
	list<int> c;
	for(int i=0;i<5;i++)
 	c.push_front(i);
	//c.push_back(1);
	cout<<(c==s)<<endl;//1
	cout<<(c>=s)<<endl;//1
	cout<<"分割线："<<endl;
	list<int> x;
	for(int i=0;i<4;i++)
 	x.push_front(i+2);
 	x.push_back(-1);
 	cout<<(x>s)<<endl;//1
 	
 	所有相同类型的容器都支持关系操作符来实现两个容器的比较：

	1.如果两个容器具有相同的长度而且所有元素都相等，那么两个两个容器相等；否则，就不相等。

	2.如果两个容器的长度不相同，但较短的容器中所有元素都等于较长容器中对应的元素，则称较短的容器小于另一容器。

	3.如果两个容器都不是对方的初始子序列，则它们的比较结果取决于所比较的第一个不相等的元素。

	如果容器内的元素不支持比较大小，则容器就不能比较大小。
 	
 	cout<<"X:"<<endl;
 	for_each(x.begin(),x.end(),print);
 	cout<<"S:"<<endl;
 	for_each(s.begin(),s.end(),print);

**************************************/ 

/*********** sort 和 merge ***********
	 bool gre(int a,int b){
		return a>b;
	}
	 
	list<int> s;
	for(int i=0;i<5;i++)
	s.push_back(i);
	list<int> c;
	for(int i=0;i<4;i++)
	c.push_back(i);
	//s.merge(c);//默认升序
	s.merge(c,gre);//没有完成降序排序 
	s.sort(gre); 
	for_each(s.begin(),s.end(),print);
	
--------------------------------------------

	list<int> s;
	for(int i=0;i<5;i++)
	s.push_back(i);
	list<int> c;
	for(int i=0;i<4;i++)
	c.push_back(i);
	//s.merge(c);//默认升序
	s.merge(c);//没有完成降序排序 
	s.sort(greater<int>());
	for_each(s.begin(),s.end(),print);
		
**************************************/ 

/*********** remove和 remove_if ***********
	bool v(int i){
		return i%2;
	}
	
	list<int> s;
	for(int i=0;i<10;i++)
	s.push_back(i);
	cout<<"初始:"<<endl;
	for_each(s.begin(),s.end(),print);
	s.remove(1);
	cout<<"第一次："<<endl;
	for_each(s.begin(),s.end(),print);
	s.remove_if(v);
	cout<<"第二次："<<endl;
	for_each(s.begin(),s.end(),print);
		
**************************************/ 

/*********** splice函数,将list c中指定元素（或范围）插入到位置后面***********
***********list  c中会减少相应多元素**********
	list<int> s;
	for(int i=0;i<5;i++)
	s.push_back(i);
	list<int> c;
	for(int i=0;i<5;i++)
	c.push_back(3);
	s.splice(s.end(),c,c.begin(),c.end());
	cout<<c.size()<<endl;
	for_each(s.begin(),s.end(),print);

**************************************/ 

/*********** remove和 remove_if ***********
	bool v(int i){
		return i%2;
	}
	
	list<int> s;
	for(int i=0;i<10;i++)
	s.push_back(i);
	cout<<"初始:"<<endl;
	for_each(s.begin(),s.end(),print);
	s.remove(1);
	cout<<"第一次："<<endl;
	for_each(s.begin(),s.end(),print);
	s.remove_if(v);
	cout<<"第二次："<<endl;
	for_each(s.begin(),s.end(),print);
		
**************************************/ 
	
/*********** unique()：删除相邻相同的与unique(谓词)：删除与第一个不同的 ***********
*********** sort()+unique()删除全部相同的 ***********
	bool v(int i){
		return i==5;
	} 
	
	
	list<int> s;
	list<int> c;
	not_equal_to<int> Pred;
	s.push_back(1);
	s.push_back(1);
	s.push_back(2);
	s.push_back(1);
	for_each(s.begin(),s.end(),print);
	s.unique();
	cout<<"分割"<<endl;
	for_each(s.begin(),s.end(),print); 
	c.push_back(1);
	c.push_back(1);
	c.push_back(2);
	c.push_back(1);
	cout<<"分割"<<endl;
	for_each(c.begin(),c.end(),print);
	c.sort();
	c.unique(Pred); //删除与第一个不同的 
	//c.unique();删除相同的 
	//c.unique(v);//Wrong
	cout<<"分割"<<endl; 
	for_each(c.begin(),c.end(),print);
**************************************/ 

// list::merge
#include <iostream>
#include <list>

// compare only integral part:
bool mycomparison (double first, double second)
{ return ( int(first)<int(second) ); }

int main ()
{
  std::list<double> first, second;

  first.push_back (3.1);
  first.push_back (2.2);
  first.push_back (2.9);

  second.push_back (3.7);
  second.push_back (7.1);
  second.push_back (1.4);

  first.sort();
  second.sort();

  first.merge(second);

  // (second is now empty)

  second.push_back (2.1);

  first.merge(second,mycomparison);

  std::cout << "first contains:";
  for (std::list<double>::iterator it=first.begin(); it!=first.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}

output： 
first contains: 1.4 2.2 2.9 2.1 3.1 3.7 7.1
Notice how in the second merger, the function  mycomparison (which only compares the integral parts) did not consider  2.1lower than  2.2 or  2.9, so it was inserted right after them, before  3.1.

第二个程序是c++的Example

STL list容器由于采用了双向迭代器，不支持随机访问，所以标准库的merge(), sort()等功能函数都不适用，list单独实现了merge()，sort()等函数。

s.merge(c);

c中元素会清空

两个问题：

1、merge（）

为什么我的调用出错,例子调用正确.?

2、谓词是什么？

c.unique(v);//Wrong

为什么这个会出错？


SOLUTION：

1.先附原型：

  template<typename _Tp, typename _Alloc>
    template <typename _BinaryPredicate>
      void
      list<_Tp,_Alloc>::
      unique(_BinaryPredicate __binary_pred)
      {
        iterator __first = begin();
        iterator __last = end();
        if (__first == __last) return;
        iterator __next = __first;
        while (++__next != __last)
        {
          if (__binary_pred(*__first, *__next))
            _M_erase(__next);
          else
            __first = __next;
          __next = __first;
        }
      }

  template<typename _Tp, typename _Alloc>
    template <typename _StrictWeakOrdering>
      void
      list<_Tp,_Alloc>::
      merge(list& __x, _StrictWeakOrdering __comp)
      {
	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	// 300. list::merge() specification incomplete
	if (this != &__x)
	  {
	    iterator __first1 = begin();
	    iterator __last1 = end();
	    iterator __first2 = __x.begin();
	    iterator __last2 = __x.end();
	    while (__first1 != __last1 && __first2 != __last2)
	      if (__comp(*__first2, *__first1))
		{
		  iterator __next = __first2;
		  _M_transfer(__first1, __first2, ++__next);
		  __first2 = __next;
		}
	      else
		++__first1;
	    if (__first2 != __last2)
	      _M_transfer(__last1, __first2, __last2);
	  }
      }

#include<iostream>
#include<list>
#include<vector>
using namespace std;
void print(int i){
	cout<<i<<endl;
}
 bool gre(int a,int b){
	return a>b;
	}
int main(){
	
	 
	list<int> s;
	
	s.push_back(3);
	s.push_back(2);
	s.push_back(1);
	list<int> c;
	
	c.push_back(3);
	c.push_back(2);
	c.push_back(1);
	//s.merge(c);//默认升序
	c.merge(s,gre);//没有完成降序排序 	
 	//c.merge(s,greater<int>());
	for_each(c.begin(),c.end(),print);
	return 0;
}

这个可以了。

// Moves the elements from [first,last) before position.
       void
      _M_transfer(iterator __position, iterator __first, iterator __last)
       { __position._M_node->transfer(__first._M_node, __last._M_node); }
//https://gcc.gnu.org/onlinedocs/libstdc++/libstdc++-html-USERS-4.1/stl__list_8h-source.html


通过看文档，发现出错原因是因为函数本身的定义，具体原因还需要继续看。


StrictWeakOrdering（严格弱排序）的要求：





2.

官方文档例子：

// list::unique
#include <iostream>
#include <cmath>
#include <list>

// a binary predicate implemented as a function:
bool same_integral_part (double first, double second)
{ return ( int(first)==int(second) ); }

// a binary predicate implemented as a class:
struct is_near {
  bool operator() (double first, double second)
  { return (fabs(first-second)<5.0); }
};

int main ()
{
  double mydoubles[]={ 12.15,  2.72, 73.0,  12.77,  3.14,
                       12.77, 73.35, 72.25, 15.3,  72.25 };
  std::list<double> mylist (mydoubles,mydoubles+10);
  
  mylist.sort();             //  2.72,  3.14, 12.15, 12.77, 12.77,
                             // 15.3,  72.25, 72.25, 73.0,  73.35

  mylist.unique();           //  2.72,  3.14, 12.15, 12.77
                             // 15.3,  72.25, 73.0,  73.35

  mylist.unique (same_integral_part);  //  2.72,  3.14, 12.15
                                       // 15.3,  72.25, 73.0

  mylist.unique (is_near());           //  2.72, 12.15, 72.25

  std::cout << "mylist contains:";
  for (std::list<double>::iterator it=mylist.begin(); it!=mylist.end(); ++it)
    std::cout << ' ' << *it;
  std::cout << '\n';

  return 0;
}
函数实现： 

 template<typename _Tp, typename _Alloc>
    template <typename _BinaryPredicate>
      void
      list<_Tp,_Alloc>::
      unique(_BinaryPredicate __binary_pred)
      {
        iterator __first = begin();
        iterator __last = end();
        if (__first == __last) return;
        iterator __next = __first;
        while (++__next != __last)
        {
          if (__binary_pred(*__first, *__next))
            _M_erase(__next);
          else
            __first = __next;
          __next = __first;
        }
      }

看调用：__binary_pred(*__first, *__next)

终于发现了！是两个参数！！

更改后：

#include<iostream>
#include<list>
#include<vector>
using namespace std;
void print(int i){
	cout<<i<<endl;
}
	bool v(int i,int j){
		return i!=j;
	} 
	
int main(){
	list<int> s;
	list<int> c;
	not_equal_to<int> Pred;
	s.push_back(1);
	s.push_back(1);
	s.push_back(2);
	s.push_back(1);
	for_each(s.begin(),s.end(),print);
	s.unique();
	cout<<"分割"<<endl;
	for_each(s.begin(),s.end(),print); 
	c.push_back(1);
	c.push_back(1);
	c.push_back(2);
	c.push_back(1);
	cout<<"分割"<<endl;
	for_each(c.begin(),c.end(),print);
	c.sort();
	//c.unique(Pred); //删除与第一个不同的 
	//c.unique();删除相同的 
	c.unique(v);//Wrong
	cout<<"分割"<<endl; 
	for_each(c.begin(),c.end(),print);
	
	return 0;
}

这样就可以了。

还有：

一个参数的是：Prediate  pred

两个参数是：BinaryPrediate pred


另外附函数解释：

The second version (2), takes as argument a specific comparison function that determine the "uniqueness" of an element. In fact, any behavior can be implemented (and not only an equality comparison), but notice that the function will call binary_pred(*i,*(i-1)) for all pairs of elements (where i is an iterator to an element, starting from the second) and remove i from the list if the predicate returns true.

The elements removed are destroyed.

wytbno
关注
专栏目录
一篇文章全面理解C++STL中的list容器（附实战练习——学生成绩管理系统）
qq_59708493的博客
12-29 2634
list容器实际上就是一个链表，不同于vector容器，list容器是通过指针将数据链式储存起来；链表是由一系列结点组成的，每一个结点由储存数据的数据域和储存下一个数据的地址的指针域组成；
学习笔记 STL实例练习
编程改变世界的小星
06-14 556
学习笔记 STL实例练习 比赛规则： 某市举行一场演讲比赛（ speech_contest ），共有24个人参加。比赛共三轮，前两轮为淘汰赛，第三轮为决赛。 比赛方式：分组比赛，每组6个人；选手每次要随机分组，进行比赛； 第一轮分为4个小组，每组6个人。比如编号为: 100-123. 整体进行抽签（draw）后顺序演讲。当小组演讲完后，淘汰组内排名最后的三个选手，然后继续下一个小组的比赛。 第二轮分为2个小组，每组6人。比赛完毕，淘汰组内排名最后的三个选手，然后继续下一个小组的比赛。 第三轮只剩下1组6个
STL学习之list
工作、生活
01-15 632
标签:STL list STL中list的使用： STL中的list就是一双向链表，可高效地进行插入删除元素。现总结一下它的操作。 文中所用到两个list对象c1,c2分别有元素c1(10,20,30) c2(40,50,60)。还有一个list::iterator citer用来指向c1或c2元素。 list对象的声明构造()： A. listc0; //空链表 B. listc1(
STL练习程序（set...）
weixin_34126215的博客
07-05 778
#include <iostream> #include <string> #include <set> using namespace std; int main() { string name[]={"tian","dsp","sp","ti"}; set<string> setname; fo...
C语言常见的list一些编程练习
m0_37756557的博客
11-14 1791
#include #include #include typedef struct Node {     int data;//数据域     struct Node* pNext;//指针域 }Node,* pNode; pNode create_list(void); void traverse_list(pNode pHead); int is_empty(
[C++][STL] C++ STL 之 List
03-18
**C++ STL 之 List 知识点详解** C++ Standard Template Library（STL）是C++编程中不可或缺的一部分，它提供了一组高效且可重用的...通过实际编程练习，你可以进一步掌握`list`的用法，并将其应用于各种实际问题中。
STL-70个算法.rar_C++_stl 练习
最新发布
09-23
STL提供了一些核心的数据结构，如vector（动态数组）、list（双向链表）、deque（双端队列）、set（红黑树实现的集合）、map（红黑树实现的键值对映射）和unordered_set/unordered_map（哈希表实现的集合和映射）。...
stl练习题之四
03-07
在这个“stl练习题之四”中，我们将深入探讨如何使用STL中的简单容器类，并通过分析`main.cpp`文件来理解递归函数的应用。 首先，STL容器类是C++程序员最常使用的工具之一，它们包括数组（如`std::array`）、顺序...
C++ Primer Plus 编程练习源码工程 第13章
10-26
在C++编程领域，第13章通常会涵盖一些高级主题，可能包括类模板、函数模板、STL容器（如vector、list、set和map）、迭代器以及算法的使用等。这些是C++编程中的核心概念，对于任何想要成为熟练C++程序员的人来说都至...
1.4_学习STL-list_noneb4s_图形学_
10-04
压缩包中的第二个文件“1.4_学习STL-list”很可能包含了更详细的练习和例子，可能涵盖如何利用list处理图形数据结构、优化内存分配、以及在图形算法中应用list等主题。通过这些实例，学习者能够更好地理解STL list的...
CAD AutoList编程
03-07
AutoLISP 开发者指南,AutoCAD支持AutoLISP，但不支持许多Visual LISP functions 或 Microsoft ActiveX Automation interface.
STL编程题1（C++程序设计第8周）
NodYoung
01-04 2366
问题描述下面的程序输出结果是:1 2 6 7 8 9请填空：#include <iostream> #include <iterator> #include <set> using namespace std; int main() { int a[] = {8,7,8,9,6,2,1}; // 在此处补充你的代码 ostream_iterator<int> o(cout,
STL之 - list疯狂练习了一把
roker
01-22 1076
网上曰：我曾用STL写过几个商业程序。它在很多方面减少了我的工作量，也排除了很多逻辑错误。最大的一个程序有大约5000行。可能最惊人的事情就是它的速度。它读入并处理一个1-2兆的报告文件仅花大约20秒。我是在linux上用gcc2.7.2开发的，现在运行在HP-UX机器上。它一共用了大约50和函数对象和很多容器，这些容器的大小从小list到一个有14,000个元素的map都有。一个程序中的
List
weixin_42343552的博客
07-21 3688
1.ArrayList 底层是一个数组，数组查询快，增删慢。 查询时地址连续，有索引，因此查询快。 增删时，由于数组长度不可变，每次都要新建一个数组，并将原数组的数据复制，因此，增删慢。 ArrayList是非同步的，因此执行效率高，但在高并发时容易引起线程安全问题。 2.LinkedList linkedList底层是双向链表链表，因此查询慢，增删快。 链表地址不连续，每次查询都要从头开始，因...
STL之list
迷惘宅猪的专栏
06-23 317
前言list是双向链表容器。当经常从容器的中间插入元素或者删除元素时，非常高效。#include <list>list基础list定义模板 template < class T, class Allocator = allocator< T>>class list T是存储的元素的数据类型；Allocator指定了分配器，默认是标准分配器。list构造函数 explicit list(cons
STL_list应用举例
qq1010234991的博客
06-30 749
#include using namespace std; #include #include int main() { int i; list ilist; cout << "size=" << ilist.size() << endl; //size=0 ilist.push_back(0); ilist.push_back(1); ilist.push_back(2); il
STL之list基本使用实例
CodingStart
03-22 1025
list其实就是双向链表，好好复习list的使用。 Cplusplus描述的list方法： 基本操作实例： void test_list() { list pList; cout << "push_back() , pop_back() ，begin() , end()测试：" << endl; pList.push_back(1); //尾插 pList.
编程常用合集，List集合使用详解掌握啦吗
关注我！带你一路 "狂飙" 到底！
03-21 635
我们知道，List是Java编程中经常使用的集合之一，但List到底有哪些不为人知的地方，List为什么被使用得这么多？今天索尔就为大家分析一下关于List的那点事儿。 List本身其实是一个接口，继承自Collection接口，所以List存储元素的特点是单元素，区别于Map（双元素集合），JDK8为List接口提供了10个实现类，供开发人员使用。 为什么提供那么多的实现类呢？因为在实际开发场景下需要根据业务的不同选择不同的实现类来使用，这就要求大家对实现类的特点都要加以掌握，才能在实际的开发..
STL编程题-集合动态修改
wuchenfengXXX的专栏
05-29 1187
描述 现有一整数集（允许有重复元素），初始为空。我们定义如下操作： add x 把x加入集合 del x 把集合中所有与x相等的元素删除 ask x 对集合中元素x的情况询问 对每种操作，我们要求进行如下输出。 add 输出操作后集合中x的个数 del 输出操作前集合中x的个数 ask 先输出0或1表示x是否曾被加入集合（0表示不曾加入），再输出当前
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值