第十二周项目四【利用遍历思想求解问题】

最新推荐文章于 2021-10-27 11:36:28 发布
最新推荐文章于 2021-10-27 11:36:28 发布
阅读量363 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sdlixiao6/article/details/53317251
版权 
/*问题及代码
 *Copyright(c)2016,烟台大学计算机学院
 *All right reserved.
 *文件名称：利用遍历思想求解图问题.cpp
 *作者：李潇
 *完成日期；2016年11月24日
 *版本号；v1.0
 *问题描述：
         
假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。 
　　（1）设计一个算法，判断顶点u到v是否有简单路径 
　　（2）设计一个算法输出图G中从顶点u到v的一条简单路径（设计测试图时，保证图G中从顶点u到v至少有一条简单路径）。 
　　（3）输出从顶点u到v的所有简单路径。 
　　（4）输出图G中从顶点u到v的长度为s的所有简单路径。 
　　（5）求图中通过某顶点k的所有简单回路（若存在） 
　  （6）求不带权连通图G中从顶点u到顶点v的一条最短路径。 
　　（7）求不带权连通图G中，距离顶点v最远的顶点k 
 *输入描述：图的邻接矩阵
 *程序输出：根据要求输出。
*/

//头文件
#ifndef GRAPH_H_INCLUDED
#define GRAPH_H_INCLUDED

#define MAXV 100                //最大顶点个数
#define INF 32767       //INF表示∞
typedef int InfoType;

//以下定义邻接矩阵类型
typedef struct
{
    int no;                     //顶点编号
    InfoType info;              //顶点其他信息，在此存放带权图权值
} VertexType;                   //顶点类型

typedef struct                  //图的定义
{
    int edges[MAXV][MAXV];      //邻接矩阵
    int n,e;                    //顶点数，弧数
    VertexType vexs[MAXV];      //存放顶点信息
} MGraph;                       //图的邻接矩阵类型

//以下定义邻接表类型
typedef struct ANode            //弧的结点结构类型
{
    int adjvex;                 //该弧的终点位置
    struct ANode *nextarc;      //指向下一条弧的指针
    InfoType info;              //该弧的相关信息,这里用于存放权值
} ArcNode;

typedef int Vertex;

typedef struct Vnode            //邻接表头结点的类型
{
    Vertex data;                //顶点信息
    int count;                  //存放顶点入度,只在拓扑排序中用
    ArcNode *firstarc;          //指向第一条弧
} VNode;

typedef VNode AdjList[MAXV];    //AdjList是邻接表类型

typedef struct
{
    AdjList adjlist;            //邻接表
    int n,e;                    //图中顶点数n和边数e
} ALGraph;                      //图的邻接表类型

//功能：由一个反映图中顶点邻接关系的二维数组，构造出用邻接矩阵存储的图
//参数：Arr - 数组名，由于形式参数为二维数组时必须给出每行的元素个数，在此将参数Arr声明为一维数组名（指向int的指针）
//      n - 矩阵的阶数
//      g - 要构造出来的邻接矩阵数据结构
void ArrayToMat(int *Arr, int n, MGraph &g); //用普通数组构造图的邻接矩阵
void ArrayToList(int *Arr, int n, ALGraph *&); //用普通数组构造图的邻接表
void MatToList(MGraph g,ALGraph *&G);//将邻接矩阵g转换成邻接表G
void ListToMat(ALGraph *G,MGraph &g);//将邻接表G转换成邻接矩阵g
void DispMat(MGraph g);//输出邻接矩阵g
void DispAdj(ALGraph *G);//输出邻接表G

#endif // GRAPH_H_INCLUDED

一二题代码：

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
int visited[MAXV];     //定义存放节点的访问标志的全局数组
void ArrayToList(int *Arr, int n, ALGraph *&G)
{
    int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
    ArcNode *p;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    G->n=n;
    for (i=0; i<n; i++)                 //给邻接表中所有头节点的指针域置初值
        G->adjlist[i].firstarc=NULL;
    for (i=0; i<n; i++)                 //检查邻接矩阵中每个元素
        for (j=n-1; j>=0; j--)
            if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
                p->adjvex=j;
                p->info=Arr[i*n+j];
                p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
                G->adjlist[i].firstarc=p;
            }

    G->e=count;
}
void ExistPath(ALGraph *G,int u,int v, bool &has)
{
    int w;
    ArcNode *p;
    visited[u]=1;
    if(u==v)
    {
        has=true;
        return;
    }
    p=G->adjlist[u].firstarc;
    while (p!=NULL)
    {
        w=p->adjvex;
        if (visited[w]==0)
            ExistPath(G,w,v,has);
        p=p->nextarc;
    }
}

