树的邻接表储存与遍历，给自己留个成长记录吧

我这里树的储存和图的存储一样啦~

先是用前叉式链表的邻接表版本。

//自己给自己出了一个题，给你树的点数n，根节点永远是1，让你从根节点把这个遍历一遍。
//接下来有n-1组ai和bi，代表ai和bi有边。
#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int maxv=1e5+10;
const int maxe=1e5+10;
const int inf=0x3f3f3f3f;

int head[2*maxv];
struct EDGE
{
    int d,next;
    EDGE():next(-1){};
}e[maxe*2];
int which=1;

void add(int s,int d)//这里模拟了前叉式链表。
{
    e[which].d=d;
    e[which].next=head[s];
    head[s]=which++;
}

int n;
bool vis[maxv];
//由于用邻接表实现树的储存，而且输入时候又不是按照一定顺序，所以出来的序列不一定是严格的前序遍历。
//这是由我给定的条件决定的。 不过这个dfs一定能遍历所有的点。
void dfs(int x)
{
    if(!vis[x])
    {
        printf("%d ",x);
        vis[x]=1;
        for(int i=head[x];i!=-1;i=e[i].next)
        {
            int d=e[i].d;
            if(!vis[d])
            {
                dfs(d);
            }
        }
    }
}
int main()
{
    while(scanf("%d",&n)==1)
    {
        memset(e,0,sizeof(e));
        memset(head,-1,sizeof(head));
        memset(vis,0,sizeof(vis));
        which=1;

        for(int i=1;i<=n-1;i++)
        {
            int s,d;
            scanf("%d%d",&s,&d);
            //这里要求给无向图。
            add(s,d);
            add(d,s);
        }

        dfs(1);
        printf("\n");
    }
}

这个head数组之前一直是用着而已没有考虑过它的实际到底意味着什么，只是囫囵吞枣。

思考了一番，head数组存的是最后一个插入到起点是下标的边的标号。

而整个表的寻找都是通过边储存的关系来模拟的，所有的找下一个的操作，全部用的是边的序号。

举个遍历边表的例子：

head[x]，

首先x是head[x]所存储的最后一个插入的边的序号。

通过这个序号，找到对应边，边的信息中已经储存了下一个边的序号，获得下一个边的序号。

然后继续这个过程。最终会找到next是-1的边，那么遍历以x为起点的边表就结束了。

这个代码中并没有一个实际的链表，而是靠储存的信息模拟了链表。

下面是自己想出来的模拟后插式链表的方法。

同样这个也是以边的序号为引索的，只不过这个用vector的又一个实际的“链表”。

举个遍历的例子：

head[x]。

请注意head[x]不是一个元素而是一个数组。

他里面盛着以x为起点的所有边的序号。

插入这个“链表”的时候是用vector的push_back函数，很方便。

这样我们遍历时候只需要遍历从head[x]的下标为0到head[x].size()-1就可以轻松地找到边表的所有边。

这里“链表”储存的仍然是边的序号。

并不是教科书上的点的序号。

//自己给自己出了一个题，给你树的点数n，根节点永远是1，让你从根节点把这个遍历一遍。
//接下来有n-1组ai和bi，代表ai和bi有边。
#include <iostream>
#include <string>
#include <cstring>
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
const int maxv=1e5+10;
const int maxe=1e5+10;
const int inf=0x3f3f3f3f;

struct EDGE
{
    int s,d;
}e[maxe*2];

//这里模拟后插式链表（不过并不是典型的邻接表），用vector实现了，不知道效率怎样，是自己想的。
vector<int> head[maxe];
//head[1]代表头结点为1的点所连的边的序号数组。

int n;
bool vis[maxv];
//这个遍历方式一定能遍历所有点，但是并不一定是前序遍历，因为输入的顺序不一定。
void dfs(int x)
{
    if(!vis[x])
    {
        printf("%d ",x);
        vis[x]=1;
        for(int i=0;i<head[x].size();i++)
        {
            int enumber=head[x][i];
            int d=e[enumber].d;
            if(!vis[d])
            {
                dfs(d);
            }
        }
    }
}

int main()
{
    while(scanf("%d",&n)==1)
    {
        for(int i=0;i<n;i++) head[i].clear();
        memset(e,0,sizeof(e));
        memset(vis,0,sizeof(vis));
        which=1;

        for(int i=1;i<=n-1;i++)
        {
            int s,d;
            scanf("%d%d",&s,&d);
            e[i].s=s;
            e[i].d=d;
            //这里要求给无向图。
            head[s].push_back(i);
            head[d].push_back(i);
        }

        dfs(1);
        printf("\n");
    }
}

接下来这个是真的链表啦~

用vector来实现。

//自己给自己出了一个题，给你树的点数n，根节点永远是1，让你从根节点把这个遍历一遍。
//接下来有n-1组ai和bi，代表ai和bi有边。
#include <bits/stdc++.h>
using namespace std;
const int maxv=1e5+10;
const int maxe=1e5+10;
const int inf=0x3f3f3f3f;

int n;
bool vis[maxv];
vector<int> G[maxv];
void dfs(int x)
{
    if(!vis[x])
    {
        printf("%d ",x);
        vis[x]=1;
        for(int i=0;i<G[x].size();i++)
        {
            int d=G[x][i];
            if(!vis[d])
            {
                dfs(d);
            }
        }
    }
}

int main()
{
    while(scanf("%d",&n)==1)
    {
        memset(vis,0,sizeof(vis));
        for(int i=1;i<=n-1;i++)
        {
            int s,d;
            scanf("%d%d",&s,&d);
            G[s].push_back(d);
            G[d].push_back(s);
        }
        dfs(1);
    }
}

G就是整个图的邻接表。

遍历某个点的边表，举个例子

G[x]。

G[x]是一个数组，里面存的就是G[x]所有的点的序号，后插的顺序。

遍历这个点相邻的边时候，直接for(int i=0;i<G[x].size();i++)就可以了。