最近学习——关于vector

 

一:
Python中没有类似c++中的Vector向量;

用List实现:

dict或tuple的list

movies = [{'id':1, 'name':'a'},{'id':2, 'name':'b'}]
movies[0]['name']
 

 

 

二:

关于Vector

向量(Vectors

  1.基本操作
 vector是向量类型,她是一种对象实体,具有值,所以可以看作是变量。她可以容纳许多其他类型的相同实体,
如若干个整数,所以称其为容器。Vector是C++STL(标准模板类库)的重要一员,使用她时,只要包括头文件#include<vector>即可。
 vector可以有四种定义方式: 
vector<int>是模板形式,尖括号中为元素类型名,她可以是任何合法的数据类型。 
  (1)vector<int> a(10);
//定义了10个整数元素的向量,但并没有给出初值,因此其值是不确定的。
     
  (2)vector<int> b(10,1);
//定义了10个整数元素的向量,且给出每个元素的初值为1。这种形式是数组望尘莫及的,
//数组只能通过循环来成批的赋给相同初值。
   
  (3)vector<int> c(b);
//用另一个现成的向量来创建一个向量。
   
  (4)vector<int>d(b.begin(),b.begin()+3);
//定义了其值依次为b向量中第0到第2个(共3个)元素的向量。
    因此,创建向量时,不但可以整体向量复制性赋值,还可以选择其他容器的部分元素来定义向量和赋值。
特别的,向量还可以从数组获得初值。例如:
int a[8]={2007,9,24,2008,10,14,10,5};
vector<int> va(a,a+8);
   上面第(4)种形式的b.begin() 、b.end()是表示向量的起始元素位置和最后一个元素之外的元素位置。
向量元素位置也属于一种类型,称为遍历器。遍历器不单表示元素位置,还可以在容器中前后挪动。
每种容器都有对应的遍历器。向量中的遍历器类型为:
vector<int>::iterator
因此要输入向量中所有元素,可以有两种循环控制方式:
for(int i=0; i<a.size(); ++i)  //第一种方法
     cout<<a[i]<<" ";
 
for(vector<int>::iterator it=a.begin(); it!=a.end(); ++it)  //第二种方法
    cout<<*it<<" ";
第一种方法是下标方式,a[i]是向量元素操作,这种形式和数组一样;
第二种方法是遍历器方式,*it是指针间访形式,它的意义是it所指向的元素值。
  a.size()是向量中元素的个数,a.begin()表示向量的第一个元素,这种操作方式是一个对象捆绑一个函数调用,
表示对该对象进行某个操作。
   类似这样的使用方式称为调用对象a的成员函数,这在对象化程序设计中很普遍。
向量中的操作都是通过使用成员函数来完成的。它的常用操作有:
a.assign(b.begin(), b.begin()+3);   //b向量的0~2元素构成向量赋给a
a.assign(4,2);                                      //使a向量只含0~3元素,且赋值为2
int x=a.back();                                   //将a的最后一个向量元素值赋给整数型变量x
a.clear();                                             //a向量中元素清空(不再有元素)
if(a.empty()) cout<<"empty";      //a.empty()经常作为条件,判断向量是否为空
int y=a.front();                                 //将a的第一个向量元素值赋给整型变量y
a.pop_back();                                  //删除a向量的最后一个元素
a.push_back(5);                             //在a向量最后插入一个元素,其值为5
a.resize(10);                        //将向量元素个数调至10个。多则删,少则补,其值随机
a.resize(10,2);                    //将向量元素个数调至10个。多则删,少则补,其值为2
if(a=b) cout<<"epual";    //向量的比较操作还有 !=, <,< =, >,> =
  除此之外,还有元素的插入与删除、保留元素个数、容量观察等操作。
  向量是编程中使用频率最高的数据类型。
这不仅因为数据的顺序排列性在生活中最常见,还因为向量中有一些插入、删除、搜索、判空等最简单的常规操作。
当数据并不复杂时,可以代替其他数据类型而很好的工作。特别是向量可以自动伸展,容量可以自动增大,
这对一些不确定数据量的容器工作带来了极大的方便。
 
1.向量-->添加元素
//向量-->添加元素
//例:读入一个文件yuexingtian.txt 的数据到向量中,文件中为一些整数(不知个数的情况)。
//要判断向量中的元素有多少个两两相等的数对,如下:
//===============yuexingtian-->begin==============================
//向量操作
-->添加元素(例1)
//============================================================
#include<iostream>
#include<fstream>
#include<vector>

using namespace std;
//-------------------------------
int main()
{
  ifstream in("yuexingtian.txt");//yuexingtian.txt文件必须要和此程序放在同一个文件夹下
 
vector<int> s;
 for(int a; in>>a;)//将yuexingtian.txt的数据全都读入a中
   
s.push_back(a);//在s向量最后插入元素a的值
 
int pair=0;
 for(int i=0;i<s.size()-1;++i)//比较是否有相等的数的for循环
 
for(int j=i+1;j<s.size();++j)
   if(s[i]==s[j]) pair++;
  cout<<pair<<endl;
}
//========================end============thanks=================
  因为不知道文件中的元素个数,所以无法用数组来处理,也无法向向量定义中确定元素个数,但可以先创建一个空向量,
然后用添加操作不断往向量中添加元素。
  如果频繁扩充容量,就要显著增加向量操作的负担,因为扩充意味着分配更大空间,复制原空间到现空间,删除原空间。
向量并不是每次扩展都要扩容,向量中预留了一部分未用的元素供扩展之用。
  一开始若创建一个空向量,则向量中已经含有一些未用的元素,可以用capacity()查看。
如果上述程序面临着大量数据,比如10万个整数,这时候,为了保持向量的性能,应该在一开始就规定保留未用元素的数量。
yuexingtian.txt文件内容:
 
运行结果:
 
 
//===============yuexingtian-->begin==============================
//向量操作
-->添加元素(例2)
//============================================================
#include< iostream>
#include <vector>
#include< string>

using namespace std;
int main()
{
vector<string> sval;//定义一个向量
string str1("yue");
string str2("xing");
sval.push_back(str1);//在sval向量最后插入一个值,值为"yue"
sval.push_back(str2);//在sval向量最后插入一个值,值为"xing"
  
for(vector<string>::iterator iter=sval.begin();iter!=sval.end();++iter)
    //vector<string>::iterator为遍历器;可查看:《C++数据类型——向量(1)》
     cout<<*iter<<" ";
     cout<<endl;
    return 0;
}
//========================end============thanks=================

//=================http://yuexingtian.cublog.cn=======================
运行结果:
 
DE>//二维向量(2-D Vectors)
//在二维向量中,可以使用vector中的swap操作来交换两个向量。swap操作是专门为提高
//两向量直接互相交换的性能儿设计的。如果用一般的的swap:
//eg:void sawp(vector<int>&a,vector<int>&b)
//   {vector<int> temp=a;a=b;b=temp;}
//它涉及向量的创建、赋值、在赋值,最后还要销毁临时向量。但若用vector的swap操作,
//这些工作都可以省掉。只要做微不足道的地址交换工作,岂不美哉?!
//eg:文件yuexingtian.txt中含有一些行,每行中有一些整数,可以构成一个向量。
//整个文件可以看成是一组向量,其中每个元素又都是向量,只不过元素的向量其长度
//参差不齐。设计一个程序,使得按从短到长的顺序输出每个向量:
//=============yuexingtian-->begin==================
//如干个向量按长短排序
//================================================== 
#include<iostream>
#include<fstream>
#include<sstream>
#include<vector>
using namespace std;
//----------------------------
typedef vector<vector<int> > Mat;DE>
DE>DE>
DE>
Mat input();
void mySort(Mat &a);
void print(const Mat &a);
//----------------------------
int main()
{
  Mat a=input();
  mySort(a);
  print(a);
  return 0;
}
//----------------------------
Mat input()//输入 
{
 ifstream in ("yuexingtian.txt");
 Mat a;
 for (string s;getline(in,s);)
 {
   vector<int> b;
   istringstream sin(s);
   for(int ia; sin>>ia; )
     b.push_back(ia);
   a.push_back(b);
 }
 return a;
}
//----------------------------------
void mySort(Mat &a)//排序 
{
 for(int pass=1;pass<a.size();++pass)
 for(int i=0;i<a.size()-pass;++i)
   if(a[i+1].size()<a[i].size())
     a[i].swap(a[i+1]);
}
//-----------------------------------
void print(const Mat &a)//输出 
{
 for(int i=0;i<a.size();++i)
 {
   for(int j=0;j<a[i].size();++j)
     cout<<a[i][j]<<" ";
     cout<<endl;
 }
}
//=========================end========================


DE>
运行结果:

 

yuexingtian.txt文件:

 

     程序分析:输出print()函数是一个双重循环,它按序将二维向量中的每一个元素(向量)打印出来。且每打印一个向量,就换行。
mySort是排序函数,他按向量元素个的多少进行排序,使用的是“冒泡法“。
   排序中所使用的swap就是两个向量相互交换的操作,它在vector中定义。
用typedef来定义Mat这个二维向量的名字,以使程序中是名称易记易用。
 
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章