王道考研408 数据结构 5.4 树、森林与6.3 图的遍历

5.4 树、森林

5.4.04

编程求以孩子兄弟表示法存储的森林的叶子结点数

思路：只要求出左孩子指针为空的所有结点即可

typedef struct CSNode{
    ElemType data;
    struct CSNode *firstchild, *nextsibling;
}CSNode, *CSTree;
int leaf_node(CSNode tree){
    if(tree == NULL) return 0;
    if(tree->firstchild!=NULL) return leaf_node(tree->nextsibling)+1;
    else return leaf_node(tree->firstchild)+leaf_node(tree->nextsibling);
}

5.4.05

以孩子兄弟链表为存储结构，请设计递归算法求树的深度

int height(CSNode tree){
	int hc,hs;
    if(tree == NULL) return 0;
    else{
		hc = height(tree->firstchild);
        hs = height(tree->nextsibling);
        if(hc+1>hs) return hc+1;
        else return hs;
    }
    return 0;
}

5.4.06

已知一棵树的层次序列以及每个结点的度，编写算法构造此树的孩子-兄弟链表

看都看不懂，直接抄答案

#define maxNodes 15
void createCSTree_Degree(CSTree &T, DataType e[], int degree[], int n)//e表示层次序列；degree表示各节点的度
{
    CSNode *pointer = new CSNode[maxNodes];
    int i,j,d,k;
    for(i = 0; i < n;i++){
        pointer[i]->data = e[i];
        pointer[i]->lchild = pointer[i]->rsibling = NULL;
    }//初始化
    for(i = 0; i < n; i++){
        d = degree[i];
        if(d){
            k++;
            pointer[i]->lchild = pointer[k];
            for(j = 2; j <= d; j++){
                k++;
                pointer[k-1]->rsibling = pointer[k];
            }
        }
    }// end for
    T = pointer[0];//没有[0]结果一样
    delete [] pointer;//这步感觉有点问题，不过伪代码whatever
}

6.3 图的遍历

6.3.02

试设计一个算法，判断一个无向图G是否为一棵树，若是一棵树，则算法返回true，否则返回false

bool isTree(Graph &G)
{
    for(i = 1; i<=G.vexnum; i++)
        visited[i] = False;
    int Vnum = 0, Enum = 0;
    DFS(G,1, Vnum, Enum, visited);
    if(Vnum == G.vexnum && Enum == 2*(G.vexnum - 1))
        return true;
    else return false;
}
void DFS(Graph &G, int v, int & Vnum, int &Enum, int visited[])
{
    visited[v] = True;
    Vnum++;
    int w = FirstNeighbor(G, v);
    while(w!=-1){
        Enum++;
        if(!visited[w]) DFS(G, w, Vnum, Enum, visited);
        w = NextNeighbor(G, v, w);
    }
}

6.3.03

写出图的深度优先搜索DFS算法的非递归算法

void DFS_NoCircle(Graph &G, int v)
{
    int w;
    InitStack(S);
    for(i = 0; i<G.vexnum; i++)
        visited[i] = False;
    Push(S, v);
    visited[v] = True;
    while(!IsEmpty(S)){
        K = pop(S);
        visit(K);
        for(w = FirstNeighbor(G, k); w>=0; w = NextNeighbor(G, k, w))
            if(!visited[w]){
                Push(S, w);
                visited[w] = True;
            }
    }
}

6.3.04

分别采用基于深度优先遍历和广度优先遍历算法判别以邻接表方式存储的有向图中是否存在由顶点vi到顶点vj的路径。注意：算法中涉及的图的基本操作必须在存储结构上实现。

cnm这我怎么可能会啊！！捏麻

//深度搜索
int visited[MaxSize] = {0};//完全不能这么写好嘛！
void DFS(ALGraph G, int i, int j, bool &can_reach)
{
    if(i == j){
        can_reach = True;
        return;
    }
    visited[i] = 1;
    for(int p = FirstNeighbor(G, i); p>=0; p = NextNeighbor(G, i, p))
        if(!visited[p] && !can_reach)
            DFS(G, p, j, can_reach);
}
//广度搜索
int visited[MaxSize] = {0};
int BFS(ALGraph G, int i, int j) //如果有就返回1，没有就返回0
{
    InitQueue(Q); Enqueue(Q,i);
    while(!Empty(Q))
    {
        DeQueue(Q,u);
        visited[u] = 1;
        if(u == j) return 1;
        for(int p = FirstNeighbor(G,i); p>0; p = NextNeighbor(G, u, p))
        {
            if(p == j) return 1;
            if(!visited[p]){
                Enqueue(Q,p);
                visited[p] = 1;
            }
        }
    }
    return 0;
}

哦我好像会的，那没事了

6.3.05

假设图用邻接表表示，设计一个算法，输出从顶点Vi到顶点Vj的所有简单路径

//深搜，直接用个数组记录一下路径就行了
void FindPath(AGraph *G, int u, int v, int path[], int d)
{
    int w,i;
    ArcNode *p;
    d++;
    path[d] = u;
    visited[u] = 1;
    if(u == v) print(path);//呃呃
    p = G->adjlist[u].firstarc; //指向第一个相邻点，这一步是不严谨的，应该重新写个函数来调用，不过你懂得
    while(p != NULL){
        w = p->adjvex;
        if(visited[w] == 0)
            FindPath(G,w,v,path,d);//path能这么传参我直接吃
        p = p->nextarc;
    }
    visited[u] = 0;
}

后记

不想编程啊，编程感觉身上有蚂蚁在爬。