void HasPath(ALGraph *G,int u,int v)
{
    int i;
    bool flag = false;
    for (i=0; i<G->n; i++)
        visited[i]=0; //访问标志数组初始化
    ExistPath(G,u,v,flag);
    printf(" 从 %d 到 %d ", u, v);
    if(flag)
        printf("有简单路径\n");
    else
        printf("无简单路径\n");
}
void FindAPath(ALGraph *G,int u,int v,int path[],int d)
{
    //d表示path中的路径长度，初始为-1
    int w,i;
    ArcNode *p;
    visited[u]=1;
    d++;
    path[d]=u;  //路径长度d增1，顶点u加入到路径中
    if (u==v)   //找到一条路径后输出并返回
    {
        //printf("一条简单路径为:");
        for (i=0; i<=d; i++)
            printf("%d ",path[i]);
        printf("\n");
        return;         //找到一条路径后返回
    }
    p=G->adjlist[u].firstarc;  //p指向顶点u的第一个相邻点
    while (p!=NULL)
    {
        w=p->adjvex;    //相邻点的编号为w
        if (visited[w]==0)
            FindAPath(G,w,v,path,d);
        p=p->nextarc;   //p指向顶点u的下一个相邻点
    }
}

void APath(ALGraph *G,int u,int v)
{
    int i;
    int path[MAXV];
    for (i=0; i<G->n; i++)
        visited[i]=0; //访问标志数组初始化
	printf("从%d到%d的一条路径为:",u,v);
    FindAPath(G,u,v,path,-1);  //d初值为-1，调用时d++，即变成了0
}

int main()
{
    ALGraph *G;
    int A[5][5]=
    {
        {1,0,1,0,1},
        {0,1,0,1,0},
        {1,0,1,0,1},
        {0,1,1,0,0},
        {1,0,0,1,0},
    };  //请画出对应的有向图
    ArrayToList(A[0], 5, G);
    HasPath(G, 2, 4);
    HasPath(G, 4, 1);
    APath(G, 2, 4);
    APath(G, 4, 1);
    return 0;
}
运行结果：

三四题代码:

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
int visited[MAXV];     //定义存放节点的访问标志的全局数组
void ArrayToList(int *Arr, int n, ALGraph *&G)
{
    int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
    ArcNode *p;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    G->n=n;
    for (i=0; i<n; i++)                 //给邻接表中所有头节点的指针域置初值
        G->adjlist[i].firstarc=NULL;
    for (i=0; i<n; i++)                 //检查邻接矩阵中每个元素
        for (j=n-1; j>=0; j--)
            if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
                p->adjvex=j;
                p->info=Arr[i*n+j];
                p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
                G->adjlist[i].firstarc=p;
            }

    G->e=count;
}
void FindPaths(ALGraph *G,int u,int v,int path[],int d)
//d是到当前为止已走过的路径长度，调用时初值为-1
{
    int w,i;
    ArcNode *p;
    visited[u]=1;
    d++;            //路径长度增1
    path[d]=u;              //将当前顶点添加到路径中
    if (u==v && d>1)            //输出一条路径
    {
        printf("  ");
        for (i=0; i<=d; i++)
            printf("%d ",path[i]);
        printf("\n");
    }
    p=G->adjlist[u].firstarc; //p指向u的第一条边
    while(p!=NULL)
    {
        w=p->adjvex;     //w为u的邻接顶点
        if (visited[w]==0)      //若顶点未标记访问，则递归访问之
            FindPaths(G,w,v,path,d);
        p=p->nextarc; //找u的下一个邻接顶点
    }
    visited[u]=0;   //恢复环境
}


void DispPaths(ALGraph *G,int u,int v)
{
    int i;
    int path[MAXV];
    for (i=0; i<G->n; i++)
        visited[i]=0; //访问标志数组初始化
    printf("从%d到%d的所有路径:\n",u,v);
    FindPaths(G,u,v,path,-1);
    printf("\n");
}
void SomePaths(ALGraph *G,int u,int v,int s, int path[],int d)
//d是到当前为止已走过的路径长度，调用时初值为-1
{
    int w,i;
    ArcNode *p;
    visited[u]=1;
    d++;            //路径长度增1
    path[d]=u;              //将当前顶点添加到路径中
    if (u==v && d==s)           //输出一条路径
    {
        printf("  ");
        for (i=0; i<=d; i++)
            printf("%d ",path[i]);
        printf("\n");
    }
    p=G->adjlist[u].firstarc; //p指向u的第一条边
    while(p!=NULL)
    {
        w=p->adjvex;     //w为u的邻接顶点
        if (visited[w]==0)      //若顶点未标记访问，则递归访问之
            SomePaths(G,w,v,s,path,d);
        p=p->nextarc; //找u的下一个邻接顶点
    }
    visited[u]=0;   //恢复环境
}

