C++提高笔记(二:容器和常用算法部分)

Posted 自己的无聊笔记本

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了C++提高笔记(二:容器和常用算法部分)相关的知识,希望对你有一定的参考价值。


39、vector容器

功能:

vector数据结构和数组非常相似,也称为单端数组

vector与普通数组区别:

不同之处在于数组是静态空间,而vector可以动态扩展


动态扩展:

(1)并不是在原空间之后续接新空间,而是找更大的内存空间,然后将原数据拷贝新空间,释放原空间。

(2)vector容器的迭代器是支持随机访问的迭代器。


vector<int> v;//创建一个vector容器

v.begin();//指向开始的指针 或者是v.rend();

v.end();//指向末尾的指针 或者是v.begin();


v.insert();//插入


40、vector构造函数

功能描述:创建vector容器

函数原型:

(1)vector<T> v; //采用模板实现类实现,默认构造函数

(2)vector(v.begin(), v.end()); //将v[begin(), end())区间中的元素拷贝给本身。

(3)vector(n, elem); //构造函数将n个elem拷贝给本身。

(4)vector(const vector &vec); //拷贝构造函数。


例子:

void printVector(vector<int> &v1) {//将vector作为函数的形参

for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {

cout << *it << endl;

}

}

void test() {

vector<int> v;

v.push_back(12);

v.push_back(123);

v.push_back(1234);

v.push_back(12345);

vector<int> v2(v.begin(), v.end());

printVector(v2);

printVector(v);


}


41、 vector赋值操作

功能描述:给vector容器进行赋值

函数原型:

(1)vector& operator=(const vector &vec);//重载等号操作符

(2)assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。注意,这里是赋值,不是构造。

(3)assign(n, elem); //将n个elem拷贝赋值给本身。


总结: vector赋值方式比较简单,使用operator=,或者assign都可以


42、vector容量和大小

功能描述:对vector容器的容量和大小操作

函数原型:

(1)empty(); //判断容器是否为空

(2)capacity(); //容器的容量

(3)size(); //返回容器中元素的个数, 注:容量一般是大于等于大小的。

(4)resize(int num); //重新指定容器的长度为num,若容器变长,则以默认值0填充新位置。 //如果容器变短,则末尾超出容器长度的元素被删除。


(5)resize(int num, elem); //重新指定容器的长度为num,若容器变长,则以elem值填充新位置。

//如果容器变短,则末尾超出容器长度的元素被删除


总结:

判断是否为空 — empty

返回元素个数 — size

返回容器容量 — capacity

重新指定大小 — resize


42、vector插入和删除

功能描述:对vector容器进行插入、删除操作

函数原型:

push_back(ele); //尾部插入元素ele

pop_back(); //删除最后一个元素

insert(const_iterator pos, ele); //迭代器指向位置pos插入元素ele,注意是迭代器

insert(const_iterator pos, int count, ele);//迭代器指向位置pos插入count个元素ele

erase(const_iterator pos); //删除迭代器指向的元素

erase(const_iterator start, const_iterator end);//删除迭代器从start到end之间的元素

clear(); //删除容器中所有元素


例子:

void printVector(vector<int> &v1) {

for (vector<int>::iterator it = v1.begin(); it != v1.end(); it++) {

cout << *it<<"  ";

}

cout << endl;

}


void test() {

vector<int> v1;

v1.push_back(10);//尾插法

v1.push_back(20);

printVector(v1);

v1.pop_back();//尾删

printVector(v1);

v1.push_back(20);

v1.push_back(30);

v1.insert(v1.begin() + 1, 1000);//插入

printVector(v1);

v1.erase(v1.begin() + 1);//删除迭代器的位置,注意是迭代器

printVector(v1);

v1.erase(v1.begin(), v1.end());//删除所有的元素,等价于 v1.clear()

printVector(v1);

}


总结:

尾插 — push_back

尾删 — pop_back

插入 — insert (位置迭代器)

删除 — erase (位置迭代器)

清空 — clear


43、vector数据存取

功能描述:对vector中的数据的存取操作

函数原型:

at(int idx); //返回索引idx所指的数据

operator[]; //返回索引idx所指的数据

front(); //返回容器中第一个数据元素

back(); //返回容器中最后一个数据元素


总结:

除了用迭代器获取vector容器中元素,[ ]和at也可以

front返回容器第一个元素

back返回容器最后一个元素


44、vector互换容器

功能描述:实现两个容器内元素进行互换

函数原型:

swap(vec); // 将vec与本身的元素互换


实际用途:swap可以使两个容器互换,可以达到实用的收缩内存效果


例子:

vector<int> v1;

for (int i = 0; i < 100000;i++) {

v1.push_back(i+1);

}

cout << v1.capacity() << " "<< v1.size() << endl;

v1.resize(3);//容量不会变,但是size会变为3

