第九章 图

9.6有向图用邻接矩阵存储，设计算法求解顶点V的出度入度

void getDegree(Graph &G,int &i,int &ind,int &outd){
    //ind,outd分别为入度和出度
    int j,ind=0,outd=0;
    //求顶点i的入度
    for(j=1;j<=G.VerNum;j++){
        if(G.AdjMatrix[j][i]>=1&&G.AdjMatrix[j][i]<INF)
            id++;
    }
    //求顶点i的出度
    for(j=1;j<=G.VerNum;j++){
        if(G.AdjMatrix[i][j]>=1&&G.AdjMatrix[i][j]<INF)
            outd++;
    }
    //总的度
    deg=ind+outd;
}

9.7图G使用邻接矩阵存储，设计算法实现函数firstadj(G,v),nextadj(G,v,w)

//求顶点V的第一个邻接点
int firstadj(G,v){
    int w;
    for(w=1;w<=G.VerNum;w++){
        if(G.AdjMatrix[v][w]>=1&&G.AdjMatrix[v][w]<INF){
            return w;
        }
    }
    return 0;
}

// 求顶点V位于w后面的第一个邻接点
int nextadj(G,v,w){
    int i;
    fow(i=w+1;i<=G.VerNum;i++){
        if(G.AdjMatrix[v][i]>=1&&G.AdjMatrix[v][i]<INF)
            return i;
    }
    return 0;
}

9.8 图G用邻接矩阵A[n+1,n+1]表示，设计算法判断G是否为无向图

bool isUdg(Graph G){
    int i,j;
    for(i=1;i<=G.VerNum;i++){
        for(j=1;j<=G.VerNum,j++){
            if(G.AdjMatrix[i][j]!=G.AdjMatrix[j][i])//出现一点不对称就不是无向图
                return false;
        }
    }
    //循环结束，再判定边数是否小于等于n(n-1)/2
    if(G.verNum<=G.VerNum*(G.VerNum-1)/2)
        return true;
    else
        return false;
}

9.9 图G用邻接表存储，设计算法输出所有的边或弧

void getEdge(Graph G,int E[MaxVerNum+1][MaxVerNum+1]){
    //E[][]为保存边信息的邻接矩阵
    int i;
    for(i=1;i<=G.VerNum;i++){
        p=G.AdjList[i].firstEdge;
        while(p){
            if(G.pkind==DG||G.kind==DN||E[p->adjVer][i]==0)//排除无向图的重复节点
                E[i][p->adjVer]=1;//保存边；
            p=p->next;
        }
    }
}

9.12 设计算法判断顶点vi到vj之间是否存在路径

void dfs(ALGraph *G,int u,int v,bool &flag){
    int w;
    visited[u]=TRUE;//设置起始顶点的访问标志
    if(u==v)//说明找到了终点
        flag=TRUE;//有路径
    w=first(G,u);
    while(w!=0)//当还存在邻接点时
    {
        if(visited[w]==FALSE)//从没有被访问过的邻接点继续dfs
            dfs(G,w,v,flag);
        w=nextadj(G,u,w);//求下一个邻接点
    }
}

bool ExistPAth(ALGraph *G,int i,int j){
    bool flag=true;
    dfs(G,i,j,flag);
    return flag;
}

9.13 设计算法判断无向图G是否连通

//从顶点v出发进行深度遍历
void dfs(Graph G, int v){
    int w;
    viste(v);//访问顶点
    visited[v]=true;
    w=first(G,v);
    while(w!=0){
        if(visited[w]==false)
            dfs(G,w);
        w=nextadj(G,v,w);
    }
}

bool dfs_travel(Graph G){
    int i;
    for(i=1;i<=n;i++){
        visited[i]=false;
    }
    dfs(G,1);
    for(i=1;i<=n;i++){
        if(visited[i]==false)//如果存在没有被访问的顶点，就不连通
            return false;
    }
    return true;
}

9.14 设计算法求无向图G的边数

