总结一下模板\(≧▽≦)/

二叉树的各种操作：

#include<stdio.h>
#include<string.h>
#include<malloc.h>
#include<stdlib.h>
typedef struct node
{
char data;
struct node *lchild,*rchild;
}*Tree;
void CreateBitree(Tree &p) //建树
{
char ch;
scanf("%c",&ch);
if(ch==',')
p=NULL;
else
{
p=new node;
p->data=ch;
CreateBitree(p->lchild);
CreateBitree(p->rchild);
}
return ;
}
void xpreorder(Tree p) //输出先序
{
if (p)
{
printf("%c ",p->data);
xpreorder(p->lchild);
xpreorder(p->rchild);
}
}
void zpreorder(Tree p) //输出中序
{
if(p)
{
zpreorder(p->lchild);
printf("%c",p->data);
zpreorder(p->rchild);
}
}
void hpreorder(Tree p) //输出后序
{
if(p)
{
hpreorder(p->lchild);
hpreorder(p->rchild);
printf("%c",p->data);
}
}
void ycount(Tree p,int &count) //求二叉树叶子节点
{
if(p)
{
if(p->lchild==NULL&&p->rchild==NULL)
{
count++;
return ;
}
if(p->lchild) ycount(p->lchild,count);
if(p->rchild) ycount(p->rchild,count);
}
}
int sleaf(Tree p)  //求二叉树深度
{
int high=0;
if(!p) return high;
int n=sleaf(p->lchild);
int m=sleaf(p->rchild);
high=m>n?m:n;
return high+1;
}
int main()
{
node *p;
CreateBitree(p);
xpreorder(p);
printf("\n");
zpreorder(p);
printf("\n");
hpreorder(p);
printf("\n");
int countleaf=0;
ycount(p,countleaf);
printf("%d\n",countleaf);
printf("%d\n",sleaf(p));
return 0;
}

有先序和中序求后序：

#include<stdio.h>
#include<string.h>
#include<malloc.h>
struct node
{
char data;
struct node *lchild,*rchild;
};
void Bian(struct node *p)
{
if(p->lchild!=NULL)
Bian(p->lchild);
if(p->rchild!=NULL)
Bian(p->rchild);
printf("%c",p->data);

}
struct node*buildtree(struct node *p,char *pre,char*mid,int n)
{
if(n<=0)
return NULL;
p=(struct node*)malloc(sizeof(struct node));
p->data=pre[0]; //先序的第一个数是根节点
int q=strchr(mid,pre[0])-mid;  //根节点在中序中的位置好找到左子树和右子树
p->lchild=buildtree(p->lchild,pre+1,mid,q);
p->rchild=buildtree(p->rchild,pre+q+1,mid+q+1,n-q-1); //无限递归
return p;
}
int main()
{
char pre[1001],mid[1001];
gets(pre);
gets(mid);
int n=strlen(pre);
struct node *root;
root=buildtree(root,pre,mid,n);
Bian(root);
printf("\n");
return 0;
}

中序和后序求先序：

void Bian(struct node *p)
{
if(p)
{
printf("%c",p->data);
Bian(p->lchild);
Bian(p->rchild);
}
}
struct node*buildtree(struct node *p,char *mid,char*aft,int n)
{
if(n<=0)
return NULL;
p=(struct node*)malloc(sizeof(struct node));
p->data=aft[n-1];
int q=strchr(mid,aft[n-1])-mid;
p->lchild=buildtree(p->lchild,mid,aft,q);
p->rchild=buildtree(p->rchild,mid+q+1,aft+q,n-q-1);
return p;
}