cout << v1.capacity() << " " << v1.size() << endl;

//巧用swap

vector<int>(v1).swap(v1);//容量和大小都会变,注释:vector<int>(v)表示匿名对象,使用v来初始化匿名对象(拷贝函数),再使用swap交换

cout << v1.capacity() << " " << v1.size() << endl;


45、vector预留空间

功能描述:减少vector在动态扩展容量时的扩展次数

函数原型:

reserve(int len);//容器预留len个元素长度,预留位置不初始化,元素不可访问。


例子:

vector<int> v;

v.reserve(10000);//预留空间

int* p = NULL;

int num = 0;//统计开辟次数

for (int i = 0; i < 10000;i++) {

v.push_back(i);

if (p != &v[0]) {

p = &v[0];

num += 1;

}

}

cout << num << endl;//30次, reserve 之后就变为了1


总结:如果数据量较大,可以一开始利用reserve预留空间


46、deque容器(deque:双端容器)

deque容器基本概念

功能:

双端数组,可以对头端进行插入删除操作

deque与vector区别:

vector对于头部的插入删除效率低,数据量越大,效率越低

deque相对而言,对头部的插入删除速度回比vector快

vector访问元素时的速度会比deque快,这和两者内部实现有关

eque内部工作原理:

deque内部有个中控器,维护每段缓冲区中的内容,缓冲区中存放真实数据

deque容器的迭代器也是支持随机访问的


47、deque构造函数

功能描述:deque容器构造

函数原型:

deque<T> deqT; //默认构造形式

deque(beg, end); //构造函数将[beg, end)区间中的元素拷贝给本身。

deque(n, elem); //构造函数将n个elem拷贝给本身。

deque(const deque &deq); //拷贝构造函数


例子:

void printDeque(const deque<int> &v1) {// 添加const 容器变为只读状态

for (deque<int>::const_iterator it = v1.begin(); it != v1.end(); it++) {//需要将iterator变为const_iterator

//*it = 100;//容器里的内容就不可以修改了

cout << *it<<"  ";

}

cout << endl;

}


void test() {

deque<int> d;

for (int i = 0; i < 10; i++) {

d.push_back(i+1);

}

printDeque(d);

}


总结:deque容器和vector容器的构造方式几乎一致,灵活使用即可


48、deque赋值操作

功能描述:给deque容器进行赋值

函数原型:

deque& operator=(const deque &deq); //重载等号操作符

assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。

assign(n, elem); //将n个elem拷贝赋值给本身。


总结:deque赋值操作也与vector相同,需熟练掌握


49、deque大小操作

功能描述:对deque容器的大小进行操作

函数原型:

deque.empty(); //判断容器是否为空

deque.size(); //返回容器中元素的个数

deque.resize(num); //重新指定容器的长度为num,若容器变长,则以默认值填充新位置。

//如果容器变短,则末尾超出容器长度的元素被删除。

deque.resize(num, elem); //重新指定容器的长度为num,若容器变长,则以elem值填充新位置。如果容器变短,则末尾超出容器长度的元素被删除。

注意:deque没有容量的概念,因为它的容量可以变化


50、deque 插入和删除

功能描述:向deque容器中插入和删除数据

函数原型:

两端插入操作:

push_back(elem); //在容器尾部添加一个数据

push_front(elem); //在容器头部插入一个数据

pop_back(); //删除容器最后一个数据

pop_front(); //删除容器第一个数据

指定位置操作:

insert(pos,elem); //在pos位置插入一个elem元素的拷贝,返回新数据的位置。

insert(pos,n,elem); //在pos位置插入n个elem数据,无返回值。

insert(pos,beg,end); //在pos位置插入[beg,end)区间的数据,无返回值。

clear(); //清空容器的所有数据

erase(beg,end); //删除[beg,end)区间的数据,返回下一个数据的位置。

erase(pos); //删除pos位置的数据,返回下一个数据的位置。


总结:

插入和删除提供的位置是迭代器!

尾插 — push_back

尾删 — pop_back

头插 — push_front

头删 — pop_front


51、deque 数据存取

功能描述:对deque 中的数据的存取操作

函数原型:

at(int idx); //返回索引idx所指的数据

operator[]; //返回索引idx所指的数据

front(); //返回容器中第一个数据元素

back(); //返回容器中最后一个数据元素