void dfs(Graph G,int v,int &E){
    int w;
    visit(v);
    visited[v]=true;
    w=firstadj(G,v);
    while(w!=0){
        E++;
        if(visited[w]==false)
            dfs(G,w,E);
        w=nextadj(G,v,w);
    }
}
int Enum(Grapg G){
    int i,E;
    for(i=1;i<=n;i++){
        dfs(G,i,E);
    }
    return E/2;
}

9.15 判断无向图G是否为树

//判断无向图是否为树的条件为：G必须是无回路的连通图或能够遍历n-1条边的连通图
void dfs(Graph G,int v,int &en,int &vn){
    int w;
    vn++;//顶点自增
    visited[v]=true;
    w=firstadj(G,v);
    while(w!=0){
        en++;//边自增
        if(visisted[w]==false)
            dfs(G,w,en,vn);
        w=nextadj(G,v,w);
    }
}
vool isTree(Graph G){
    int en=0,vn=0;//边数和顶点数
    dfs(G,1,en,vn);
    if(vn==n&&en==n*(n-1)/2)
        return true;
    else 
        return false;
}

9.16 判断有向图G是否为树

//从v0开始进行深度遍历，且每一个顶点都没有被重复访问且访问完了所有顶点，则为以v0为根的有向树
void dfs(Graph G,int v,int &vn){
    int w;
    visisted[v]=true;
    vn++;
    w=firstadj(G,v);
    while(w!=0){
        if(visited[w]==false)
            dfs(G,w,vn);
        else{//说明重复扫描了,不符合定义
            judge=flase;
        }
        w=nextadj(G,w,vn);
    }
}
bool isTree(Graph G,int v0){
    bool judge=true;
    int vn=0;
    dfs(G,v0,vn);
    return vn==n&&judge;
}

9.18 连通图用邻接表A表示，设计算法以产生dfs(1)de dfs生成树，并存储在邻接矩阵中

void spanningTreeLinkedList(Graph G,int B[][],int v){
    int i,w;
    visited[v]=true;
    w=first(G,v);
    while(w!=0){
        if(visited[w]==false)
            spanningTreeLinkedList(G,B,w);
        w=nextadj(G,v,w);
    }
}

9.20设计算法求解从vi到vj之间的最短路径

int bfsKlevel(Graph G,int vi,int vj){
    int w;
    queue Q;
    init_queue(Q);
    for(i=1;i<=n;i++){
        visited[i]=false;
    }
    visited[vi]=true;
    en_queue(Q,vi,1);
    while(!empty(Q)){
        del_queue(Q,v,level);
        w=firstadj(G,v);
        while(w!=0){
            if(w==vj){
                return level;
            }
            if(!visited[w]){
                visited[w]=true;
            	en_queue(Q,w,level+1);
            }
            w=nextadj(G,v,w);
        }
    }
}

9.21设计算法求解距离v0的最远的一个顶点

int bfs_maxdis(Graph G,int v0){
    int w;
    queue Q;
    init_queue(Q);
    for(i=1;i<=n;i++){
        visisted[i]=false;
    }
    visited[v0]=true;
    en_queue(Q,v0);
    while(!empty(Q)){
        del_queue(Q,v);
        w=firstadj(Q,v);
        while(w!=0){
            if(!visited[w]){
                visited[w]=true;
                en_queue(Q,w);
            }
            w=nextadj(G,v,w);
        }
    }
    return v;
}

9.22 设计算法求解二叉树T中层次最小的一个叶子节点的值

void levelOrder(TNode *&T){
    sqQueue *q;
    initqueue(q);
    if(T!=NULL){
        enqueue(q,T);
    }
    while(!empty(q)){
        delqueue(q,T);
        if(T->lchild==NULL&&T->rchild==NULL){
            cout<<T->data;
            break;
        }
        if(T->lchild!=NULL){
            enqueue(Q,T->lchild);
        }
        if(T->rchild!=NULL){
            enqueue(Q,T->rchild);
        }
    }
}