C++_STL

文章目录


12.STL容器
一、 String
1.构造函数
string();
string( size_type length, char ch );
string( const char *str );
string( const char *str, size_type length );
string( string &str, size_type index, size_type length );
string( input_iterator start, input_iterator end );

字符串的构造函数创建一个新字符串,包括:
• 以length为长度的ch的拷贝(即length个ch);
• 以str为初值 (长度任意);
• 以index为索引开始的子串,长度为length, 或者
• 以从start到end的元素为初值.
例如,

string str1( 5, 'c' );
string str2( "Now is the time..." );
string str3( str2, 11, 4 );

可以用 ==, >, <, >=, <=, and !=比较字符串. 可以用 + 或者 += 操作符连接两个字符串, 并且可以用[]获取特定的字符.
函数用法

  1. 赋值(assign)
    语法:
    basic_string &assign( const basic_string &str );
    basic_string &assign( const char *str );
    basic_string &assign( const char *str, size_type num );
    basic_string &assign(const basic_string &str, size_type index, size_type len );
    basic_string &assign( size_type num, char ch );
    函数以下列方式赋值:
    •用str为字符串赋值;
    •用str的开始num个字符为字符串赋值;
    •用str的子串为字符串赋值,子串以index索引开始,长度为len。
    •用num个字符ch为字符串赋值.
    例如以下代码:

    string str1, str2 = “War and Peace”;
    str1.assign( str2, 4, 3 );
    2.push_back(char _CH): 向字符串尾部插入字符
    3.添加文本(append)
    语法:
    basic_string &append( const basic_string &str );
    basic_string &append( const char *str );
    basic_string &append( const basic_string &str, size_type index, size_type len );
    basic_string &append( const char *str, size_type num );
    basic_string &append( size_type num, char ch );
    basic_string &append( input_iterator start, input_iterator end );

append() 函数可以完成以下工作:
在字符串的末尾添加str,
在字符串的末尾添加str的子串,子串以index索引开始,长度为len;
在字符串的末尾添加str中的num个字符,
在字符串的末尾添加以迭代器start和end表示的字符序列.
例:str1.append(str2);
对字符串元素的访问[],at()
at([])
语法:
reference at( size_type index );
①我们可以使用下标操作符[]和函数at()对元素包含的字符进行访问。但是应该注意的是操作符[]并不检查索引是否有效(有效索引0~str.length()),如果索引失效,会引起未定义的行为。而at()会检查,如果使用at()的时候索引无效,会抛出out_of_range异常。
比如下列代码:
string text = “ABCDEF”;
char ch = text.at( 2 );
显示字符 ‘C’.
迭代器的使用
1.iterator begin() :函数返回一个迭代器,得到指向字符串开头的iterator。(第一个元素)
2.Iterator end(): 函数返回一个迭代器,得到指向字符串结尾的iterator。(不是最后一个元素,不可访问)
3.Iterator rbegin() :函数返回一个迭代器,得到指向反向字符串开头的iterator。(最后一个元素。)
4.Iterator rend(): 函数返回一个迭代器,得到指向反向字符串结尾的iterator。(不是第一个元素,不可访问)
string的比较:
bool operator==(const string &s1,const string &s2)const;//比较两个字符串是否相等
运算符">","<",">=","<=","!="均被重载用于字符串的比较;
int compare(const string &s) const;//比较当前字符串和s的大小
int compare(int pos, int n,const string &s)const;//比较当前字符串从pos开始的n个字符组成的字符串与s的大小
int compare(int pos, int n,const string &s,int pos2,int n2)const;//比较当前字符串从pos开始的n个字符组成的字符串与s中pos2开始的n2个字符组成的字符串的大小
int compare(const char *s) const;
int compare(int pos, int n,const char *s) const;
int compare(int pos, int n,const char *s, int pos2) const;
compare函数在>时返回1,<时返回-1,==时返回0
string的子串:
string substr(int pos = 0,int n = npos) const;//返回pos开始的n个字符组成的字符串
1.size_t size(): 得到字符串大小。(length()功能一样)
2.c_str(): 函数返回一个指向正规C字符串的指针, 内容与本字符串相同。
1.bool empty(): 判断字符串是否为空。(空为真,不为空为0)
2.clear(): 清空字符容器中所有内容。
3.erase():
①basic_string & erase(size_type pos=0, size_type n=npos);
即从给定起始位置pos处开始删除, 要删除字符的长度为n, 返回值修改后的string对象引用.
②iterator erase(const_iterator position)
删除迭代器位置处的单个字符, 并返回下个元素的迭代器

