数据结构

• 1、向量 vector
• • 1.1介绍
  • 1.2初始化
  • 1.3常用内置函数
  • 1.4
• 2、链表 list
• • 2.1介绍
• 3、栈 stack
• • 3.1介绍
  • 3.2常用内置函数
• 4、队列 queue
• • 4.1介绍
  • 4.2常用内置函数
• 5、集合 set
• • 5.1介绍
  • 5.2常用内置函数
• 6、映射 map
• • 6.1介绍
  • 6.2常用内置函数
• 7、树 tree
• • 7.1介绍
• 8、堆 heap

1、向量 vector

1.1介绍

进行vector操作前应添加头文件#include<vector>

vector是向量类型，可以容纳许多类型的数据（int，double，string，结构体），因此也被称为容器

(可以理解为动态数组，是封装好了的类）

1.2初始化

vector<int> a
（尖括号为元素类型名，它可以是任何合法的数据类型）
1、

定义具有10个整型元素的向量，不具有初值，其值不确定
vector<int>a(10);

2、

定义具有10个整型元素的向量，且给出的每个元素初值为1
vector<int>a(10,1);

3、

用向量b给向量a赋值，a的值完全等价于b的值
vector<int>a(b);

4、

将向量b中从0-2（共三个）的元素赋值给a，a的类型为int型
vector<int>a(b.begin(),b.begin()+3);

5、

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

1.3常用内置函数

#include<vector>
vector<int> a,b;

//b为向量，将b的0-2个元素赋值给向量a
a.assign(b.begin(),b.begin()+3);

//a含有4个值为2的元素
a.assign(4,2);

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

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

//返回a的第i元素,当且仅当a存在
a[i];

//清空a中的元素
a.clear();

//判断a是否为空，空则返回true，非空则返回false
a.empty();

//删除a向量的最后一个元素
a.pop_back();

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

//在a的最后一个向量后插入一个元素，其值为5
a.push_back(5);

//在a的第一个元素（从第0个算起）位置插入数值5,
a.insert(a.begin()+1,5);

//在a的第一个元素（从第0个算起）位置插入3个数，其值都为5
a.insert(a.begin()+1,3,5);

//b为数组，在a的第一个元素（从第0个元素算起）的位置插入b的第三个元素到第5个元素（不包括b+6）
a.insert(a.begin()+1,b+3,b+6);

//返回a中元素的个数
a.size();

//b为向量，将a中的元素和b中的元素整体交换
a.swap(b);

1.4

错误赋值：

vector<int>a;
for(int i=0;i<10;++i){a[i]=i;}//下标只能用来获取已经存在的元素

查找

int a[6]={1,2,3,4,5,6};
vector<int>b(a,a+4);
for(int i=0;i<=b.size()-1;++i){cout<<b[i]<<" ";}

for(vector<int>::iterator it=b.begin();it!=b.end();it++){cout<<*it<<"  ";}

三个常用算法

 #include<algorithm>
 
 //对a中的从a.begin()（包括它）到a.end()（不包括它）的元素进行从小到大排列
 sort(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()（不包括它）的元素中查找10，若存在返回其在向量中的位置
  find(a.begin(),a.end(),10);

2、链表 list

2.1介绍

链表是物理上非连续，逻辑上连续的一种存储结构。数据元素的逻辑顺序是通过链表的指针地址实现，每个元素包含两个结点，一个是存储元素的数据域 (内存空间)，另一个是指向下一个结点地址的指针域。根据指针的指向，链表能形成不同的结构，例如单链表，双向链表，循环链表等。

3、栈 stack

3.1介绍

栈（stack）又名堆栈，是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作入栈，就是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈，它是把栈顶元素删除掉，使前一个元素成为新的栈顶元素。

3.2常用内置函数

#include<stack>
stack<int> stack1;
stack1.push(element);//入栈
stack1.pop();    //出栈
stack1.empty();    //是否为空
stack1.size();     //元素个数
stack1.top();    //判断是否为栈顶元素

4、队列 queue

4.1介绍

队列也是一种线性表，是一种先进先出的线性结构。队列只允许在表的一端进行插入（入队）、删除（出队）操作。允许插入的一端称为队尾，允许删除的一端称为队头。

4.2常用内置函数

 #include<queue>
        queue<int> queue1;
        queue1.push(element);    //加入队列顶部
        queue1.pop();    //弹出队列里第一个元素
        queue1.back();    //队列最后一个元素
        queue1.front();    //队列第一个元素
        queue1.size();    //队列元素个数
        queue1.empty;    //队列是否为空

5、集合 set

5.1介绍

特点是不会存在有重复的元素，特殊的容器

5.2常用内置函数

#include<set>
set<int> s;     //创建一个整型集合：s
s.insert(element);     //插入一个元素，并会自动排序（在没有自定义的情况下，缺省升序排列）
s.size();     //当前容器中元素个数
set<int>::iterator it;//定义向前迭代器
    for(it=s.begin();it!=s.end();it++)//遍历集合中的所有元素
    {
        if(it==s.end())
         cout <<*it;
        else
         cout <<*it<<" ";
    }

(集合交集)

6、映射 map

6.1介绍

Map是STL的一个关联容器，它提供一对一（其中第一个可以称为关键字，每个关键字只能在map中出现一次，第二个可能称为该关键字的值，可以重复）的数据处理能力，由于这个特性，它完成有可能在我们处理一对一数据的时候，在编程上提供快速通道。

6.2常用内置函数

#include<map>
map<string,int> map1;    //创建一个map类型，健（key)为string型，值（value）为int型。是健到值得一种映射。
map1.size()
map1.insert(pair<string,int>("month",1));     //插入一个元素
map1["month"]=1;   // 插入一个元素
map1.find("month")    //查找该健，如果没有找到返回最后一位元素后面的迭代器
map1.count("month")    //查找健"month"出现的次数，但是map中健都是单一且按照升序排列的，只有0和1两中情况
map1.earse("month")  //删除month-1这一键值对
//因为map在创建的时候是有序的，所以查找效率是：logn。
map<string,int>::iterator iter;  
    for(iter = map1.begin(); iter != map1.end(); iter++)  
       cout<<iter->first<<' '<<iter->second<<endl;
       cout<<(*iter).first<<' '<<(*iter).second<<endl;

map<string,int>::iterator iter;
m.insert(pair<string,int>(“Mon”,1));
iter=m.find(“Mon”);
cout<second;

7、树 tree

7.1介绍

树是一种数据结构，它是由n（n>=1）个有限节点组成一个具有层次关系的集合。把它叫做 “树” 是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：

1、每个节点有零个或多个子节点；
2、没有父节点的节点称为根节点；
3、每一个非根节点有且只有一个父节点；
4、除了根节点外，每个子节点可以分为多个不相交的子树；
在日常的应用中，我们讨论和用的更多的是树的其中一种结构，就是二叉树。

二叉树是树的特殊一种，具有如下特点：

1、每个结点最多有两颗子树，结点的度最大为2。
2、左子树和右子树是有顺序的，次序不能颠倒。
3、即使某结点只有一个子树，也要区分左右子树。
两类特殊的二叉树：

8、堆 heap

堆是一种比较特殊的数据结构，可以被看做一棵树的数组对象，具有以下的性质：

1、堆中某个节点的值总是不大于或不小于其父节点的值；
2、堆总是一棵完全二叉树。
将根节点最大的堆叫做最大堆或大根堆，根节点最小的堆叫做最小堆或小根堆。

因为堆有序的特点，一般用来做数组中的排序，称为堆排序。

标签：begin,end,07,元素,29,map1,2021,节点,向量
来源： https://blog.csdn.net/Lzh4792/article/details/119221608