刷题技巧
输入int类型的01，默认输入1
for(int i=0;~b;i++) 这里的~b为b!=-1
memset(数组名，赋的初值，sizeof 数组名) 初始化数组
单链表
在解决图和树的数据结构问题时，常常用邻接表来存储。邻接表是由很多条单链表构成的，而单链表的实现方式有很多，如数组，结构体，vector等容器实现，在这些实现方式中，静态数组的速度是最快的。
- 传统结构体表示链表
struct Node{
int value;
Node* next;
}
每次创建新的链表节点，都需要new一个新的结构体，在竞赛级别的算法题目里，链表的长度都是十万百万级，如果每次创建一个新节点都new一次，光创建出这个链表就已经超时了。
- 静态数组表示
这里的静态和动态其实是指是否需要重复开辟空间。提前开辟好空间以后用这些空间去表示称为静态，与之对应的每次都需要开辟空间称为动态。
那，如何表示呢？
e[N], ne[N], head, idx来表示一个单链表！
**e[N]**存放每一个节点的值，**ne[N]**存放下一个节点的下标，head指向头结点，idx表示已经用到了数组中的哪个节点。
- 具体操作
// 初始化
void init()
{
head = -1;
idx = 0;
}
// 将x插到头结点
void add_to_head(int x)
{
e[idx] = x, ne[idx] = head, head = idx ++ ;
}
// 将x插到下标是k的点后面
void add(int k, int x)
{
e[idx] = x, ne[idx] = ne[k], ne[k] = idx ++ ;
}
// 将下标是k的点后面的点删掉
void remove(int k)
{
ne[k] = ne[ne[k]];
}
邻接表
用邻接表表示一棵树
用idx，h[N]，ne[N]，e[N]表示
h[N]用于存放邻接表的表头
构建树
add(int parent_id,int child_id){
//为值为parent_id的父节点添加一个值为child_id的子节点
e[idx] = child_id,ne[idx]=h[parent_id],h[parent_id] = idx++;
}
- e[]的索引是idx，值是节点中存放的值
- ne[]的索引是idx，值是下一个节点的idx
- h[]的索引是节点中存放的值，值是下一个节点的idx
树的遍历
- 前序遍历，中序遍历，后续遍历（DFS）
- 前序遍历 (preorder) 根左右
- 中序遍历 (inorder)左跟右
- 后续遍历 (postorder)左右跟
倒推
- 前序的第一个是root，后序的最后一个是root。
- 先确定跟节点，然后根据中序遍历，在根左边的为左子树，根右边的为右子树
- 对于每一个子树可以看成一个全新的树，仍然遵循上面的规律。
划重点！！根据上面的推论，只要确定了根节点的位置，根据中序遍历我们就能确定左右子树的位置，递归从而构建出整个二叉树。也就是说，我们知道一颗二叉树前序遍历和中序遍历或者后续遍历和中序遍历，就能构建二叉树，而知道前序遍历和后续遍历则不行。
// 一边建树一边遍历
#include<bits/stdc++.h>
using namespace std;
const int N = 50010;
unordered_map<int,int> l,r,pos;
int in[N],pre[N],n;
vector <int> post;
int build(int il,int ir,int pl,int pr){
int root = pre[pl];
int k = pos[root];
if(il<k) l[root] = build(il,k-1,pl+1,pl+1+k-1-il);
if(k<ir) r[root] = build(k+1,ir,pl+1+k-il,pr);
// 一边建树 一边遍历
post.push_back(root);
return root;
}
int main(){
cin>>n;
for(int i=0;i<n;i++){
cin>>pre[i];
}
for(int i=0;i<n;i++){
cin>>in[i];
pos[in[i]]=i;
}
int root=build(0,n-1,0,n-1);
cout<<post[0];
return 0;
}
- 层序遍历（BFS）
//p存放层序遍历的结果，l存放父节点的左儿子，r存放父节点的右儿子
void bfs(int root){
p[0] = root;
int hh=0,kk=0;
while(hh<=kk){
int t = p[hh++];
if(l.count(t)) p[++kk] = l[t];
if(r.count(t)) p[++kk] = r[t];
}
cout<<p[0];
for(int i=1;i<n;i++) cout<<' '<<p[i];
}
并查集
- 并查集有思维巧妙，代码简短的特点，是面试热点问题。
简单描述一下并查集
现在有两个集合a和b，从这两个集合中取出任意一个元素，如何判断该元素属于哪个集合？以及如何快速将两个集合合并？
–常见思路–
定义一个belong[]数组存储元素归属
if(belong[x]=='a') puts('a');
else puts('b');
定义数组操作，查询元素归属的时间复杂度是O(1)；但合并两个操作呢？
只能在定义一个新的数组，然后把每个集合中的元素都存进去，时间复杂度为O(n)！
有没有什么办法实现这两个操作且时间复杂度低？
并查集可以在近乎O(1)的时间复杂度下实现这两个操作!!
- 将集合中的元素存在树中，定义一颗树的跟节点为这个集合的id，定义一个数组p[]存取每个元素的父节点, x的父节点是p[x],而根节点的父节点就是其本身，即p[x]=x，所以我们只要一直不断向上查询这个元素的根节点，就能知道归属。
- 对于合并集合，由于这两个集合是以两颗树的形式存在，我们只要让一颗树的根节点的父节点为另一颗树的根节点，即可把这两颗树连起来。
代码实现
- p[]数组存放每个元素的父节点，即x的父节点是p[x]
- find(int x)：查找某一元素的根节点
- 判断归属 if( find(a) == find(b) ) 属于同一个集合
- 合并 p[find(a)] = find(b)
- 如何实现find()函数
//常规思路，由于每次都要while一遍，所以查找根节点的时间复杂度是个问题
int find(int x){
while(p[x]!=x) x = p[x];
return x;
}
// 采用路径压缩优化，路径压缩就是在查询根节点的过程中，将路径上的每一个节点的父节点都
//重新设置为根节点，避免重复查找，这样时间复杂度可以近乎缩减为O(1);
int find(int x)
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
#include<bits/stdc++.h>
using namespace std;
const int N = 100010;
int p[N];
int find(int x) // 返回x的祖宗节点 + 路径压缩
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
int main(){
int n,m;
cin>>n>>m;
for(int i=1;i<=n;i++){
p[i] = i;
}
while(m--){
char ins;
int a,b;
cin>>ins>>a>>b;
if(ins=='M') p[find(a)] = find(b);
else{
if(find(a)==find(b)) puts("Yes");
else puts("No");
}
}
return 0;
}
二叉树
二叉树可以用两个数组 l[N] , r[N] 来表示, N 为节点数量，l[i] 记录节点 i 的左儿子，r[i] 记录节点i的右儿子
二叉树三种深度遍历
// k用来记录当前位置，满足pat空格检测输出
void dfs_pre(int root,int &k){
if(root == -1) return;
if(++k == n) cout<<root;
else cout<<root<<' ';
dfs_pre(l[root],k);
dfs_pre(r[root],k);
}
void dfs_in(int root,int &k){
if(root == -1) return;
dfs_in(l[root],k);
if(++k == n) cout<<root;
else cout<<root<<' ';
dfs_in(r[root],k);
}
void dfs_post(int root,int &k){
if(root == -1) return;
dfs_post(l[root],k);
dfs_post(r[root],k);
if(++k == n) cout<<root;
else cout<<root<<' ';
}
二叉树的广度优先遍历
void bfs(int root){
q[0] = root;
int hh=0,tt=0;
while(hh<=tt){
int t = q[hh++];
if(l[t]!=-1) q[++tt] = l[t];
if(r[t]!=-1) q[++tt] = r[t];
}
}
二叉搜索树
二叉搜索树 (BST) 递归定义为具有以下属性的二叉树：
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值
- 若它的右子树不空，则右子树上所有结点的值均大于或等于它的根结点的值
- 它的左、右子树也分别为二叉搜索树
如果是一棵二叉搜索树，那么其中序遍历必然为一组升序排列的数列！
c++里set容器就是用二叉搜索树实现的
完全二叉树可以用一维数组存储
反转二叉树
#include<bits/stdc++.h>
using namespace std;
const int N = 11;
int l[N],r[N],q[N],n;
bool has_father[N];
void dfs_re(int root){
if(root == -1) return;
dfs_re(l[root]);
dfs_re(r[root]);
swap(l[root],r[root]);
}
void bfs(int root){
q[0] = root;
int hh=0,tt=0;
while(hh<=tt){
int t = q[hh++];
if(l[t]!=-1) q[++tt] = l[t];
if(r[t]!=-1) q[++tt] = r[t];
}
cout<<root;
for(int i=1;i<n;i++){
cout<<' '<<q[i];
}
cout<<endl;
}
void dfs_in(int root,int &k){
if(root == -1) return;
dfs_in(l[root],k);
if(++k == n) cout<<root;
else cout<<root<<' ';
dfs_in(r[root],k);
}
int main(){
// 初始化
memset(r,-1,sizeof r);
memset(l,-1,sizeof l);
// 读入数据
cin>>n;
for(int i=0;i<n;i++){
char a,b;
cin>>a>>b;
if(a!='-'){
l[i]=a-'0';
has_father[l[i]] = true;
}
if(b!='-'){
r[i]=b-'0';
has_father[r[i]] = true;
}
}
int root = 0;
// 寻找根节点
while(has_father[root]) root++;
// 反转二叉树
dfs_re(root);
// 输出层序遍历
bfs(root);
// 输出中序遍历
int k = 0; // 负责记录当前位置来判断是否需要输出空格
dfs_in(root,k);
return 0;
}