声明
#include <vector>
using namespace std;
std::vector<double> v;
初始化与赋值
//定义一个空向量
std::vector<int> a;
std::cout << " a: " << a.size() << std::endl;
//定义一个10个元素的向量
std::vector<int> b(10);
std::cout << " b: " << b.size() << std::endl;
//定义一个10个元素的向量， 并附初值
std::vector<int> c(10, 1);
std::cout << " c: " << c.size() << std::endl;
//用向量c来创建向量d，并整体赋值
std::vector<int> d(c);
std::cout << " d: " << d.size() << std::endl;
//用向量c的部分元素来创建向量e
std::vector<int>e(c.begin(), c.begin()+3);
std::cout << " e: " << e.size() << std::endl;
//使用数值获得初值
int nus[4] = {1, 2, 3, 4};
std::vector<int> f(nus, nus+4);
std::cout << " f: " << f.size() << std::endl;
// 使用数组初始化
std::vector<int> h {11, 12, 13, 14, 15};
std::cout << " h: " << h.size() << std::endl;
⚠️采用下标的方式赋初值是错误的，下标只能用于获取已存在的元素
//错误的方法
std::vector<int> g;
for (int i = 0; i < 10; ++i) {
g[i] = i;
}
//下标只能用于获取已存在的元素
插入元素
push_back() 向量尾部增加一个元素
push_back() 向量尾部增加一个元素
std::cout << "---- add element ---- " << std::endl;
std::vector<int> a;
//push_back()
a.push_back(12);
std::cout << " a vector: { ";
for (int i = 0; i < a.size(); ++i) {
std::cout << a[i] << " ";
}
std::cout <<"}" <<std::endl;
insert() 在迭代器前添加元素
insert() 在迭代器前添加元素
insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x
//insert()
//iterator insert(iterator it,const T& x):向量中迭代器指向元素前增加一个元素x
a.insert(a.begin(), 13);
std::cout << " a vector: { ";
for (int i = 0; i < a.size(); ++i) {
std::cout << a[i] << " ";
}
std::cout <<"}" <<std::endl;
iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x
//iterator insert(iterator it,int n,const T& x):向量中迭代器指向元素前增加n个相同的元素x
a.insert(a.begin(), 2, 22);
std::cout << " a vector: { ";
for (int i = 0; i < a.size(); ++i) {
std::cout << a[i] << " ";
}
std::cout <<"}" <<std::endl;
iterator insert(iterator it,const_iterator first,const_iterator last)
:向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据
//iterator insert(iterator it,const_iterator first,const_iterator last)
// :向量中迭代器指向元素前插入另一个相同类型向量的[first,last)间的数据
std::vector<int> b {1, 2, 3};
a.insert(a.begin(), b.begin(), b.end());
std::cout << " a vector: { ";
for (int i = 0; i < a.size(); ++i) {
std::cout << a[i] << " ";
}
std::cout <<"}" <<std::endl;
删除元素
erase() 删除向量中迭代器指向元素
iterator erase(iterator it):删除向量中迭代器指向元素
std::cout << "---- erase element ---- " << std::endl;
std::vector<int> a {1, 2, 3, 4, 5};
// iterator erase(iterator it):删除向量中迭代器指向元素
a.erase(a.begin());
std::cout << " a vector: { ";
for (int i = 0; i < a.size(); ++i) {
std::cout << a[i] << " ";
}
std::cout <<"}" <<std::endl;
iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
// iterator erase(iterator first,iterator last):删除向量中[first,last)中元素
a.erase(a.begin(), a.begin()+2);
std::cout << " a vector: { ";
for (int i = 0; i < a.size(); ++i) {
std::cout << a[i] << " ";
}
std::cout <<"}" <<std::endl;
pop_back() 删除向量中最后一个元素
pop_back() 删除向量中最后一个元素
// pop_back():删除向量中最后一个元素
a.pop_back();
std::cout << " a vector: { ";
for (int i = 0; i < a.size(); ++i) {
std::cout << a[i] << " ";
}
std::cout <<"}" <<std::endl;
clear() 清空向量中所有元素
clear():清空向量中所有元素
//clear():清空向量中所有元素
a.clear();
std::cout << " a size: " << a.size() << std::endl;
获取某一元素
at() 返回pos位置元素的引用
at(int pos):返回pos位置元素的引用
std::cout << "---- get element ---- " << std::endl;
std::vector<int> v {11, 21, 31, 41};
//at(int pos):返回pos位置元素的引用
std::cout <<" v at 1: " << v.at(1) << std::endl;
下标
//下标
std::cout <<" v [1] : " << v[1] << std::endl;
front() 返回首元素的引用
front():返回首元素的引用
//front():返回首元素的引用
std::cout << " v front() 0 : " << v.front() << std::endl;
back() 返回尾元素的引用
//back():返回尾元素的引用
std::cout << " v back() -1 : " << v.back() <<std::endl;
begin() 返回向量头指针，指向第一个元素
//begin() 返回向量头指针，指向第一个元素
std::cout << " v begin() 0 : " << *(v.begin()) << std::endl;
end() 返回向量尾指针，指向向量最后一个元素的下一个位置
// end():返回向量尾指针，指向向量最后一个元素的下一个位置 注意这里不是指向最后一个元素
std::cout << " v end() 0 : " << *(v.end()) << std::endl;
⚠️ end() 不是指向最后一个元素的迭代器
rbegin() 反向迭代器，指向最后一个元素
// rbegin():反向迭代器，指向最后一个元素
std::cout << " v rbegin() -1: " << *(v.rbegin()) << std::endl;
rend() 反向迭代器，指向第一个元素之前的位置
// rend():反向迭代器，指向第一个元素之前的位置 注意不是指向第一个元素
std::cout << " v rend() 0 : " << *(v.rend()) << std::endl;
⚠️ rend() 不是指向第一个元素的迭代器
获取向量的大小
size() const:返回向量中元素的个数
std::cout << "---- vector size ---- " << std::endl;
std::vector<int> v {12, 13, 14, 15};
std::cout << " v size : " << v.size() << std::endl;
empty() const:判断向量是否为空，若为空，则向量中无元素
std::cout <<" v empty : " << v.empty() << std::endl;
交换两个向量
swap(vector&):交换两个同类型向量的数据
std::cout << "---- vector swap ---- " << std::endl;
std::vector<int> a {1, 2, 3};
std::cout << " vector a: { ";
for(size_t i = 0; i < a.size(); i++){
std::cout << a[i] << " ";
}
std::cout << "} " << std::endl;
std::vector<int> b {11, 12, 13};
std::cout << " vector b: { ";
for(size_t i = 0; i < b.size(); i++){
std::cout << b[i] << " ";
}
std::cout << "} " << std::endl;
std::cout << " -----after swap----" <<std::endl;
// swap()
a.swap(b);
std::cout << " vector a: { ";
for(size_t i = 0; i < a.size(); i++){
std::cout << a[i] << " ";
}
std::cout << "} " << std::endl;
std::cout << " vector b: { ";
for(size_t i = 0; i < b.size(); i++){
std::cout << b[i] << " ";
}
std::cout << "} " << std::endl;
遍历vector
std::cout << " ---- vector traver ---- " << std::endl;
std::vector<int> vec {1, 2, 3, 4};
//方式一:
for (size_t i = 0; i < vec.size(); ++i) {
std::cout << vec[i] << " ";
}
std::cout << std::endl;
//方式二:
for(auto v: vec){
std::cout << v << " ";
}
std::cout << std::endl;
//方式三：
for(std::vector<int>::iterator iter = vec.begin(); iter != vec.end(); iter++){
std::cout << *(iter) << " ";
}
std::cout << std::endl;
//方式四：
for(auto iter = vec.begin(); iter != vec.end(); iter++){
std::cout << *(iter) << " ";
}
std::cout << std::endl;
排序sort()
使用sort()函数, 需要引用头文件：
#include<algorithm>
从小到大
排序函数sort() 默认排序从小到大
std::cout << " ---- vector sort ---- " << std::endl;
std::vector<int> a{4, 2, 5, 6, 1};
// 默认从小到大
sort(a.begin(), a.end());
std::cout << " sort up: ";
for(auto v: a){
std::cout << v << " ";
}
std::cout << std::endl;
从大到小
方式一：使用greater<>()函数
//从大到小
//方法一：使用 greater<int>()函数
std::vector<int> b {4, 2, 5, 6, 1};
sort(b.begin(), b.end(), greater<int>());
std::cout << " sort down 1: ";
for(auto v: b){
std::cout << v << " ";
}
std::cout << std::endl;
方式二：使用反向迭代器
//方法二：
std::vector<int> c {4, 2, 5, 6, 1};
sort(c.rbegin(), c.rend());
std::cout << " sort down 2: ";
for(auto v: c){
std::cout << v << " ";
}
std::cout << std::endl;
方式三：自定义比较函数
⚠️ 比较函数必须写在类外部（全局区域）或声明为静态函数
//方法三： 自定义规则函数camp_max() -- 这个函数需要是全局函数 大的写在前面
//自己定义比较函数，大的写在前面,这个是全局函数
bool camp_max(int x, int y){
return x > y;
}
int main(){
std::vector<int> d {4, 2, 5, 6, 1};
sort(d.begin(), d.end(), camp_max);
std::cout << " sort down 3: ";
for(auto v: d){
std::cout << v << " ";
}
std::cout << std::endl;
}
方式四: 使用sort排序后，使用reverse()
//方式四：使用sort排序后，使用reverse() 将元素倒置，但不排列
std::vector<int> f {4, 2, 5, 6, 1};
sort(f.begin(), f.end());
reverse(f.begin(), f.end());
std::cout << " sort down 4: ";
for(auto v: f){
std::cout << v << " ";
}
std::cout << std::endl;
结构体排序
对于结构体，自定义排序规则
c++如何对自定义结构体排序_论菜鸟的自我修养的博客-CSDN博客_c++ 自定义结构体
方式一: 结构体内重载比较函数
* 以A-star算法中，节点结构体为例(f = g + h )，我们的排序规则是：
* 1. f不等，按f从小到大排序
* 2. 当f相等，按h从小到大排序
#include <iostream>
#include <vector>
#include <algorithm>
typedef struct Node{
int x;
int y;
float f;
float g;
float h;
Node *father_node;
Node(int x_, int y_) : x(x_), y(y_){
this->f = 0;
this->h = 0;
this->g = 0;
this->father_node = NULL;
}
//重载输出
friend ostream &operator << (ostream&, Node &n){
if (n.father_node == NULL){
cout << " [ " << n.x << " , " << n.y << " ] -- " << "GHF: " << n.g << " , " << n.h << " , " << n.f <<
" -- { NULL } ";
} else{
cout << " [ " << n.x << " , " << n.y << " ] -- " << "GHF: " << n.g << " , " << n.h << " , " << n.f <<
" -- { " << n.father_node->x << " , " << n.father_node->y << " } ";
}
return cout;
}
//方式一: 结构体内重载比较函数
//升序排序 <
// 加const强调函数里不会去修改这个引用，如果修改则会编译出错 传递引用是考虑到效率，不需要复制
bool operator < (const Node &n) const
{
if (this->f == n.f){
return this->h < n.h;
} else{
return this->f < n.f;
}
}
//降序排序 >
bool operator > (const Node &n) const
{
if(this->f == n.f){
return this->h >n.h;
} else{
return this->f > n.f;
}
}
}Node;
int main(){
std::cout << " ----struct vector sort ---- " << std::endl;
std::vector<Node> Nodes;
Node n1(1, 1);
n1.f = 10;
n1.g = 0;
n1.h = 10;
Nodes.push_back(n1);
Node n2(2, 2);
n2.f = 10;
n2.g = 1;
n2.h = 9;
Nodes.push_back(n2);
Node n3(3,3);
n3.f = 11;
n3.g = 2;
n3.h = 10;
Nodes.push_back(n3);
//升序排序
//sort(Nodes.begin(), Nodes.end());
sort(Nodes.begin(), Nodes.end(), less<Node>());
std::cout << " ----up order--------" << std::endl;
for(auto n : Nodes){
std::cout << n << std::endl;
}
std::cout << " ------------" << std::endl;
//降序排序
sort(Nodes.begin(), Nodes.end(), greater<Node>());
std::cout << " ----down order--------" << std::endl;
for(auto n : Nodes){
std::cout << n << std::endl;
}
std::cout << " ------------" << std::endl;
}
方式二: 结构体外排序
⚠️ 比较函数必须写在结构体外部（全局区域）或声明为静态函数
升序排序 <
降序排序 >
#include <iostream>
#include <vector>
#include <algorithm>
typedef struct Node{
int x;
int y;
float f;
float g;
float h;
Node *father_node;
Node(int x_, int y_) : x(x_), y(y_){
this->f = 0;
this->h = 0;
this->g = 0;
this->father_node = NULL;
}
//重载输出
friend ostream &operator << (ostream&, Node &n){
if (n.father_node == NULL){
cout << " [ " << n.x << " , " << n.y << " ] -- " << "GHF: " << n.g << " , " << n.h << " , " << n.f <<
" -- { NULL } ";
} else{
cout << " [ " << n.x << " , " << n.y << " ] -- " << "GHF: " << n.g << " , " << n.h << " , " << n.f <<
" -- { " << n.father_node->x << " , " << n.father_node->y << " } ";
}
return cout;
}
}Node;
// 全局函数
// 升序排序 <
bool less_camp(const Node &n1, const Node &n2){
if(n1.f == n2.f){
return n1.h < n2.h;
}else{
return n1.f < n2.f;
}
}
//降序 >
bool greater_camp(const Node &n1, const Node &n2){
if(n1.f == n2.f){
return n1.h > n2.h;
}else{
return n1.f > n2.f;
}
}
int main(){
std::cout << " ----struct vector sort ---- " << std::endl;
std::vector<Node> Nodes;
Node n1(1, 1);
n1.f = 10;
n1.g = 0;
n1.h = 10;
Nodes.push_back(n1);
Node n2(2, 2);
n2.f = 10;
n2.g = 1;
n2.h = 9;
Nodes.push_back(n2);
Node n3(3,3);
n3.f = 11;
n3.g = 2;
n3.h = 10;
Nodes.push_back(n3);
std::cout << " ----- method outside struct ------" <<std::endl;
sort(Nodes.begin(), Nodes.end(), less_camp);
std::cout << " ----up order--------" << std::endl;
for(auto n : Nodes){
std::cout << n << std::endl;
}
std::cout << " ------------" << std::endl;
sort(Nodes.begin(), Nodes.end(), greater_camp);
std::cout << " ----down order--------" << std::endl;
for(auto n : Nodes){
std::cout << n << std::endl;
}
std::cout << " ------------" << std::endl;
}
查找vector中的最大最小值
std::max_element()返回迭代器 可用std::distance()函数查找位置
std::min_element()
std::vector<double> v {1.0, 2.0, 3.0, 4.0, 5.0, 1.0, 2.0, 3.0, 4.0, 5.0};
std::vector<double>::iterator biggest = std::max_element(std::begin(v), std::end(v));
//or std::vector<double>::iterator biggest = std::max_element(v.begin(), v.end);
std::cout << "Max element is " << *biggest<< " at position " <<std::distance(std::begin(v), biggest) << std::endl;
//另一方面，取最大位置也可以这样来写：
//int nPos = (int)(std::max_element(v.begin(), v.end()) - (v.begin());
//效果和采用distance(...)函数效果一致
//说明：max_element(v.begin(), v.end()) 返回的是vector<double>::iterator,
//相当于指针的位置，减去初始指针的位置结果即为最大值得索引。
auto smallest = std::min_element(std::begin(v), std::end(v));
std::cout << "min element is " << *smallest<< " at position " <<std::distance(std::begin(v), smallest) << std::endl;
1689
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