52、deque 排序(需要添加头文件 # include<a;gorithms>)

功能描述:利用算法实现对deque容器进行排序(默认升序)

算法:

sort(iterator beg, iterator end) //对beg和end区间内元素进行排序


53、stack容器(符合先进后出的数据结构)

概念:stack是一种先进后出(First In Last Out,FILO)的数据结构,它只有一个出口

栈中只有顶端的元素才可以被外界使用,因此栈不允许有遍历行为


栈中进入数据称为 — 入栈 push

栈中弹出数据称为 — 出栈 pop


54、stack 常用接口

功能描述:栈容器常用的对外接口

构造函数:

stack<T> stk; //stack采用模板类实现, stack对象的默认构造形式

stack(const stack &stk); //拷贝构造函数

赋值操作:


stack& operator=(const stack &stk); //重载等号操作符

数据存取:


push(elem); //向栈顶添加元素

pop(); //从栈顶移除第一个元素

top(); //返回栈顶元素

大小操作:


empty(); //判断堆栈是否为空

size(); //返回栈的大小



55、queue 基本概念

概念:Queue是一种先进先出(First In First Out,FIFO)的数据结构,它有两个出口


队列容器允许从一端新增元素,从另一端移除元素


队列中只有队头和队尾才可以被外界使用,因此队列不允许有遍历行为


队列中进数据称为 — 入队 push


队列中出数据称为 — 出队 pop


56、常用接口:

功能描述:栈容器常用的对外接口

构造函数:


queue<T> que; //queue采用模板类实现,queue对象的默认构造形式

queue(const queue &que); //拷贝构造函数

赋值操作:


queue& operator=(const queue &que); //重载等号操作符

数据存取:


push(elem); //往队尾添加元素

pop(); //从队头移除第一个元素

back(); //返回最后一个元素

front(); //返回第一个元素

大小操作:


empty(); //判断堆栈是否为空

size(); //返回栈的大小


注意:只有队头和队尾才能被外界访问,所以不许允遍历行为。



总结:


入队 — push

出队 — pop

返回队头元素 — front

返回队尾元素 — back

判断队是否为空 — empty

返回队列大小 — size



57、list基本概念

功能:将数据进行链式存储

链表(list)是一种物理存储单元上非连续的存储结构,数据元素的逻辑顺序是通过链表中的指针链接实现的

链表的组成:链表由一系列结点组


STL中的链表是一个双向循环链表

双向:每一个节点既记录了上一个节点的信息,又记录了下一个节点的信息。

循环:最后一个节点记录的是第一个节点的位置。

由于链表的存储方式并不是连续的内存空间,因此链表list中的迭代器只支持前移和后移,属于*双向迭代器*


list的优点:

采用动态存储分配,不会造成内存浪费和溢出

链表执行插入和删除操作十分方便,修改指针即可,不需要移动大量元素


list的缺点:

链表灵活,但是空间(指针域) 和 时间(遍历)额外耗费较大

List有一个重要的性质,插入操作和删除操作都不会造成原有list迭代器的失效,这在vector是不成立的。


总结:STL中List和vector是两个最常被使用的容器,各有优缺点


58、list构造函数

功能描述:创建list容器

函数原型:

list<T> lst; //list采用采用模板类实现,对象的默认构造形式:

list(beg,end); //构造函数将[beg, end)区间中的元素拷贝给本身。

list(n,elem); //构造函数将n个elem拷贝给本身。

list(const list &lst); //拷贝构造函数。


59、list 赋值和交换

功能描述:给list容器进行赋值,以及交换list容器

函数原型:


assign(beg, end); //将[beg, end)区间中的数据拷贝赋值给本身。

assign(n, elem); //将n个elem拷贝赋值给本身。

list& operator=(const list &lst); //重载等号操作符

swap(lst); //将lst与本身的元素互换。


60、list 大小操作

功能描述:对list容器的大小进行操作

函数原型:


size(); //返回容器中元素的个数

empty(); //判断容器是否为空

resize(num); //重新指定容器的长度为num,若容器变长,则以默认值填充新位置。

//如果容器变短,则末尾超出容器长度的元素被删除。

resize(num, elem); //重新指定容器的长度为num,若容器变长,则以elem值填充新位置。


**************************************这里需要熟练*************************************


61、list 插入和删除

功能描述:对list容器进行数据的插入和删除

函数原型:


push_back(elem);//在容器尾部加入一个元素

pop_back();//删除容器中最后一个元素

push_front(elem);//在容器开头插入一个元素

pop_front();//从容器开头移除第一个元素

insert(pos,elem);//在pos位置插elem元素的拷贝,返回新数据的位置。

insert(pos,n,elem);//在pos位置插入n个elem数据,无返回值。

insert(pos,beg,end);//在pos位置插入[beg,end)区间的数据,无返回值。

clear();//移除容器的所有数据

erase(beg,end);//删除[beg,end)区间的数据,返回下一个数据的位置。

erase(pos);//删除pos位置的数据,返回下一个数据的位置。

remove(elem);//删除容器中所有与elem值匹配的元素。


62、list 数据存取

功能描述:对list容器中数据进行存取

函数原型:


front(); //返回第一个元素。

back(); //返回最后一个元素。


总结:

list容器中不可以通过[ ]或者at方式访问数据(list的迭代器不支持随机访问 && 是list不是连续的空间)

返回第一个元素 — front

返回最后一个元素 — back


63、list 反转和排序

功能描述:将容器中的元素反转,以及将容器中的数据进行排序

函数原型:

reverse(); //反转链表

sort(); //链表排序,默认的排序规则是从小到大。

如果想从大到小的话,需要写一个函数:

bool myCompare(int v1, int v2) {

//降序,就让v1>v2, 就return v1>v2

return v1 > v2;


}

L.sort(myCompare);

得到的结果就是降序的!



注意:不支持随机访问的容器,不能用标准的algorithm,(比如list就不可以)。但是不支持          随机访问的容器内部会提供对应的一些算法。


例子:

bool comparePerson(Person &p1, Person &p2) {

//按照年龄升序

if (p1.m_Age == p2.m_Age) {// 添加排序规则

return p1.m_H < p2.m_H;

}

return p1.m_Age < p2.m_Age;

}


void test() {

list<Person> L;//创建一个容器

Person p1("刘备", 35, 175);// name, age, height

Person p2("曹操", 45, 180);

Person p3("孙权", 40, 170);

Person p4("赵云", 25, 190);

Person p5("张飞", 35, 160);

Person p6("关羽", 35, 200);

L.push_back(p1);

L.push_back(p2);

L.push_back(p3);

L.push_back(p4);

L.push_back(p5);

L.push_back(p6);

printList(L);

//排序

cout << "------------------after sort---------------------" << endl;

//必须要有一个排序规则(回调函数)

L.sort(comparePerson);

printList(L);

}

         

总结:

对于自定义数据类型,必须要指定排序规则,否则编译器不知道如何进行排序

高级排序只是在排序规则上再进行一次逻辑规则制定,并不复杂


64、set/ multiset 容器

3.8.1 set基本概念

简介:所有元素都会在插入时自动被排序

本质:

set/multiset属于关联式容器,底层结构是用二叉树实现。

set和multiset区别:

set不允许容器中有重复的元素

multiset允许容器中有重复的元素


65、set构造和赋值

功能描述:创建set容器以及赋值

构造:

set<T> st; //默认构造函数:

set(const set &st); //拷贝构造函数

赋值:

set& operator=(const set &st); //重载等号操作符

例子:

void printSet(const set<int>& s) {

for (set<int>::const_iterator it = s.begin(); it != s.end(); it++) {

cout << *it<<" ";

}

cout << endl;

}


void test() {

set<int> s;

s.insert(10);//只有insert的方式

s.insert(20);

s.insert(40);

s.insert(30);

s.insert(2);

printSet(s);

}


set特点:所有元素在插入的时候自动被排序,不允许插入重复值(会自动被删除)



66、set大小和交换(因为不允许有重复的值,所以不能重新指定大小)

功能描述:统计set容器大小以及交换set容器

函数原型:


size(); //返回容器中元素的数目

empty(); //判断容器是否为空

swap(st); //交换两个集合容器


67、set插入和删除

功能描述:set容器进行插入数据和删除数据

函数原型:


insert(elem); //在容器中插入元素。

clear(); //清除所有元素

erase(pos); //删除pos迭代器所指的元素,返回下一个元素的迭代器。

erase(beg, end); //删除区间[beg,end)的所有元素 ,返回下一个元素的迭代器。

erase(elem); //删除容器中值为elem的元素。


68、set查找和统计

功能描述:对set容器进行查找数据以及统计数据

函数原型:

find(key); //查找key是否存在,若存在,返回该键的元素的迭代器;若不存在,返回set.end();

count(key); //统计key的元素个数


69、set和multiset区别

学习目标:掌握set和multiset的区别

区别:

set不可以插入重复数据,而multiset可以

set插入数据的同时会返回插入结果,表示插入是否成功

注意:通过对组pair<set<int>::iterator , bool> ret = s.insert();来检查是否插入成功

multiset不会检测数据,因此可以插入重复数据


70、pair对组创建

功能描述:成对出现的数据,利用对组可以返回两个数据

两种创建方式:

pair<type, type> p ( value1, value2 );

pair<type, type> p = make_pair( value1, value2 );


例子:

void test() {

pair<string, int> p("Tom", 32);

cout << "Name " << p.first << endl;

cout << "Age " << p.second << endl;

pair<string, int> p1 = make_pair("Jerry", 64);

cout << "Name " << p1.first << endl;

cout << "Age " << p1.second << endl;

}


71、set容器排序

学习目标:set容器默认排序规则为从小到大,掌握如何改变排序规则

主要技术点:

利用仿函数,可以改变排序规则

仿函数:重载了函数调用符() 比如bool operator()(int v1, int v2){};

注意:VS2019在重载()的时候需要在前面加const,否则会报错。



 一  set存放内置数据类型:

class MyCompare {//这是仿函数,本质上是类

public:

    bool operator()(int v1,int v2)const { // 也不能使用引用类型调用,加const变为常函数

return v1 > v2;

}

};



void printSet(const set<int, MyCompare>& s) {

for (set<int,MyCompare>::const_iterator it = s.begin(); it != s.end(); it++) {

cout << *it << " ";

}

cout << endl;

}

void test() {

set<int, MyCompare> s1 = {10,20,30,50,40};

printSet(s1);

}



二  set存放自定义数据类型:

class MyCompare {//这是仿函数,本质上是类

public:

    bool operator()(Person v1,Person v2)const { // 也不能使用引用类型调用,加const变为常函数

return v1.m_Age > v2.m_Age;

}

};


void printSet(const set<Person, MyCompare>& s) {

for (set<Person,MyCompare>::const_iterator it = s.begin(); it != s.end(); it++) {

cout << (*it).m_Name << " " << (*it).m_Age << ". " << endl;;

}

}

void test() {

Person p1("刘备", 24);

Person p2("张飞", 254);

Person p3("关羽", 42);

Person p4("赵云", 12);

set<Person, MyCompare> s = { p1,p2,p3,p4 };

printSet(s);


总结:仿函数和直接写cmp函数其实是一样的原理,只是重载了(),而且作用域都是全局。所以在类里面直接写cmp的时候需要添加static关键字,放到静态区。在写仿函数的时候,不可以使用引用调用,具体原因目前还不是很清楚(要用的话,需要在前面再加const,貌似也是对VS2019来说的),另外,在VS2019里面,还需要添加const才可以,比如bool operator()(int v1,int v2)const{} ,否则也会报错。



********************************************************************************

72、map基本概念(高性能、高效率)

简介:

map中所有元素都是pair

pair中第一个元素为key(键值),起到索引作用,第二个元素为value(实值)

所有元素都会根据元素的键值自动排序

本质:

map/multimap属于关联式容器,底层结构是用二叉树实现。

优点:

可以根据key值快速找到value值

map和multimap区别:

map不允许容器中有重复key值元素

multimap允许容器中有重复key值元素


73、 map构造和赋值

功能描述:对map容器进行构造和赋值操作

函数原型:

构造:

map<T1, T2> mp; //map默认构造函数:

map(const map &mp); //拷贝构造函数

赋值:

map& operator=(const map &mp); //重载等号操作符


例子:

map<int, int> m;

m.insert(pair<int, int>(1, 10));//匿名对组

m.insert(pair<int, int>(2, 3230));

m.insert(pair<int, int>(7, 23));

cout << m[7] << endl;//输出7


总结:map中所有元素都是成对出现,插入数据时候要使用对组



74、map大小和交换

功能描述:统计map容器大小以及交换map容器

函数原型:

size(); //返回容器中元素的数目

empty(); //判断容器是否为空

swap(st); //交换两个集合容器


75、map插入和删除

功能描述:map容器进行插入数据和删除数据

函数原型:

insert(elem); //在容器中插入元素。注意,插入的是对组。

clear(); //清除所有元素

erase(pos); //删除pos迭代器所指的元素,返回下一个元素的迭代器。

erase(beg, end); //删除区间[beg,end)的所有元素 ,返回下一个元素的迭代器。

erase(key); //删除容器中值为key的元素。


76、map查找和统计

功能描述:对map容器进行查找数据以及统计数据

函数原型:

find(key); //查找key是否存在,若存在,返回该键的元素的迭代器;若不存在,返回set.end();

count(key); //统计key的元素个数  只是在multimap里面有效,在map里面永远是1.


例子:

map<int, int> m;

m.insert(pair<int, int>(1, 10));//匿名对组

m.insert(pair<int, int>(2, 3230));

m.insert(pair<int, int>(7, 243));

m.insert(pair<int, int>(34, 233));

m.insert(pair<int, int>(5, 253));

m.insert(pair<int, int>(4, 237));

map<int, int>::iterator x = m.find(7);

if (x != m.end()) {

cout << "Find it!" << endl;

}


77、map容器排序

学习目标:map容器默认排序规则为 按照key值进行 从小到大排序,掌握如何改变排序规则

注意,这里的默认指的是不调用sort,直接就是排好了的。

主要技术点:

利用仿函数,可以改变排序规则



*****************************************************************************************

78、函数对象(仿函数)

函数对象概念

概念:

重载函数调用操作符的类,其对象常称为函数对象

函数对象使用重载的()时,行为类似函数调用,也叫仿函数

本质:

函数对象(仿函数)是一个类,不是一个函数


79、函数对象使用

特点:

函数对象在使用时,可以像普通函数那样调用, 可以有参数,可以有返回值

函数对象超出普通函数的概念,函数对象可以有自己的状态

函数对象可以作为参数传递


例子:

class MyAdd {

public:

int operator()(int a, int b) {

return a + b;

}

};

void test() {

MyAdd add;//也是需要先创建对象的,只是在sort里面好像不需要创建对象

int a = 9;

int b = 6;

cout << add(a, b) << endl;

}


总结:仿函数写法非常灵活,可以作为参数进行传递


80、谓词

概念:

返回bool类型的仿函数称为谓词

如果operator()接受一个参数,那么叫做一元谓词

如果operator()接受两个参数,那么叫做二元谓词


例子(一元谓词):

class GF {

public:

bool operator()(int val) {

return val > 5;

}

};


void test() {

vector<int> v;

for (int i = 0; i < 10; i++) {

v.push_back(i + 1);

}

//查找有无大于5的数字

vector<int>::iterator it = find_if(v.begin(),v.end(),GF());//最后传递一个匿名的函数对象

if (it == v.end()) {

cout << "没有找到" << endl;

}

else {

cout << "找到了:" << *it << endl;

}

}


二元谓词(那个cmp里面的比较大小sort的排序规则):


**************************************************************************

81、内建函数对象

概念:STL内建了一些函数对象

分类:

算术仿函数

关系仿函数

逻辑仿函数


用法:

这些仿函数所产生的对象,用法和一般函数完全相同

使用内建函数对象,需要引入头文件 #include<functional>


82、算术仿函数

功能描述:实现四则运算

其中negate是一元运算,其他都是二元运算

仿函数原型:

template<class T> T plus<T> //加法仿函数

template<class T> T minus<T> //减法仿函数

template<class T> T multiplies<T> //乘法仿函数

template<class T> T divides<T> //除法仿函数

template<class T> T modulus<T> //取模仿函数

template<class T> T negate<T> //取反仿函数


例子:

void test() {

negate<int> n;

plus<int> p;

cout << n(50) << endl;

cout << p(10, 20) << endl;

}

总结:使用内建函数对象时,需要引入头文件 #include <functional>


83、关系仿函数

功能描述:实现关系对比

仿函数原型:


template<class T> bool equal_to<T> //等于

template<class T> bool not_equal_to<T> //不等于

template<class T> bool greater<T> //大于

template<class T> bool greater_equal<T> //大于等于

template<class T> bool less<T> //小于

template<class T> bool less_equal<T> //小于等于


例子:

void test() {

vector<int> a = { 9, 12, 32,34,1,2,3 };

cout << endl;

sort(a.begin(), a.end(), greater_equal<int>());

for (vector<int>::iterator it = a.begin(); it != a.end(); it++) {

cout << *it <<"  ";

}

cout << endl;

}

84、逻辑仿函数

功能描述:实现逻辑运算

函数原型:


template<class T> bool logical_and<T> //逻辑与

template<class T> bool logical_or<T> //逻辑或

template<class T> bool logical_not<T> //逻辑非


例子:

void test() {

vector<bool> v;

v.push_back(true);

v.push_back(false);

v.push_back(true);

v.push_back(false);

//利用逻辑非,将容器v搬运到容器v2中,并执行取反操作

vector<bool> v2(v.size());

transform(v.begin(), v.end(), v2.begin(),logical_not<int>());

for (vector<bool>::iterator it = v2.begin(); it != v2.end(); it++) {

cout << *it << " ";

}

cout << endl;

}


85、常用算法

概述:算法主要是由头文件<algorithm> <functional> <numeric>组成。

<algorithm>是所有STL头文件中最大的一个,范围涉及到比较、 交换、查找、遍历操作、复制、修改等等

<numeric>体积很小,只包括几个在序列上面进行简单数学运算的模板函数

<functional>定义了一些模板类,用以声明函数对象。


86、常用遍历算法

学习目标:掌握常用的遍历算法

算法简介:

for_each //遍历容器

transform //搬运容器到另一个容器中


87、for_each

功能描述:实现遍历容器

函数原型:

for_each(iterator beg, iterator end, _func);

// 遍历算法 遍历容器元素

// beg 开始迭代器

// end 结束迭代器

// _func 函数或者函数对象


例子:

class print02 { //仿函数

public:

void operator()(int val) {

cout << val << " ";

}

};

void print(int val) { //普通函数:注意,在类外

cout << val << " ";

}


void test() {

vector<int> v = {1,2,1,323,12,32};

for_each(v.begin(), v.end(),print); // 普通函数

cout << endl;

for_each(v.begin(), v.end(), print02());//仿函数(使用匿名对象)

cout << endl;

}


88、transform

功能描述:搬运容器到另一个容器中

函数原型:

transform(iterator beg1, iterator end1, iterator beg2, _func);

//beg1 源容器开始迭代器

//end1 源容器结束迭代器

//beg2 目标容器开始迭代器

//_func 函数或者函数对象(搬运期间可以进行操作)


89、常用查找算法

学习目标:掌握常用的查找算法

算法简介:

find //查找元素

find_if //按条件查找元素

adjacent_find //查找相邻重复元素

binary_search //二分查找法

count //统计元素个数

count_if //按条件统计元素个数


89、find

功能描述:查找指定元素,找到返回指定元素的迭代器,找不到返回结束迭代器end()

函数原型:

find(iterator beg, iterator end, value);

// 按值查找元素,找到返回指定位置迭代器,找不到返回结束迭代器位置

// beg 开始迭代器

// end 结束迭代器

// value 查找的元素


90、find_if

功能描述:按条件查找元素

函数原型:

find_if(iterator beg, iterator end, _Pred);

// 按值查找元素,找到返回指定位置迭代器,找不到返回结束迭代器位置

// beg 开始迭代器

// end 结束迭代器

// _Pred 函数或者谓词(返回bool类型的仿函数)


注意:可以对自定义类型进行操作。

总结:find_if按条件查找使查找更加灵活,提供的仿函数可以改变不同的策略


91、adjacent_find

功能描述:查找相邻重复元素

函数原型:

adjacent_find(iterator beg, iterator end);

// 查找相邻重复元素,返回相邻元素的第一个位置的迭代器

// beg 开始迭代器

// end 结束迭代器


92、binary_search(二分法查找:非常快,但是必须要是有序数列)

功能描述:查找指定元素是否存在

函数原型:

bool binary_search(iterator beg, iterator end, value);

// 查找指定的元素,查到 返回true 否则false

// 注意: 在无序序列中不可用

// beg 开始迭代器

// end 结束迭代器

// value 查找的元素


93、 count

功能描述:统计元素个数

函数原型:

count(iterator beg, iterator end, value);

// 统计元素出现次数

// beg 开始迭代器

// end 结束迭代器

// value 统计的元素

总结: 统计自定义数据类型时候,需要配合重载 operator==


一个例子:

class Person {

public:

Person(string name, int age) {

m_Name = name;

m_Age = age;


}

bool operator==(const Person &p2) { //重载运算符 == 需要加const 变为只读模式,底层代码需要添加 ,这里说的底层是指后面的count函数。

if (m_Name == p2.m_Name && m_Age == p2.m_Age) {

return true;

}

else {

return false;

}

}

string m_Name;

int m_Age;


};


void test() {

Person p1("Tom", 12);

Person p2("Jerry", 23);

Person p3("Tom", 12);

Person p4("Tom", 12);

vector<Person> v;

v.push_back(p1);

v.push_back(p2);

v.push_back(p3);

v.push_back(p4);

Person s("Tom", 12);

cout << count(v.begin(), v.end(),s) << endl;;

}


94、count_if

功能描述:按条件统计元素个数

函数原型:

count_if(iterator beg, iterator end, _Pred);

// 按条件统计元素出现次数

// beg 开始迭代器

// end 结束迭代器

// _Pred 谓词


************************常用拍排序算法************************************

95、常用排序算法

学习目标:掌握常用的排序算法

算法简介:

sort //对容器内元素进行排序

random_shuffle //洗牌 指定范围内的元素随机调整次序

merge // 容器元素合并,并存储到另一容器中

reverse // 反转指定范围的元素


96、sort

功能描述:对容器内元素进行排序

函数原型:

sort(iterator beg, iterator end, _Pred);

// 按值查找元素,找到返回指定位置迭代器,找不到返回结束迭代器位置

// beg 开始迭代器

// end 结束迭代器

// _Pred 谓词


97、random_shuffle

功能描述:洗牌 指定范围内的元素随机调整次序

函数原型:

random_shuffle(iterator beg, iterator end);

// 指定范围内的元素随机调整次序

// beg 开始迭代器

// end 结束迭代器


例子:

class MyPrint {

public:

void operator()(int val) {

cout << val << " ";

}


};


void test() {

vector<int> v;

for (int i = 0; i < 20; i++) {

v.push_back(i + 1);

}

for_each(v.begin(), v.end(), MyPrint());//输出

cout << endl;

random_shuffle(v.begin(), v.end());//打乱顺序

for_each(v.begin(), v.end(), MyPrint());

cout << endl;


}

**总结:**random_shuffle洗牌算法比较实用,使用时记得加随机数种子

srand((unsigned int)time(NULL))


98、merge

功能描述:个容器元素合并,并存储到另一容器中

函数原型:

merge(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 容器元素合并,并存储到另一容器中

// 注意: 两个容器必须是有序的

// beg1 容器1开始迭代器

// end1 容器1结束迭代器

// beg2 容器2开始迭代器

// end2 容器2结束迭代器

// dest 目标容器开始迭代器


**总结:**merge合并的两个容器必须的有序序列



99、reverse

功能描述:将容器内元素进行反转

函数原型:

reverse(iterator beg, iterator end);

// 反转指定范围的元素

// beg 开始迭代器

// end 结束迭代器

**总结:**reverse反转区间内元素,面试题可能涉及到


100、常用拷贝和替换算法

学习目标:掌握常用的拷贝和替换算法

算法简介:

copy // 容器内指定范围的元素拷贝到另一容器中

replace // 将容器内指定范围的旧元素修改为新元素

replace_if // 容器内指定范围满足条件的元素替换为新元素

swap // 互换两个容器的元素


101、copy

功能描述:容器内指定范围的元素拷贝到另一容器中

函数原型:

copy(iterator beg, iterator end, iterator dest);

// 按值查找元素,找到返回指定位置迭代器,找不到返回结束迭代器位置

// beg 开始迭代器

// end 结束迭代器

// dest 目标起始迭代器


**总结:**利用copy算法在拷贝时,目标容器记得提前开辟空间


102、replace

功能描述:容器内指定范围的旧元素修改为新元素

函数原型:

replace(iterator beg, iterator end, oldvalue, newvalue);

// 将区间内旧元素 替换成 新元素

// beg 开始迭代器

// end 结束迭代器

// oldvalue 旧元素

// newvalue 新元素


103、replace_if

功能描述: 将区间内满足条件的元素,替换成指定元素

函数原型:

replace_if(iterator beg, iterator end, _pred, newvalue);

// 按条件替换元素,满足条件的替换成指定元素

// beg 开始迭代器

// end 结束迭代器

// _pred 谓词

// newvalue 替换的新元素


104、swap

功能描述:互换两个容器的元素

函数原型:

swap(container c1, container c2);

// 互换两个容器的元素

// c1容器1

// c2容器2


**总结:**swap交换容器时,注意交换的容器要同种类型



105、常用算术生成算法

学习目标:掌握常用的算术生成算法

注意:

算术生成算法属于小型算法,使用时包含的头文件为 #include <numeric>

算法简介:

accumulate // 计算容器元素累计总和

fill // 向容器中添加元素


106、accumulate

功能描述:计算区间内 容器元素累计总和

函数原型:

accumulate(iterator beg, iterator end, value);

// 计算容器元素累计总和

// beg 开始迭代器

// end 结束迭代器

// value 起始值  起始的累加值

**总结:**accumulate使用时头文件注意是 numeric,这个算法很实用


107、 fill

功能描述:向容器中填充指定的元素

函数原型:

fill(iterator beg, iterator end, value);

// 向容器中填充元素

// beg 开始迭代器

// end 结束迭代器

// value 填充的值

**总结:**利用fill可以将容器区间内元素填充为 指定的值


108、常用集合算法

学习目标:掌握常用的集合算法

算法简介:

set_intersection // 求两个容器的交集

set_union // 求两个容器的并集

set_difference // 求两个容器的差集


109、set_intersection(交集)

功能描述:求两个容器的交集

函数原型:

set_intersection(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求两个集合的交集

//***** 注意:两个集合必须是有序序列*****


// beg1 容器1开始迭代器

// end1 容器1结束迭代器

// beg2 容器2开始迭代器

// end2 容器2结束迭代器

// dest 目标容器开始迭代器


总结:

求交集的两个集合必须的有序序列

目标容器开辟空间需要从两个容器中取小值

set_intersection返回值既是交集中最后一个元素的位置



110、 set_union(并集)

功能描述:求两个集合的并集

函数原型:

set_union(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求两个集合的并集

// 注意:两个集合必须是有序序列


// beg1 容器1开始迭代器

// end1 容器1结束迭代器

// beg2 容器2开始迭代器

// end2 容器2结束迭代器

// dest 目标容器开始迭代器


总结:


求并集的两个集合必须的有序序列

目标容器开辟空间需要两个容器相加

set_union返回值既是并集中最后一个元素的位置


111、set_difference

功能描述:求两个集合的差集

函数原型:

set_difference(iterator beg1, iterator end1, iterator beg2, iterator end2, iterator dest);

// 求两个集合的差集

// 注意:两个集合必须是有序序列


// beg1 容器1开始迭代器

// end1 容器1结束迭代器

// beg2 容器2开始迭代器

// end2 容器2结束迭代器

// dest 目标容器开始迭代器


总结:


求差集的两个集合必须的有序序列

目标容器开辟空间需要从两个容器取较大值

void test01()

{

vector v1;

for (int i = 0; i < 10; i++) {

v1.push_back(i + 1);

}

vector v2;

v2.resize(v1.size());

copy(v1.begin(), v1.end(), v2.begin());


for_each(v2.begin(), v2.end(), myPrint());

cout << endl;

}


以上是关于C++提高笔记(二:容器和常用算法部分)的主要内容,如果未能解决你的问题,请参考以下文章

c++提高编程 5 STL-常用算法

C++面试笔记--STL模板与容器

C++中STL常用算法

C++--第23课 - STL简介

C++ STL 之 常用算法

C++常用查找算法