容器:C++vector用法 VS C#list用法

来源:互联网 发布:余文乐有淘宝店吗 编辑:程序博客网 时间:2024/03/29 22:56

C++中,用容器向量(vector)实现。容器向量也是一个类模板。
标准库vector类型使用需要的头文件:#include <vector>。vector 是一个类模板。不是一种数据类型,vector<int>是一种数据类型。Vector的存储空间是连续的,list不是连续存储的。

一、 定义和初始化
vector< typeName > v1;       //默认v1为空,故下面的赋值是错误的v1[0]=5;
vector<typeName>v2(v1);   //或v2=v1;或vector<typeName> v2(v1.begin(), v1.end());//v2是v1的一个副本,若v1.size()>v2.size()则赋值后v2.size()被扩充为v1.size()。
vector< typeName > v3(n,i);//v3包含n个值为i的typeName类型元素
vector< typeName > v4(n);//v4含有n个值为0的元素
int a[4]={0,1,2,3,3}; vector<int> v5(a,a+5);//v5的size为5,v5被初始化为a的5个值。后一个指针要指向将被拷贝的末元素的下一位置。
vector<int> v6(v5);//v6是v5的拷贝
vector< 类型 > 标识符(最大容量,初始所有值);

二、vector对象最重要的几种操作
1. v.push_back(t)   在容器的最后添加一个值为t的数据,容器的size变大。
    另外list有push_front()函数,在前端插入,后面的元素下标依次增大。
2. v.size()        返回容器中数据的个数,size返回相应vector类定义的size_type的值。v.resize(2*v.size)或                  

v.resize(2*v.size, 99) 将v的容量翻倍(并把新元素的值初始化为99)
3. v.empty()     判断vector是否为空
4. v[n]           返回v中位置为n的元素
5. v.insert(pointer,number, content)    向v中pointer指向的位置插入number个content的内容。
    还有v. insert(pointer, content),v.insert(pointer,a[2],a[4])将a[2]到a[4]三个元素插入。
6. v.pop_back()    删除容器的末元素,并不返回该元素。
7.v.erase(pointer1,pointer2) 删除pointer1到pointer2中间(包括pointer1所指)的元素。
   vector中删除一个元素后,此位置以后的元素都需要往前移动一个位置,虽然当前迭代器位置没有自动加1,
   但是由于后续元素的顺次前移,也就相当于迭代器的自动指向下一个位置一样。
8. v1==v2          判断v1与v2是否相等。
9. !=、<、<=、>、>=      保持这些操作符惯有含义。
10. vector<typeName>::iterator p=v1.begin( ); p初始值指向v1的第一个元素。*p取所指向元素的值。
      对于const vector<typeName>只能用vector<typeName>::const_iterator类型的指针访问。
11.   p=v1.end( ); p指向v1的最后一个元素的下一位置。
12. v.clear()      删除容器中的所有元素。12.v.clear()      删除容器中的所有元素。

13, v.swap()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// swap vectors
#include <iostream>
#include <vector>
void main ()
{
  vector<int> foo (3,100);   // three ints with a value of 100
  vector<int> bar (5,200);   // five ints with a value of 200
   
  foo.swap(bar);
   
  cout << "foo contains:";
  for (unsigned i=0; i<foo.size(); i++)
    cout << ' ' << foo[i];
  cout << '\n';
   
  cout << "bar contains:";
  for (unsigned i=0; i<bar.size(); i++)
    cout << ' ' << bar[i];
  cout << '\n';
   
  return 0;
}
   
output:
foo contains: 200 200 200 200 200 
bar contains: 100 100 100

在这里补充一下Vector变量之间的赋值:

1
2
3
4
5
vector<int>a(5,0);       
vector<int>b(3,1);
//经过总结下面的语句可行:
a.clear();            
a=b;

#include<algorithm>中的泛函算法
搜索算法:find() 、search() 、count() 、find_if() 、search_if() 、count_if() 
分类排序:sort() 、merge() 
删除算法:unique() 、remove() 
生成和变异:generate() 、fill() 、transformation() 、copy() 
关系算法:equal() 、min() 、max() 
sort(v1.begin(),vi.begin()+v1.size/2); 对v1的前半段元素排序
list<char>::iterator pMiddle =find(cList.begin(),cList.end(),'A');找到则返回被查内容第一次出现处指针,否则返回end()。
int icount=count(v.begin(),v.end(),str);