③iterator erase(const_iterator first, const_iterator last)
删除迭代器[first, last)区间的所有字符,返回一个指向被删除的最后一个元素的下一个字.
插入字符 insert()
语法:
string &insert(int p0, const char *s);
string &insert(int p0, const char *s, int n);
string &insert(int p0,const string &s);
string &insert(int p0,const string &s, int pos, int n);
//前4个函数在p0位置插入字符串s中pos开始的前n个字符
string &insert(int p0, int n, char c);//此函数在p0处插入n个字符c
iterator insert(iterator it, char c);//在it处插入字符c,返回插入后迭代器的位置
void insert(iterator it, const_iterator first, const_iterator last);//在it处插入[first,last)之间的字符
void insert(iterator it, int n, char c);//在it处插入n个字符c
替换字符 replace()
string &replace(int p0, int n0,const char *s);//删除从p0开始的n0个字符,然后在p0处插入串s
string &replace(int p0, int n0,const char *s, int n);//删除p0开始的n0个字符,然后在p0处插入字符串s的前n个字符
string &replace(int p0, int n0,const string &s);//删除从p0开始的n0个字符,然后在p0处插入串s
string &replace(int p0, int n0,const string &s, int pos, int n);//删除p0开始的n0个字符,然后在p0处插入串s中从pos开始的n个字符
string &replace(int p0, int n0,int n, char c);//删除p0开始的n0个字符,然后在p0处插入n个字符c
string &replace(iterator first0, iterator last0,const char *s);//把[first0,last0)之间的部分替换为字符串s
string &replace(iterator first0, iterator last0,const char *s, int n);//把[first0,last0)之间的部分替换为s的前n个字符
string &replace(iterator first0, iterator last0,const string &s);//把[first0,last0)之间的部分替换为串s
string &replace(iterator first0, iterator last0,int n, char c);//把[first0,last0)之间的部分替换为n个字符c
string &replace(iterator first0, iterator last0,const_iterator first, const_iterator last);//把[first0,last0)之间的部分替换成[first,last)之间的字符串
搜索函数 find()
find()函数:
int find(char c, int pos = 0) const;//从pos开始查找字符c在当前字符串的位置
int find(const char *s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
int find(const char *s, int pos, int n) const;//从pos开始查找字符串s中前n个字符在当前串中的位置
int find(const string &s, int pos = 0) const;//从pos开始查找字符串s在当前串中的位置
//查找成功时返回所在位置,失败返回string::npos的值
int rfind(char c, int pos = npos) const;//从pos开始从后向前查找字符c在当前串中的位置
int rfind(const char *s, int pos = npos) const;
int rfind(const char *s, int pos, int n = npos) const;
int rfind(const string &s,int pos = npos) const;
//从pos开始从后向前查找字符串s中前n个字符组成的字符串在当前串中的位置,成功返回所在位置,失败时返回string::npos的值
int find_first_of(char c, int pos = 0) const;//从pos开始查找字符c第一次出现的位置
int find_first_of(const char *s, int pos = 0) const;
int find_first_of(const char *s, int pos, int n) const;
int find_first_of(const string &s,int pos = 0) const;
//从pos开始查找当前串中第一个在s的前n个字符组成的数组里的字符的位置。查找失败返回string::npos
int find_first_not_of(char c, int pos = 0) const;
int find_first_not_of(const char *s, int pos = 0) const;
int find_first_not_of(const char *s, int pos,int n) const;
int find_first_not_of(const string &s,int pos = 0) const;
//从当前串中查找第一个不在串s中的字符出现的位置,失败返回string::npos
int find_last_of(char c, int pos = npos) const;
int find_last_of(const char *s, int pos = npos) const;
int find_last_of(const char *s, int pos, int n = npos) const;
int find_last_of(const string &s,int pos = npos) const;
int find_last_not_of(char c, int pos = npos) const;
int find_last_not_of(const char *s, int pos = npos) const;
int find_last_not_of(const char *s, int pos, int n) const;
int find_last_not_of(const string &s,int pos = npos) const;
//find_last_of和find_last_not_of与find_first_of和find_first_not_of相似,只不过是从后向前查找

提取字符串 substr()
substr
语法:
basic_string substr( size_type index, size_type num = npos );

substr()返回本字符串的一个子串,从index开始,长num个字符。如果没有指定,将是默认值 string::npos。这样,substr()函数将简单的返回从index开始的剩余的字符串。
例如:
string s(“What we have here is a failure to communicate”);

string sub = s.substr(21);

cout << "The original string is " << s << endl;
cout << "The substring is " << sub << endl;

显示:
The original string is What we have here is a failure to communicate
The substring is a failure to communicate
交换(swap)
语法:
void swap( basic_string &str );

swap()函数把str和本字符串交换。例如:
string first( “This comes first” );
string second( “And this is second” );
first.swap( second );
字符串流处理:
通过定义ostringstream和istringstream变量实现,头文件中
例如:
string input(“hello,this is a test”);
istringstream is(input);
string s1,s2,s3,s4;
is>>s1>>s2>>s3>>s4;//s1=“hello,this”,s2=“is”,s3=“a”,s4=“test”
ostringstream os;
os<<s1<<s2<<s3<<s4;
cout<<os.str();

二、vecotr
向量(Vector)是一个封装了动态大小数组的顺序容器(Sequence Container)。跟任意其它类型容器一样,它能够存放各种类型的对象。可以简单的认为,向量是一个能够存放任意类型的动态数组。
1.构造函数
vector():创建一个空vector
vector(int nSize): 创建一个vector,元素个数为nSize
vector(int nSize,const t& t):创建一个vector,元素个数为nSize,且值均为t
vector(const vector&):复制构造函数
vector(begin,end):复制[begin,end)区间内另一个数组的元素到vector中
2.增加函数
void push_back(const T& x): //向量尾部增加一个元素X
iterator insert(iterator it,const T& x)://向量中迭代器指向元素前增加一个元素x
iterator insert(iterator it,int n,const T& x)://向量中迭代器指向元素前增加n个相同的元素x
iterator insert(iterator it,const_iterator first,const_iterator last)://向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据
3.删除函数
iterator erase(iterator it): //删除向量中迭代器指向元素
iterator erase(iterator first,iterator last): //删除向量中[first,last)中元素
void pop_back(): //删除向量中最后一个元素
void clear(): //清空向量中所有元素
4.遍历函数
reference at(int pos): // 返回pos位置元素的引用
reference front(): // 返回首元素的引用
reference back(): //返回尾元素的引用
iterator begin(): //返回向量头迭代器指针,指向第一个元素
iterator end(): //返回向量尾迭代器指针,指向向量最后一个元素的下一个位置
reverse_iterator rbegin():反向迭代器,指向最后一个元素
reverse_iterator rend():反向迭代器,指向第一个元素之前的位置
5.判断函数
bool empty() const:判断向量是否为空,若为空,则向量中无元素
6.大小函数
int size() const:返回向量中元素的个数
int capacity() const:返回当前向量张红所能容纳的最大元素值
int max_size() const:返回最大可允许的vector元素数量值
7.其他函数
void swap(vector&): //交换两个同类型向量的数据
void assign(int n,const T& x): //设置向量中第n个元素的值为x
void assign(const_iterator first,const_iterator last): //向量中[first,last)中元素设置成当前向量元素。

  1. 如果你需要高效的随即存取,而不在乎插入和删除的效率,使用vector;
  2. 如果你需要大量的插入和删除,而不关心随即存取,则应使用list;
  3. 如果你需要随即存取,而且关心两端数据的插入和删除,则应使用deque。
    List
    Lists将元素按顺序储存在链表中. 与 向量(vectors)相比, 它允许快速的插入和删除,但是随机访问却比较慢.
    list的特点:
    不使用连续的内存空间这样可以随意地进行动态操作;
    (2)可以在内部任何位置快速地插入或删除,当然也可以在两端进行push和pop。
    (3)不能进行内部的随机访问,即不支持[ ] 操作符和vector.at() ;
    (4)相对于verctor占用更多的内存。
    2.1 list中的构造函数
    list() 声明一个空列表;
    list(n) 声明一个有n个元素的列表,每个元素都是由其默认构造函数T()构造出来的;
    list(n,val) 声明一个由n个元素的列表,每个元素的值都是val得来的;
    list(first,last) 声明一个列表,其元素的初始值来源于由区间所指定的序列中的元素;
    list list1(10,0); 创建长度为10,每个元素的值都为0;
    2.2 begin()和end():
    通过调用list容器的成员函数begin()得到一个指向容器起始位置的iterator,可以调用list容器的 end() 函数来得到list末端下一位置,相当于:int a[n]中的第n+1个位置a[n],实际上是不存在的,不能访问,经常作为循环结束判断结束条件使用。
    2.3 push_back() 和push_front():
    使用list的成员函数push_back和push_front插入一个元素到list中。其中push_back()从list的末端插入,而 push_front()实现的从list的头部插入。
    2.4 empty():利用empty() 判断list是否为空。
    2.5 clear(): 清空list中的所有元素。
    2.6 resize():
    如果调用resize(n)将list的长度改为只容纳n个元素,超出的元素将被删除,如果需要扩展那么调用默认构造函数T()将元素加到list末端。如果调用resize(n,val),则扩展元素要调用构造函数T(val)函数进行元素构造,其余部分相同。
    2.7 pop_back和pop_front():
    通过pop_back()删除最后一个元素,通过pop_front()删除第一个元素;序列必须不为空,如果当list为空的时候调用pop_back()和pop_front()会使程序崩掉。
    2.8 front()和back():
    通过front()可以获得list容器中的头部元素,通过back()可以获得list容器的最后一个元素。但是有一点要注意,就是list中元素是空的时候,这时候调用front()和back()会发生什么呢?实际上会发生不能正常读取数据的情况,但是这并不报错,那我们编程序时就要注意了,个人觉得在使用之前最好先调用empty()函数判断list是否为空。
    2.9 assign():
    具体和vector中的操作类似,也是有两种情况,第一种是:l1.assign(n,val)将 l1中元素变为n个T(val)。第二种情况是:l1.assign(l2.begin(),l2.end())将l2中的从l2.begin()到l2.end()之间的数值赋值给l1。
    2.10 swap():
    交换两个链表(两个重载),一个是l1.swap(l2); 另外一个是swap(l1,l2),都可能完成连个链表的交换。
    2.11 reverse():通过reverse()完成list的逆置。
    2.12 merge():
    合并两个链表并使之默认升序(也可改),l1.merge(l2,greater()); 调用结束后l2变为空,l1中元素包含原来l1 和 l2中的元素,并且排好序,升序。其实默认是升序,greater()可以省略,另外greater()是可以变的,也可以不按升序排列。
    2.13 insert():在指定位置插入一个或多个元素(三个重载):
    l1.insert(l1.begin(),100); 在l1的开始位置插入100。
    l1.insert(l1.begin(),2,200); 在l1的开始位置插入2个100。
    l1.insert(l1.begin(),l2.begin(),l2.end());在l1的开始位置插入l2的从开始到结束的所有位置的元素。
    2.14 erase():删除一个元素或一个区域的元素(两个重载)
    l1.erase(l1.begin()); 将l1的第一个元素删除。
    l1.erase(l1.begin(),l1.end()); 将l1的从begin()到end()之间的元素删除。

stack:
1.1栈,一个后进先出的容器。
1.2 stack是一种操作受限制的线性表,只能通过top()来访问栈顶元素。
1.3、stack常用函数
1.3.1、push()
push(x):将x入栈,时间复杂度为O(1)
1.3.2、top()
top():获取栈顶元素,时间复杂度为O(1)
1.3.3、pop()
pop():出栈顶元素。
1.3.4、empty()
empty():判断栈是否为空。
1.3.5、size()
size():获得栈元素个数。

Deque(双端队列的操作)
1.构造函数和析构函数
deque c //default构造函数,产生一个空的deque
deque c(c2) //copy构造函数,建立c2的同型deque并成为c2的一份拷贝
deque c(n) //利用default构造函数生成一个大小为n的deque
deque c(n,t) //建立一个大小为n的deque,每个元素值都是t
deque c(beg,end) //建立一个deque,以区间[beg,end)作为元素初值
c.~deque() //销毁所有元素,释放内存
2.非更易型操作
c.empty() //返回容器是否为空
c.size() //返回目前的元素个数
c.max_size() //返回元素个数之最大可能量
c.shrink_to_fit() //要求降低容量,以符合元素个数
c[id] //返回索引id指向的元素,不检查范围
c.at(id) //返回索引id指向的元素,如果超出范围就跑出range-error异常
c.front() //返回第一元素
c.back() //返回最末元素
c.begin() //返回一个迭代器指向第一元素
c.end() //返回一个迭代器指向最末元素的下一位置
c.rbegin() //返回一个反向迭代器指向反向迭代的第一元素
c.rend() //返回一个反向迭代器指向反向迭代的最末元素的下一位置

更易型操作
c=c2 //将c2的全部元素赋给c
c.push_back(elem) //附加一个elem的拷贝于末尾
c.pop_back() //移除最后一个元素,但是不返回它
c.push_front(elem) //在头部插入一个elem的拷贝
c.pop_front() //移除第一个元素,但是不返回它
c.assign(n,elem) //复制n个elem,赋值给c
c.assign(beg,end) //将区间[beg,end)所有元素赋值给c
c.insert(pos,elem) //在iterator位置pos之前方插入一个elem拷贝,并返回新元素的位置
c.insert(pos,n,elem) //在ierator位置pos之前方插入n个elem拷贝,并返回第一个新元素的位置,若没有元素,则返回pos
c.insert(pos,beg,end) //在ierator位置pos之前方插入区间[beg,end)内所有元素的拷贝,并返回第一个新元素的位置,若没有元素,则返回pos
c.erase(pos) //移除iterator位置pos上的元素,返回下一个元素的位置
c.erase(beg,end) //移除区间[beg,end)内的所有元素,返回下一个元素的位置
c.resize(num) //将元素数量改为num,如果size()变大,多出的新元素都要以default函数初始化
c.resize(num,elem) //将元素数量改为num,如果size()变大,多出新元素都是elem的拷贝
c.clear() //移除所有元素,清空容器

deque的操作并不复杂,在以下情形中最好采用deque:
需要在两端安插和移除元素(毕竟双端队列)
无需指向容器内的元素
要求不再使用的元素必须释放
queue 队列是一种容器适配器,专门用来满足先进先出的操作,也就是元素在容器的一端插入并从另一端提取。
1.1、queue的定义
queue name;
queue q;
queue q;
queue q;
queue q;//Node是结构体
1.2、queue容器元素的访问
queue是一种先进先出的限制性数据结构。通过front()访问队首元素,通过back()来访问队尾元素。
1.3、queue常用函数
1.3.1、front(),back()
获取队首,队尾元素,时间复杂度为O(1)
1.3.2、pop()
队首元素出队,时间复杂度为O(1)
1.3.3、empty()
检测queue是否为空,返回bool类型,true为空。
1.3.4、size()
返回queue内元素个数
1.4、queue的用途
当需要实现广度优先搜索的时候,可以使用queue代替。
使用front()和back()的时候,必须判断队列是否为空,empty()。

map
map 是一种有序无重复的关联容器。
关联容器与顺序容器不同,他们的元素是按照关键字来保存和访问的,而顺序元素是按照它们在容器中的位置保存和访问的。
构造函数
  (1) 默认构造: map<Key, value> m;  构造一个空的map,注意,必要时要给出模板参数中的 Compare。需要时给出 Alloc
  (2) 范围构造: map<key, value> m(iterator first, iterator last);  将迭代器[frist, last)范围内的元素填入map中
  (3) 拷贝构造: map<key, value> m(cosnt map& m2);  用m2构造m
  (4) 初始化列表构造: map<key, value> m(initializer_list<value_type> il) //由于map 的 value_type 是 pair类型,所以要构造成pair作为列表,这是三种构造 pair的方式
map<key, value> m{{key k1, value v1},{k2, v2}, …}  // 通过 {}构造 pair
   map<key, value> m{make_pair(key k1, value v1), make_pair(k2, v2), …}  // 通过 make_pair() 函数构造 pair
   map<key, value> m{pair<key, value>(k1, v1), pair<key, value>(k2, v2), …}  // 通过类型转换构造 pair
赋值操作符=
  map& operator= (const map& x)  // map赋值
  map& operator= (map&& x)   
  map& operator= (initializer_list<value_type> il)  // 参数列表赋值
迭代器
  begin, end, rbegin, rend
  cbegin, cend, crbegin, crend
  map 的迭代器支持 ++, – 操作,但是不支持 +i 操作。
  注意 map中是根据 key的值来排列元素的位置的,所以通过迭代器遍历出来的结果顺序,可能和插入值的顺序不同。
  另外对 map的迭代器解引用的结果是得到一个 pair类型的对象。它有两个共有成员 first, second。first保存 key的值,second 保存value的值。
  由于map的 key 是 const的,所以得到的 pair 的first 也是const 的。
成员函数
  容量
    empty()  // 如果map 为空,返回true。否则返回 false
          // bool empty() const noexcept;
    size()    // 返回map 中元素的大小,即 key-value 的个数
          // size_type size() const noexcept;
    max_size()   // 返回由于存储空间的限制,map有可能包含的最大元素数。但不保证一定能达到这个数量,有可能在中途申请空间失败。
             // size_type max_size() const noexcept;
  元素访问
    操作符[]  // m[k] 返回map 中 Key为 k的元素的value的引用。
          // 如果 k不存在,那么将会插入一个 key为 k的元素,并返回其默认 value。
          // []操作总会将 map的大小 +1
          // 注意,对于map,解引用迭代器得到 pair,操作符[]得到 value
    at()    // m.at(k) 返回map中Key为k的元素的value的引用。
          // 如果k不存在,抛一个 out_of_range 异常。
          // 使用 at 不会添加元素,不会增加 map的大小
  修改
    insert 插入
    (1) pair<iterator, bool> insert(const pair<key, value> &val);
     // 单个值插入,参数为 pair类型,first 为 key, second为 value
      // 返回值也是一个 pair,first为插入后的 iterator,second 为bool类型, true表示插入成功,false 表示插入失败
           // 插入失败是因为 map 中已经有一个 key 与输入相同。这次插入操作对map 不会有任何影响, 失败时返回值的 first指向已有的key-value
   (2) iterator insert(const_iterator pos, const pair<key, value> &val);
    // 提示值插入
    // 从 pos 指定的位置开始查找 val应该插入的位置
    // 如果设定值合适,可以减少插入时做查找的时间
   (3) void insert(iterator first, iterator second);
    // 范围插入,插入[first, second)范围内的内容
   (4) void insert(initializer_list<value_type> il);
    // 初始化列表插入
    erase  删除
   (1) iterator erase(const_iterator position);  // 删除迭代器指向的内容, 函数返回 NULL
   (2) iterator erase(const_iterator first, const_iterator last);  // 删除迭代器范围内的内容,函数返回NULL
    (3) size_type erase(const key_type &k);   // 删除 type 为k的元素,返回删除的数目。对于 map,成功删除返回1,k不存在则返回0
   (4) 1,2中如果迭代器无效,会产生 undefined behavior
    swap 交换两个 map对象的内容
    (1) void swap(map &x)
   (2) void swap(map &x1, map &x2)  // 非成员重载函数
 clear  清空一个容器的所有元素
    void clear() noexcept;
操作
find 查找
   在map中查找key 为 k的元素,返回指向它的迭代器。若k不存在,返回 map::end.
   // iterator find(const key_type &k);
   count  计数
   统计map中 key为k的元素的个数,对于map,返回值不是1(存在),就是0(不存在)
   // size_type count(const key_type &k) const;

Set
Set:集合,一个内部自动有序而且不重复元素的容器。
1.1、Set的定义
set name;
set name;
set name;
set name;
set name;//Node是结构体类型
/*
定义和写法和vector基本一样,同样typename可以是任何基本类型,结构体,STL容器类型。
同样,typename是容器的时候,>>后要加空格,避免编译器当成位运算出错。
*/
1.2、set容器内元素的访问
   set只能通过迭代器iterator访问
  因为除了vector和string之外的STL的容器都不支持以下标的方式访问。
set内的元素,自动递增排序,并且去重。
1.3、set常用函数
    1.2.1、insert()函数
    insert(x):将x插入set容器中,并且自动递增排序和去重。时间复杂度为O(logN),N为元素个数
    1.2.2、find()函数
    find(value):查找值为value的元素,返回它的迭代器。时间复杂度为O(logN),N为元素个数
    1.2.3、erase()函数
    erase(x):删除单个元素,时间复杂度为O(logN)
    erase(a,b);删除左闭右开区间内[a,b)的元素,时间复杂度为O(b-a)
    1.2.4、size()函数
    size():用来获得set内元素的个数,时间复杂度为O(1)
    1.2.5、clear()函数
    clear():用来清空set所有元素,时间复杂度为O(N) 
vector和list区别
底层实现的数据结构不同(造成两者差异的本质原因)
Vector:数组实现,拥有一段连续的内存空间,数组中内存空间不够时,会重新申请一块内存空间并进行内存拷贝,重新申请开辟的内存大小是原来的两倍
list是由双向链表实现的,因此内存空间是不连续的。
2,应用场景不同
如果需要高效的随机存在,而不在乎插入和删除的效率,使用vector;如果需要大量的插入和删除,而不关心随机存取,则要使用list
vector和list对于迭代器的支持不同
相同点:迭代器都重载了”++”运算符
不同点:vector 迭代器支持 iter“+”, ”+=“ , ”<"等操作。而list中则不支持

算法:排序
C++STL标准库中包含了algorithm 库
本次主要介绍sort()函数的用法及细节
算法复杂度:O(nlogn),执行效率较高
适用范围分析:首先,关系型容器拥有自动(set、map)排序功能,因为底层采用了RB-Tree(红黑树 ),其次序列式容器(queue)都有特定的出入口,不允许用户对元素排序,剩下的vector、deque适用sort()算法,当然基本的数据类型也可以使用。另外,list类中提供了自己的排序方法。
Sort()的底层实现
1快速排序,2插入排序,3 堆排序

函数原型
Sort(V.begin(),V.end(),[swap]); //[ ]表示缺省值
分析:第一个和第二个参数指定排序的范围,是地址或者迭代器,第三个参数是比较函数的函数名。
注:当第三个参数缺省时默认从小到大排序,如想从大到小排序,无论是否为基本数据类型,都需要自定义比较函数。
重写比较函数的原则:
自定义的比较函数原型为:bool 函数名(类型1 参数1,类型2 参数2);如果返回false,那么就需要调换数据的位置,如果返回true,则不用调换
对基本数据类型排序时举例如下
#include
#include < algorithm >
bool wap(int a,int b);
{
return a > b; //给从大到小排序做准备
}
void main( )
{
vector v{5,1,8,9,6,7};
sort(v.begin(),v.end()); //缺省第三个参数,输出结果 1,5,6,7,8,9
sort(v.begin(),v.end(),wap);//从大到小排序,输出 9,8,7,6,5,1
}
对自定义数据类型的排序时,必然要看情况重写排序函数,排序函数可以是全局函数,也可以是成员函数。
这种情况下包含缺不缺省sort()的第三个参数。
如果缺省第三个函数,那么只能是重载”<”运算符,否则,第三个参数必须给,至于排序顺序,取决于能不实现的方式
bool Student::operator<(StudentLib& other) //类中的运算符重载
{
return this->age > other.age;
}
int main( )
{
vector A;
…省略插值过程…
Sort(A.begin(),A.end()) //排序 由大到小,缺省了第三个参数,因为重载的小于号
//想由小到大排序,重载运算时符return this->age < other.age;即可
}

已标记关键词 清除标记
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页