void DispSomePaths(ALGraph *G,int u,int v, int s)
{
    int i;
    int path[MAXV];
    for (i=0; i<G->n; i++)
        visited[i]=0; //访问标志数组初始化
    printf("从%d到%d长为%d的路径:\n",u,v,s);
    SomePaths(G,u,v,s,path,-1);
    printf("\n");
}

int main()
{
    ALGraph *G;
    int A[5][5]=
    {
        {0,1,0,1,0},
        {1,0,1,0,1},
        {0,1,0,1,0},
        {1,0,1,0,1},
        {0,1,0,1,0}
    };  //请画出对应的有向图
    ArrayToList(A[0], 5, G);
    DispSomePaths(G, 1, 4, 3);
    DispSomePaths(G, 3, 2, 3);
	DispPaths(G, 1, 4);
    DispPaths(G, 3, 4);
    return 0;
}

运行结果：

第五题代码：

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
int visited[MAXV];     //定义存放节点的访问标志的全局数组
void ArrayToList(int *Arr, int n, ALGraph *&G)
{
    int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
    ArcNode *p;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    G->n=n;
    for (i=0; i<n; i++)                 //给邻接表中所有头节点的指针域置初值
        G->adjlist[i].firstarc=NULL;
    for (i=0; i<n; i++)                 //检查邻接矩阵中每个元素
        for (j=n-1; j>=0; j--)
            if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
                p->adjvex=j;
                p->info=Arr[i*n+j];
                p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
                G->adjlist[i].firstarc=p;
            }

    G->e=count;
}
void FindPaths(ALGraph *G,int u,int v,int path[],int d)
//d是到当前为止已走过的路径长度，调用时初值为-1
{
    int w,i;
    ArcNode *p;
    visited[u]=1;
    d++;            //路径长度增1
    path[d]=u;              //将当前顶点添加到路径中
    if (u==v && d>1)            //输出一条路径
    {
        printf("  ");
        for (i=0; i<=d; i++)
            printf("%d ",path[i]);
        printf("\n");
    }
    p=G->adjlist[u].firstarc; //p指向u的第一条边
    while(p!=NULL)
    {
        w=p->adjvex;     //w为u的邻接顶点
        if (visited[w]==0)      //若顶点未标记访问，则递归访问之
            FindPaths(G,w,v,path,d);
        p=p->nextarc; //找u的下一个邻接顶点
    }
    visited[u]=0;   //恢复环境
}


void DispPaths(ALGraph *G,int u,int v)
{
    int i;
    int path[MAXV];
    for (i=0; i<G->n; i++)
        visited[i]=0; //访问标志数组初始化
    printf("从%d到%d的所有路径:\n",u,v);
    FindPaths(G,u,v,path,-1);
    printf("\n");
}

int main()
{
    ALGraph *G;
    int A[5][5]=
    {
        {0,1,0,1,0},
        {1,0,1,0,0},
        {0,1,0,1,1},
        {1,0,1,0,1},
        {0,0,1,1,0}
    };  //请画出对应的有向图
    ArrayToList(A[0], 5, G);
    DispPaths(G, 1, 4);
	DispPaths(G, 3, 4);
    return 0;
}

运行结果;


