线性表的概念：1分钟了解什么是线性表 (biancheng.net)

一、字符串

头文件

#include <string>

1、string类常用的构造函数

string str ("ABC", strlen)  // 将"ABC"存到str里,最多存储前strlen个字节
 
string s("ABC",stridx,strlen)   //将"ABC"的stridx位置,做为字符串开头,存到str里.且最多存储strlen个字节.
    
string s(strlen, 'A')  //存储strlen个'A'到str里

2、string类常用的成员函数

str1.length()；                //获取字符串长度
str1.puch_back ('A');    　　  //在str1末尾添加一个'A'字符,参数必须是字符形式
str1.append ("ABC");     　　  //在str1末尾添加一个"ABC"字符串,参数必须是字符串形式
str1.clear();           　　   //删除所有
str1.erase(2);         　　　　//删除下标为2的位置,比如: "ABCD" --> "AB"
str1.erase(2,1);               //从下标为2的位置删除1个,比如: "ABCD"  --> "ABD"
str1.insert (2,"ABC");         //在str1的下标为2的位置,插入"ABC"
str1.swap(str2);        　　   //替换str1 和 str2 的字符串

str1.assign("ABC");　　　　　　//清空string串,然后设置string串为"ABC" 
str1.size();　　　　　　　　　 //获取字符串数量,等价于length()
str1.capacity();　　　　　　　 //获取容量,容量包含了当前string里不必增加内存就能使用的字符数
str1.resize(10);　　　　　　  //表示设置当前string里的串大小,若设置大小大于当前串长度,则用字符\0来填充多余的.
str1.resize(10,char c);　　　　//设置串大小，若设置大小大于当前串长度,则用字符c来填充多余的
str1.reserve(10);　　　　　　　//设置string里的串容量,不会填充数据.
str1.replace(2,4, "ABCD");     //从下标为2的位置,替换4个字节,为"ABCD"
str1.empty();         　　     //判断为空, 为空返回true

3、返回一个常量C字符串

string* str = new string("ASD"); //str="ASD" 
const char* c = str->c_str();

4、反转字符串

string str("hello");
reverse(str.begin(),str.end());
cout<< str <<endl;

5、查找相关

//find和rfind返回查找的位置
string str("ABCDEFGABCD"); 
int n =0 ;

n= str.find('A');              //查找"A",n=0;
n= str.find("AB");             //查找"AB",n=0;
n= str.find("BC",1);           //从位置1处,查找"BC",n=1;
n= str.find("CDEfg",1,3);      //从位置1处,查找"CDEfg"的前3个字符,等价于str.find("CDE",1),n=2;

/*rfind():反向(reverse)查找,从末尾处开始,向前查找*/
n= str.rfind("CD");           //从位置10开始向前查找,n=9
n= str.rfind("CD",5);         //从位置5开始向前查找,n=2
n= str.rfind("CDEfg",5,3);    //等价于str.rfind("CDE",5);       ,所以n=2

6、拷贝相关

str2=str1.substr(2);        //提取子串,提取出str1的下标为2到末尾,给str2
str2=str1.substr(2,3);     //提取子串,从 str1的下标为2开始,提取3个字节给str2
const char *s1= str.data();   //将string类转为字符串数组,返回给s1

char *s=new char[10];
str.copy(s,count,pos);    //将str里的pos位置开始,拷贝count个字符,存到s里.

二、线性表List

1、相关概念

（1）前趋和后继

对于线性表中的数据来说，位于当前数据之前的数据统称为“前趋元素”，前边紧挨着的数据称为“直接前趋”；同样，后边的数据统称为“后继元素”，后边紧挨着的数据称为“直接后继”。除非在线性表中插入或者删除数据元素，否则数据之间的关系不会改变。

（2）线性表的特点

用线性表存储的数据有两个特点：

存储的数据本身的类型一定保持相同，是int型就都是int型，是结构体就都是一种结构体。
数据一旦用线性表存储，各个数据元素之间的相对位置就固定了。

（3）线性表的分类

之前讲过，逻辑结构上相邻的数据在实际的物理存储中有两种形式：分散存储和集中存储。
考虑到这两种情况，线性表分为两种，分别解决两种情况下数据的存储问题：

数据元素在内存中集中存储，采用顺序表示结构，简称“顺序存储”；
数据元素在内存中分散存储，采用链式表示结构，简称“链式存储”。

2、Vector的用法

向量类型，可以容纳许多类型的数据。

（1）头文件

#include <vector>