字典树：参考<Message Flood>

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>
char str1[21000][15],str2[15];
struct node
{
int flag;
struct node *next[26]; //数字定义10，英文字母定义26
};
struct node *creat()
{
int i;
struct node *p;
p=new node;
for(i=0; i<26; i++)
{
p->next[i]=NULL;
}
p->flag=0;
return p;
} //是根节点的26个方向都指向空
void Insert(struct node *p,char *s) //建字典树树
{
int i,n,num;
n=strlen(s);
for(i=0; i<n; i++)
{
if(s[i]>='A'&&s[i]<='Z') num=s[i]-'A';
else if(s[i]>='a'&&s[i]<='z') num=s[i]-'a';
if(p->next[num]==NULL) p->next[num]=creat();//如果p指向的为空，则继续向下建树
p=p->next[num];
}
p->flag=1;//记录完整的字符串
}
int Search(struct node *p,char *s) //查找
{
int i,n,num;
n=strlen(s);
for(i=0; i<n; i++)
{
if(s[i]>='A'&&s[i]<='Z') num=s[i]-'A';
else if(s[i]>='a'&&s[i]<='z') num=s[i]-'a';
if(p->next[num]==NULL) return 1;
p=p->next[num];
}
if(p->flag==1)
{
p->flag=0; //防止被查找的有重复的，被查找过便使其为0
return 0;
}
return 1;
}
void Delete(struct node*p) //释放内存！！很重要！！否则会超时
{
int i;
for(i=0; i<26; i++)
{
if(p->next[i]!=NULL)
Delete(p->next[i]);
}
free(p);
}
int main()
{
int i,n,m;
struct node *p;
while(~scanf("%d",&n)&&n)
{
scanf("%d",&m);
p=creat();
for(i=0; i<n; i++)
{
scanf("%s",str1[i]);
}
for(i=0; i<m; i++)
{
scanf("%s",str2);
Insert(p,str2);
}
int s=0;
for(i=0;i<n;i++)
{
if(Search(p,str1[i]))
++s;
}
printf("%d\n",s);
Delete(p);
}
return 0;
}

图的基础知识：之前bfs也不太会用，就当也算是bfs的模板吧

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>
struct node
{
int x;
int y;
int ans;
}q[2100];
int map[11000][1100],v[1100];
int k;
void bfs(int x)
{
int e=0,s=0,i;
node t,f;
t.x=x,t.ans=0;
q[e++]=t;
v[t.x]=1;
while(s<e)
{
t=q[s++];
if(t.x==1)
{
printf("%d\n",t.ans);
return ;
}
for(i=1; i<=k; i++)
{
f.x=i;
if(v[f.x]==0&&map[t.x][f.x]==1)
{
f.ans=t.ans+1;
q[e++]=f;
v[f.x]=1;
}
}
}
printf("NO\n");
return ;
}
int main()
{
int n,m,i,u,w,t;
while(~scanf("%d%d",&k,&m))
{
memset(map,0,sizeof(map));
memset(v,0,sizeof(v));
for(i=0; i<m; i++)
{
scanf("%d%d",&u,&w);
map[u][w]=1; //有向的
//map[w][u]=1; 若都写为无向的
}
bfs(k);
}
return 0;
}

#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<malloc.h>
int map[11000][100];
int v[100];
int flag,k;
struct node
{
int u,v,w;
node *next;
}*head[11000];
void dfs(int i)
{
if(flag==0)
{
printf("%d",i);
flag=1;
}
else
printf(" %d",i);
for(int j=1;j<k;j++)
{
if(map[i][j]==1&&v[j]==0) //无限递归 只有当之间有路且没被访问过
{
v[j]=1; //标志被访问过
dfs(j);
}
}
}
int main()
{
struct node *p;
int n,m,i,x,y;
scanf("%d",&n);
while(n--)
{
flag=0;
scanf("%d%d",&k,&m);
memset(map,0,sizeof(map));
memset(v,0,sizeof(v));
for(i=0;i<m;i++)
{
scanf("%d%d",&x,&y);
map[x][y]=1;
map[y][x]=1; //无向的
}
for(i=0;i<k;i++) //从小的编号开始
{
if(v[i]==0)
dfs(i);
}
printf("\n");
}
return 0;
}

并查集

#include "stdio.h"
int bin[1002];
int findx(int x) //查找根结点
{
int i,j
int r=x;
while(bin[r] !=r)
r=bin[r];
i = x;
while (i != r) //本循环修改查找路径中所有节点
{
j = bin[i];
bin[i] = r;
i = j;
}
return r; //路径压缩。。很省时间
}
void merge(int x,int y)
{
int fx,fy;
fx = findx(x);
fy = findx(y);
if(fx != fy)
bin[fx] = fy;
}
int main()
{
int n,m,i,x,y,count;
while(scanf("%d",&n),n)
{
for(i=1; i<=n; i++)
bin[i] = i;
for(scanf("%d",&m);)
{
scanf("%d %d",&x,&y);
merge(x,y);
}
count=0;
for(, i=1; i<=n; i++)
if(bin[i] == i)
count ++;
printf("%d\n",count-1);
}
}

整理的不是很好。。但是已经是我这个星期所学的知识都在这里了。。嘿嘿~