第六七题代码：

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
typedef struct  
{  
    int data;                   //顶点编号  
    int parent;                 //前一个顶点的位置  
} QUERE;                        //非环形队列类型  
int visited[MAXV];     //定义存放节点的访问标志的全局数组
void ArrayToList(int *Arr, int n, ALGraph *&G)
{
    int i,j,count=0;  //count用于统计边数，即矩阵中非0元素个数
    ArcNode *p;
    G=(ALGraph *)malloc(sizeof(ALGraph));
    G->n=n;
    for (i=0; i<n; i++)                 //给邻接表中所有头节点的指针域置初值
        G->adjlist[i].firstarc=NULL;
    for (i=0; i<n; i++)                 //检查邻接矩阵中每个元素
        for (j=n-1; j>=0; j--)
            if (Arr[i*n+j]!=0)      //存在一条边，将Arr看作n×n的二维数组，Arr[i*n+j]即是Arr[i][j]
            {
                p=(ArcNode *)malloc(sizeof(ArcNode));   //创建一个节点*p
                p->adjvex=j;
                p->info=Arr[i*n+j];
                p->nextarc=G->adjlist[i].firstarc;      //采用头插法插入*p
                G->adjlist[i].firstarc=p;
            }

    G->e=count;
}
void ShortPath(ALGraph *G,int u,int v)
{
    //输出从顶点u到顶点v的最短逆路径
    ArcNode *p;
    int w,i;
    QUERE qu[MAXV];             //非环形队列
    int front=-1,rear=-1;       //队列的头、尾指针
    int visited[MAXV];
    for (i=0; i<G->n; i++)      //访问标记置初值0
        visited[i]=0;
    rear++;                     //顶点u进队
    qu[rear].data=u;
    qu[rear].parent=-1;
    visited[u]=1;
    while (front!=rear)         //队不空循环
    {
        front++;                //出队顶点w
        w=qu[front].data;
        if (w==v)               //找到v时输出路径之逆并退出
        {
            i=front;            //通过队列输出逆路径
            while (qu[i].parent!=-1)
            {
                printf("%2d ",qu[i].data);
                i=qu[i].parent;
            }
            printf("%2d\n",qu[i].data);
            break;
        }
        p=G->adjlist[w].firstarc;   //找w的第一个邻接点
        while (p!=NULL)
        {
            if (visited[p->adjvex]==0)
            {
                visited[p->adjvex]=1;
                rear++;             //将w的未访问过的邻接点进队
                qu[rear].data=p->adjvex;
                qu[rear].parent=front;
            }
            p=p->nextarc;           //找w的下一个邻接点
        }
    }
}
int Maxdist(ALGraph *G,int v)
{
    ArcNode *p;
    int i,j,k;
    int Qu[MAXV];               //环形队列
    int visited[MAXV];              //访问标记数组
    int front=0,rear=0;             //队列的头、尾指针
    for (i=0; i<G->n; i++)          //初始化访问标志数组
        visited[i]=0;
    rear++;
    Qu[rear]=v;                 //顶点v进队
    visited[v]=1;               //标记v已访问
    while (rear!=front)
    {
        front=(front+1)%MAXV;
        k=Qu[front];                //顶点k出队
        p=G->adjlist[k].firstarc;       //找第一个邻接点
        while (p!=NULL)             //所有未访问过的相邻点进队
        {
            j=p->adjvex;            //邻接点为顶点j
            if (visited[j]==0)          //若j未访问过
            {
                visited[j]=1;
                rear=(rear+1)%MAXV;
                Qu[rear]=j; //进队
            }
            p=p->nextarc;           //找下一个邻接点
        }
    }
    return k;
}

int main()
{
    ALGraph *G;
    int A[9][9]=
    {
        {0,1,1,0,0,0,1,0,0},
        {0,0,0,1,1,0,0,0,1},
        {1,0,0,0,1,1,0,0,0},
        {0,0,1,0,0,0,1,0,0},
        {1,0,0,0,0,1,1,0,1},
        {0,0,1,0,0,0,0,1,0},
        {1,0,0,0,1,0,0,1,1},
        {0,0,1,0,0,0,1,0,1},
        {1,0,0,0,1,0,0,1,0}
    };  //请画出对应的有向图
    ArrayToList(A[0], 9, G);
    ShortPath(G,2,6);
	ShortPath(G,5,8);
    printf("离顶点0最远的顶点:%d\n",Maxdist(G,0));
    return 0;
}

运行结果：


知识点总结：

遍历思想和递归算法的应用

心得体会：

这次的算法验证把遍历过程和递归过程又复习了一遍，收获颇多。