三、内存管理与效率

1.使用reserve()函数提前设定容量大小,避免多次容量扩充操作导致效率低下。

vector<int> v;
v.reserve(1000);
for (int i = 1; i <= 1000; ++i) v.push_back(i);
这在循环中不会发生重新分配。

if (s.size() < s.capacity()) {
s.push_back('x');
}

2.使用“交换技巧”来修整vector过剩空间/内存

      有一种方法来把它从曾经最大的容量减少到它现在需要的容量。这样减少容量的方法常常被称为“收缩到合适(shrink to fit)”。该方法只需一条语句:vector<int>(ivec).swap(ivec);
表达式vector<int>(ivec)建立一个临时vector,它是ivec的一份拷贝:vector的拷贝构造函数做了这个工作。但是,vector的拷贝构造函数只分配拷贝的元素需要的内存,所以这个临时vector没有多余的容量。然后我们让临时vector和ivec交换数据,这时我们完成了,ivec只有临时变量的修整过的容量,而这个临时变量则持有了曾经在ivec中的没用到的过剩容量。在这里(这个语句结尾),临时vector被销毁,因此释放了以前ivec使用的内存,收缩到合适。

3.用swap方法强行释放STL Vector所占内存

1
2
   vector<int> v(4,0) ;
 vector<int>().swap(v);
1
v.swap(vector<int>());

/*或者{ std::vector<int> tmp = v;   v.swap(tmp);   }; //加大括号{ }是让tmp退出{ }时自动析构*/

统计vector中不同元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void CKnn::setGroupName()
{
    string tem;
    vector<string>::iterator iter;
    for(int i=0;i<trainLabel.size();i++)
    {
        tem=trainLabel[i];
        iter=find(groupName.begin(),groupName.end(),tem);
        if(iter==groupName.end())
        {
            groupName.pop_back(tem);
        }
    }
}

1.vector 的数据的存入和输出:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include<vector>
#include <iostream>    
using namespace std;   
void main()  
{  
   int i = 0;
   vector<int> v;   
   for( i = 0; i < 10; i++ ) 
         v.push_back( i );//把元素一个一个存入到vector中
    /* v.clear()*/ 对存入的数据清空
   for( i = 0; i < v.size(); i++ )//v.size() 表示vector存入元素的个数
          cout << v[ i ]<< "  "//把每个元素显示出来 
   cont << endl;
}

注:你也可以用v.begin()和v.end() 来得到vector开始的和结束的元素地址的指针位置。你也可以这样做:

vector::clear()函数的清空操作实际上执行的只是调用其析构函数,进行重置size等操作,实际内存中的数据并没有被清楚(这是为了提高效率)

当数组越界时,仍然会取到相应的数据。这时,可以采取:

1
2
3
vector<string> TempData;
       
TempData.swap( vector<string> () );

附:vector排序:sort(m_time.begin(),m_time.end());

vector插入N个初始为0的元素:m_time.insert(N,0);

将二维tem1的数据加入到tem2的后面:

1
2
3
4
5
vector< vector <double> >tem1;
       
vector< vector <double> >tem2;
       
tem2.insert(tem2.end(),tem1.begin(),tem1.end());

vector内元素随机打乱

vector <int> test;

random_shuffle(test.begin(), test.end());

2. 对于二维vector的定义。

1)定义一个10个vector元素,并对每个vector符值1-10。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
#include<stdio.h>
#include<vector>
#include <iostream>
       
using namespace std;
       
void main()
{
 int i = 0, j = 0;
       
//定义一个二维的动态数组,有10行,每一行是一个用一个vector存储这一行的数据。
       
所以每一行的长度是可以变化的。之所以用到vector<int>(0)是对vector初始化,否则不能对vector存入元素。
 vector< vector<int> > Array( 10, vector<int>(0) ); 
       
for( j = 0; j < 10; j++ )
 {
  for ( i = 0; i < 9; i++ )
  {
   Array[ j ].push_back( i );
  }
 }
       
 for( j = 0; j < 10; j++ )
 {
  for( i = 0; i < Array[ j ].size(); i++ )
  {
   cout << Array[ j ][ i ] << "  ";
  }
  cout<< endl;
 }
}