（2）初始化方法

vector<int> a(10); //定义了10个整型元素的向量（尖括号中为元素类型名，它可以是任何合法的数据类型），但没有给出初值，其值是不确定的。
vector<int> a(10,1); //定义了10个整型元素的向量,且给出每个元素的初值为1
vector<int> a(b); //用b向量来创建a向量，整体复制性赋值
vector<int> a(b.begin(),b.begin+3); //定义了a值为b中第0个到第2个（共3个）元素

int b[7]={1,2,3,4,5,9,8};
vector<int> a(b,b+7); //从数组中获得初值

（3）几个重要操作

a.push_back(5); //在a的最后一个向量后插入一个元素，其值为5
a.clear(); //清空a中的元素
a.empty(); //判断a是否为空，空则返回ture,不空则返回false
a[i]; //返回a的第i个元素，当且仅当a[i]存在2013-12-07
a.back(); //返回a的最后一个元素
a.front(); //返回a的第一个元素
a.pop_back(); //删除a向量的最后一个元素
a.size(); //返回a中元素的个数；
a.capacity(); //返回a在内存中总共可以容纳的元素个数
a.swap(b); //b为向量，将a中的元素和b中的元素进行整体性交换

a.insert(a.begin()+1,5); //在a的第1个元素（从第0个算起）的位置插入数值5，如a为1,2,3,4，插入元素后为1,5,2,3,4
a.insert(a.begin()+1,3,5); //在a的第1个元素（从第0个算起）的位置插入3个数，其值都为5
a.insert(a.begin()+1,b+3,b+6); //b为数组，在a的第1个元素（从第0个算起）的位置插入b的第3个元素到第5个元素（不包括b+6），如b为1,2,3,4,5,9,8，插入元素后为1,4,5,9,2,3,4,5,9,8

a.assign(b.begin(), b.begin()+3); //b为向量，将b的0~2个元素构成的向量赋给a
a.assign(4,2); //是a只含4个元素，且每个元素为2

a.erase(a.begin()+1,a.begin()+3); //删除a中第1个（从第0个算起）到第2个元素，也就是说删除的元素从a.begin()+1算起（包括它）一直到a.begin()+         3（不包括它）

a.resize(10); //将a的现有元素个数调至10个，多则删，少则补，其值随机
a.resize(10,2); //将a的现有元素个数调至10个，多则删，少则补，其值为2
a.reserve(100); //将a的容量（capacity）扩充至100，也就是说现在测试a.capacity();的时候返回值是100.这种操作只有在需要给a添加大量数据的时候才         显得有意义，因为这将避免内存多次容量扩充操作（当a的容量不足时电脑会自动扩容，当然这必然降低性能） 

a==b; //b为向量，向量的比较操作还有!=,>=,<=,>,<

（3）几种重要的算法，使用时需要包含头文件

#include<algorithm>

sort(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素进行从小到大排列
reverse(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1
reverse(a.begin(),a.end()); //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素倒置，但不排列，如a中元素为1,3,2,4,倒置后为4,2,3,1
find(a.begin(),a.end(),10); //在a中的从a.begin()（包括它）到a.end()（不包括它）的元素中查找10，若存在返回其在向量中的位置

三、栈

栈是一种线性存储结构，它的特点如下：

栈中数据是按照“后进先出”方式进出栈的。
向栈中添加/删除数据时，只能从栈顶操作。

stack是标准库中的一个容器适配器，是个类模板，使用的时候需要实例化，int是模板实参。

（1）头文件

#include <stack>

（2）定义和使用stack

stack<int> s1;

//常用函数
s1.push(x); //入栈
s1.pop(); //出栈，删除栈顶元素，并不返回该元素
s1.top(); //访问栈顶元素
s1.empty(); //判断栈空，当栈空时，返回true
s1.size(); //访问栈中的元素个数

四、队列

队列是一种线性存储结构，它有以下几个特点：

队列中数据按照“先进先出”方式进出队列。
队列只允许在“队首”进行删除操作。
在“队尾”进行插入操作。

（1）头文件

#include <queue>

（2）定义和使用方法

queue<int> q;

q.push(x);//入队，将X接到队列的末端
q.pop()；//出队，弹出队列的第一个元素，注意，并不会返回被弹出元素的值
q.front();//访问队首元素，即最早被压入队列的元素
q.back(); //访问队尾元素，最后被压入队列的元素
q.empty();//判断队列空，当队列空时，返回true
q.size(); //访问队列中的元素个数