sdlixiao6
关注
约瑟夫问题,“遍历”思想.(C语言实现)
Suda_cake的博客
12-01 1434
约瑟夫问题，“遍历”思想解决。(C实现)
第十二周项目四 利用遍历思想求解图问题（1、2）
AFencounter的博客
11-17 464
问题及代码： /* *烟台大学计算机与控制工程学院 *作 者：孙丽玮 *完成日期：2016年11月17日 *问题描述：假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。 　　 （1）设计一个算法，判断顶点u到v是否有简单路径 　　 （2）设计一个算法输出图
java遍历树的思想_Java二叉树的遍历思想及核心代码实现
weixin_33074843的博客
02-16 135
二叉树在计算机中的存储方式往往线性结构，线性存储分为顺序存储和链式存储，将二叉树按层序编号。顺序结构：按编号的顺序进行存储，对于完全二叉树而言，顺序存储可以反映二叉树的逻辑，但是对于大多数的二叉树则无法反映其逻辑关系，不过可以用 ^ 来代替不存在的结点，但是如果这个树是一个右斜树，就非常浪费存储空间。所以二叉树的存储形式一般为链式存储结构。链式存储：每一个结点都分有一个数据域(data)和两个指针...
图的遍历--思想
liu_qiqi的专栏
12-15 842
深度优先遍历DFS和广度优先遍历BFS 1.深度优先遍历的过程是递归的过程。类似于一颗树的前序遍历。    先将所有的结点初始化标记为FALSE，表示未被访问过。    再对每个结点i，进行深度递归算法。（如果存在非连通图时，也可保证将所有结点进行遍历）           标记i结点已经被访问过，并输出。           将顶点i到所有结点进行判断，判断i到这些结点之间是否有边，并
二叉树的遍历基本思想
不知道该写啥QAQ
03-31 1908
纯文字，javascript实现代码会在下篇写二叉树的概念：二叉树是结点的有限集合，该集合或者为空集，或者是由一个根和两颗互不相交的、称为该根的左子树和右子树的二叉树组合。（摘自陈慧南——数据结构）二叉树的遍历 先序遍历（PreOrder） 若二叉树为空则空操作 否则：访问根节点 先序遍历左子树 先序遍历右子树 中序遍历（InOrder） 若二叉树为空则空操作中序遍历左子树 访问根节点 中序遍
遍历思想进阶（高斯）
deligent_torche的博客
10-27 196
来思考一个问题，1+...+100 = ? 遍历：1+2+3+4+5+6.........+100 问题复杂度O(n) 高智商人类高斯表示我只需要一半复杂度 大家熟知的 （100 + 1） * （100 / 2） 所以当遇到遍历时， 例如 ： 二分查找， 双指针， 多数前缀和问题等等 因为遍历问题无处不在，所以高斯思想非常可贵，也可以使我们换一种角度看待问题 ...
第十二周项目四 利用遍历思想求解图问题（6、7）
AFencounter的博客
11-17 264
问题及代码： /* *烟台大学计算机与控制工程学院 *作 者：孙丽玮 *完成日期：2016年11月17日 *问题描述：假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。 　　 （6）求不带权连通图G中从顶点u到顶点v的一条最短路径。 　　 （7）求不带权连
第十二周 项目4 利用遍历思想求解图问题（输出一些简单回路）
王旭的博客
11-23 561
/* * 烟台大学计算机与控制工程学院 *文件名称：mian.cpp *作 者：王旭 *完成日期：2015年11月19日 *版 本 号：v1.0 * *问题描述： 输出图G中从顶点u到v的长度为s的所有简单路径。 * *输入描述：无
第十二周--利用遍历思想求解图问题
sunsunzice的博客
11-17 351
/ 作 者：孙子策 完成日期：2016.11.17 问题描述: 假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。 　　 （1）设计一个算法，判断顶点u到v是否有简单路径 　　 （2）设计一个算法输出图G中从顶点u到v的一条简单路径（设计测试图时，保证图G中从顶点u到v至少有一条简
第十二周 项目4-利用遍历思想求解图问题（1.2.3）
YY1562cjy的博客
11-17 303
问题及代码： /* * Copyright (c)2016,烟台大学计算机与控制工程学院 * All rights reserved. * 文件名称：项目4.cpp * 作 者：车佳颖 * 完成日期：2016年11月17日 * 版 本 号：v1.0 *问题描述：假设图G采用邻接表存储，分别设计实现以
集合遍历中的算法思想
qq_33470330的博客
12-24 322
集合是我们日常开发中常用的数据存储结构，遍历集合元素也是我们日常开发中所少不了的。 最近笔者在工作中用到的一个开发项目，对10万条数据的集合便利做数据解析。处理流程如下： 每次导出数据大致在100万条左右，分成十个左右的集合，并发的去导出，整个流程下来耗时80s左右。 速率的优化已经迫在眉睫。 通过在代码中增加日志观察各个流程的时间节点，却发现耗时最严重的是只有一个for循环的业务处理。耗时40...
数据结构之后续遍历思想
z1607273131的博客
10-08 338
进入根节点后，先打印左子树，再打印右子树，最后打印根节点。 例如一个二叉树： 打印顺序为：1 4 7 6 3 13 14 10 8 步骤为：        进入根节点8后。先看8有没有左子树。有左子树进入，左孩子3。再看3有没有左子树。有左孩子1，进入左孩子1。再看1有没有左子树。没有。在看有没有右子树。没有。那就打印1. 节点1就遍历了。回到节点3。有没有右子树。有。 继续从左开始，...
二叉树的遍历思想及核心代码实现
sdr_zd的博客
08-15 994
二叉树在计算机中的存储方式往往线性结构，线性存储分为顺序存储和链式存储，将二叉树按层序编号。 顺序结构：按编号的顺序进行存储，对于完全二叉树而言，顺序存储可以反映二叉树的逻辑，但是对于大多数的二叉树则无法反映其逻辑关系，不过可以用 ^ 来代替不存在的结点，但是如果这个树是一个右斜树，就非常浪费存储空间。所以二叉树的存储形式一般为链式存储结构。 链式存储：每一个结点都分有一个数据域(data)和...
线索化 - 遍历思想，流程，代码
yofer张耀琦的专栏
07-19 967
1、前言 普通二叉树只能找到结点的左右孩子信息，而该结点的直接前驱和直接后继只能在遍历过程中获得。 若可将遍历后对应的有关前驱和后继预存起来，则从第一个结点开始就能很快“顺藤摸瓜”而遍历整个树了。 二叉线索树思想是干什么的？ 中序遍历这棵树===》转换成链表访问 2线索化思想 结论：线索化过程就是在遍历过程（假设是中序遍历）中修改空指针的
第十二周项目4--利用遍历思想求解问题
meiyanrumei的博客
11-14 321
问题及代码： /* *烟台大学计算机与控制工程学院 *作 者：刘倩 *完成日期：2016年11月14日 *问题描述： 假设图G采用邻接表存储，分别设计实现以下要求的算法，要求用区别于示例中的图进行多次测试，通过观察输出值，掌握相关问题的处理方法。 　　（1）设计一个算法，判断顶点u到v是否有简单路径 　　（2）设计一个算法输出图G中从顶点u到
图的深度优先遍历DFS （邻接矩阵实现） c语言
热门推荐
大芝士球的博客
02-08 2万+
图的遍历是指从图中的某一顶点出发，按照一定的策略访问图中的每一个顶点。每个顶点有且只能被访问一次。 深度优先遍历也叫深度优先搜索(Depth First Search)。 它的遍历规则：先选择一个初始顶点，再规定一个方向，例如往右边一直遍历。于是就往右边一直走，把访问过的顶点做好标记，沿着右边访问完后，回溯到之前访问过的顶点，找找还有没有顶点没有访问的，当所有顶点被访问，完成遍历。 DFS是...
最小生成树(1)
datouniao1的博客
07-13 464
最小生成树是在图论中的一个重要的问题，我们找一个图的最小生成树，也就是找链接所有的顶点，并且使得各边的代价之和最小。当然最小生成树的程序的编写也是相当的复杂，数据结构书上也有通过prim算法来创建最小生成树，当然在这个地方我们是通过克鲁斯卡尔算法：(假设一个连通网N=(V,{E}),则令最小生成树的初始状态为只有n个顶点而无边的非连同图T=(V,{}),图中的每一个顶点自成一个连同分量。在E中选择
第十二周项目4-利用遍历思想求解图问题
DACBE的博客
11-18 621
/*    * 烟台大学计算机与控制工程学院    * 作者：王雪松   * 完成日期：2016年11月18日    *    * 问题描述： * 输入描述： * 程序输出：  */  问题及代码： 1、是否有简单路径?  问题：假设图G采用邻接表存储，设计一个算法，判断顶点u到v是否有简单路径。 [csharp]
第12周-项目3 - 图遍历算法实现
luguoca的博客
11-16 357
问题及代码： 实现图遍历算法，分别输出如下图结构的深度优先(DFS)遍历序列和广度优先遍历(BFS)序列。    测试时用的图是，可以使用其他类型的图代替。 1、深度优先遍历——DFS #include #include #include "graph.h" int visited[MAXV]; void DFS(ALGraph *G, int v) { ArcNode
C++编程思想：第2章课后习题解析与解答
"《C++编程思想》第二章课后习题主要...以上是《C++编程思想》第二章部分习题的解析，这些问题覆盖了C++的基础语法、标准库的使用，以及面向对象编程的一些基础概念。解决这些题目有助于加深对C++语言的理解和掌握。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值