2)定义一个行列都是变化的数组。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
#include<stdio.h>
#include<vector>
#include <iostream>
       
using namespace std;
       
void main()
{
 int i = 0, j = 0;
       
 vector< vector<int> > Array;
 vector< int > line;
 for( j = 0; j < 10; j++ )
 {
  Array.push_back( line );//要对每一个vector初始化,否则不能存入元素。
  for ( i = 0; i < 9; i++ )
  {
   Array[ j ].push_back( i );
  }
 }
       
 for( j = 0; j < 10; j++ )
 {
  for( i = 0; i < Array[ j ].size(); i++ )
  {
   cout << Array[ j ][ i ] << "  ";
  }
  cout<< endl;
 }
}

使用 vettor erase 指定元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include "iostream"
#include "vector"
using namespace std;
int   main()
{
    vector<int>   arr;
    arr.push_back(6);
    arr.push_back(8);
    arr.push_back(3);
    arr.push_back(8);
       
    for(vector<int>::iterator it=arr.begin(); it!=arr.end(); )
    {
        if(* it == 8)
        {
            it = arr.erase(it);
        }
        else
        {
            ++it;
        }
    }
       
    cout << "After remove 8:\n";
       
    for(vector<int>::iterator it = arr.begin(); it < arr.end(); ++it)
    {
        cout << * it << " ";
    }
    cout << endl;
}



C# List<T>用法


所属命名空间:using System.Collections.Generic;

  List<T>类是  ArrayList 类的泛型等效类。 该类使用大小可按需动态增加的数组实现  IList<T> 泛型接口。 

泛型的好处: 它为使用 c#语言编写面向对象程序增加了极大的效力和灵活性。不会强行对值类型进行装箱和拆箱,或对引用类型进行向下强制类型转换,所以性能得到提高。

一、  List的基础、常用方法:

首先说明常用的二维用法为:

public List<List<String>> DatasetList { get; private set; }//C# 二维list变量的声明DatasetList = new List<List<string>>();//初始化List<string> rowdata = new List<string>();//先获取一个一维向量DatasetList.Add(rowdata);//将一维向量依次存储到二维向量中

1、List<T> mList = new List<T>();    
a.T为列表中元素类型,现在以string类型作为例子
如:  List<string> mList = new List<string>();

b.增加元素:List. Add(T item)    添加一个元素
如:mList.Add("赖炎滨");

c.插入元素:Insert(int index, T item);    在index位置添加一个元素
如:mList.Insert(1, "laiyanbin"); 

d.删除元素:  List. Remove(T item)       删除一个值
                如:mList.Remove("赖炎滨"); 

                List. RemoveAt(int index);   删除下标为index的元素

               如.:mList.RemoveAt(0); 

                List. RemoveRange(int index, int count);   从下标index开始,删除count个元素
                如.:mList.RemoveRange(3, 2); //超出删除的范围会出错
注:删除某元素后,其后面的元素下标自动跟进

e.判断是否存在List:List. Contains(T item)   得到的结果是返回true或false

f.排序:List. Sort ()   //默认是元素第一个字母按升序 

           给List里面元素顺序反转:
           List. Reverse ()   //可以与List. Sort ()配合使用,达到想要的效果

遍历List中元素:   
   foreach (T element in mList)  T的类型与mList声明时一样
            {
                 Console.WriteLine(element);
            } 

g.List清空:List. Clear ()
           如:mList.Clear();

h.获得List中元素数目:
           List. Count ()    返回int值

i.添加数组进List:string[] temArr = { Ha","Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", " "Locu" };
            mList.AddRange(temArr);

2、List<T> testList =new List<T> (IEnumerable<T> collection);
      以一个集合作为参数创建List
       E.g.: string[] temArr = { "Ha", "Hunter", "Tom", "Lily", "Jay", "Jim", "Kuku", "Locu" };
                  List<string> testList = new List<string>(temArr);

3、List与数组的相互转换
1.从string[]转List<string>
例如:string[] str={“1”,”2”};
List <string> list=new List<string>(str);
2.从List<string>转string[] 

例如:List<string> list=new List<string>;
String[] str=list.ToArray();

//ViewState["idlist"]转换成List<>

List<int> idlist=(List<int>)ViewState["idlist"]