第十二周项目一C/C++验证算法

最新推荐文章于 2022-05-01 00:01:22 发布
最新推荐文章于 2022-05-01 00:01:22 发布
阅读量372 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/JING727708672/article/details/78612271
版权 
/*   
*Copyright (c) 2017,烟台大学计算机与控制工程学院   
*All rights reserved.   
*文件名称：.cpp
*完成日期：2017年11月23日   
*版 本 号：v1.0   
* 验证算法 
/*
【项目 - 验证算法】运行并本周视频中所讲过的算法，观察结果并领会算法。 
（1）Prim算法的验证（使用图1作为测试用例） 

（2）Kruskal算法的验证（使用图1作为测试用例） 


（3）Dijkstra算法的验证（使用图2作为测试用例） 


（4）Floyd算法验证（使用图3作为测试用例） 



（5）拓扑排序算法验证（使用图4作为测试用例） 


解答：

（1）

（程序中graph.h是图存储结构的“算法库”中的头文件）

#include <stdio.h>
#include <malloc.h>
#include "graph.h"

void Prim(MGraph g,int v)
{
    int lowcost[MAXV];          //顶点i是否在U中
    int min;
    int closest[MAXV],i,j,k;
    for (i=0; i<g.n; i++)           //给lowcost[]和closest[]置初值
    {
        lowcost[i]=g.edges[v][i];
        closest[i]=v;
    }
    for (i=1; i<g.n; i++)           //找出n-1个顶点
    {
        min=INF;
        for (j=0; j<g.n; j++)     //在(V-U)中找出离U最近的顶点k
            if (lowcost[j]!=0 && lowcost[j]<min)
            {
                min=lowcost[j];
                k=j;            //k记录最近顶点的编号
            }
        printf(" 边(%d,%d)权为:%d\n",closest[k],k,min);
        lowcost[k]=0;           //标记k已经加入U
        for (j=0; j<g.n; j++)       //修改数组lowcost和closest
            if (g.edges[k][j]!=0 && g.edges[k][j]<lowcost[j])
            {
                lowcost[j]=g.edges[k][j];
                closest[j]=k;
            }
    }
}

int main()
{
    MGraph g;
    int A[6][6]=
    {
        {0,6,1,5,INF,INF},
        {6,0,5,INF,3,INF},
        {1,5,0,5,6,4},
        {5,INF,5,0,INF,2},
        {INF,3,6,INF,0,6},
        {INF,INF,4,2,6,0}
    };
    ArrayToMat(A[0], 6, g);
    printf("最小生成树构成:\n");
    Prim(g,0);
    return 0;
}
附：测试用图结构 


运行结果：


（2）

（程序中graph.h是图存储结构的“算法库”中的头文件）

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
#define MaxSize 100
typedef struct
{
    int u;     //边的起始顶点
    int v;     //边的终止顶点
    int w;     //边的权值
} Edge;

void InsertSort(Edge E[],int n) //对E[0..n-1]按递增有序进行直接插入排序
{
    int i,j;
    Edge temp;
    for (i=1; i<n; i++)
    {
        temp=E[i];
        j=i-1;              //从右向左在有序区E[0..i-1]中找E[i]的插入位置
        while (j>=0 && temp.w<E[j].w)
        {
            E[j+1]=E[j];    //将关键字大于E[i].w的记录后移
            j--;
        }
        E[j+1]=temp;        //在j+1处插入E[i]
    }
}

void Kruskal(MGraph g)
{
    int i,j,u1,v1,sn1,sn2,k;
    int vset[MAXV];
    Edge E[MaxSize];    //存放所有边
    k=0;                //E数组的下标从0开始计
    for (i=0; i<g.n; i++)   //由g产生的边集E
        for (j=0; j<g.n; j++)
            if (g.edges[i][j]!=0 && g.edges[i][j]!=INF)
            {
                E[k].u=i;
                E[k].v=j;
                E[k].w=g.edges[i][j];
                k++;
            }
    InsertSort(E,g.e);      //采用直接插入排序对E数组按权值递增排序
    for (i=0; i<g.n; i++)   //初始化辅助数组
        vset[i]=i;
    k=1;    //k表示当前构造生成树的第几条边,初值为1
    j=0;    //E中边的下标,初值为0
    while (k<g.n)       //生成的边数小于n时循环
    {
        u1=E[j].u;
        v1=E[j].v;      //取一条边的头尾顶点
        sn1=vset[u1];
        sn2=vset[v1];   //分别得到两个顶点所属的集合编号
        if (sn1!=sn2)   //两顶点属于不同的集合
        {
            printf("  (%d,%d):%d\n",u1,v1,E[j].w);
            k++;                     //生成边数增1
            for (i=0; i<g.n; i++)   //两个集合统一编号
                if (vset[i]==sn2)   //集合编号为sn2的改为sn1
                    vset[i]=sn1;
        }
        j++;               //扫描下一条边
    }
}

int main()
{
    MGraph g;
    int A[6][6]=
    {
        {0,6,1,5,INF,INF},
        {6,0,5,INF,3,INF},
        {1,5,0,5,6,4},
        {5,INF,5,0,INF,2},
        {INF,3,6,INF,0,6},
        {INF,INF,4,2,6,0}
    };
    ArrayToMat(A[0], 6, g);
    printf("最小生成树构成:\n");
    Kruskal(g);
    return 0;
}
附：测试用图结构 



运行结果：


（3）

（程序中graph.h是图存储结构的“算法库”中的头文件）

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
#define MaxSize 100
void Ppath(int path[],int i,int v)  //前向递归查找路径上的顶点
{
    int k;
    k=path[i];
    if (k==v)  return;          //找到了起点则返回
    Ppath(path,k,v);            //找顶点k的前一个顶点
    printf("%d,",k);            //输出顶点k
}
void Dispath(int dist[],int path[],int s[],int n,int v)
{
    int i;
    for (i=0; i<n; i++)
        if (s[i]==1)
        {
            printf("  从%d到%d的最短路径长度为:%d\t路径为:",v,i,dist[i]);
            printf("%d,",v);    //输出路径上的起点
            Ppath(path,i,v);    //输出路径上的中间点
            printf("%d\n",i);   //输出路径上的终点
        }
        else  printf("从%d到%d不存在路径\n",v,i);
}
void Dijkstra(MGraph g,int v)
{
    int dist[MAXV],path[MAXV];
    int s[MAXV];
    int mindis,i,j,u;
    for (i=0; i<g.n; i++)
    {
        dist[i]=g.edges[v][i];      //距离初始化
        s[i]=0;                     //s[]置空
        if (g.edges[v][i]<INF)      //路径初始化
            path[i]=v;
        else
            path[i]=-1;
    }
    s[v]=1;
    path[v]=0;              //源点编号v放入s中
    for (i=0; i<g.n; i++)               //循环直到所有顶点的最短路径都求出
    {
        mindis=INF;                 //mindis置最小长度初值
        for (j=0; j<g.n; j++)       //选取不在s中且具有最小距离的顶点u
            if (s[j]==0 && dist[j]<mindis)
            {
                u=j;
                mindis=dist[j];
            }
        s[u]=1;                     //顶点u加入s中
        for (j=0; j<g.n; j++)       //修改不在s中的顶点的距离
            if (s[j]==0)
                if (g.edges[u][j]<INF && dist[u]+g.edges[u][j]<dist[j])
                {
                    dist[j]=dist[u]+g.edges[u][j];
                    path[j]=u;
                }
    }
    Dispath(dist,path,s,g.n,v);     //输出最短路径
}

int main()
{
    MGraph g;
    int A[7][7]=
    {
        {0,4,6,6,INF,INF,INF},
        {INF,0,1,INF,7,INF,INF},
        {INF,INF,0,INF,6,4,INF},
        {INF,INF,2,0,INF,5,INF},
        {INF,INF,INF,INF,0,INF,6},
        {INF,INF,INF,INF,1,0,8},
        {INF,INF,INF,INF,INF,INF,0}
    };
    ArrayToMat(A[0], 7, g);
    Dijkstra(g,0);
    return 0;
}
附：测试用图结构 


运行结果：


（4）


[Floyd算法实现] 

（程序中graph.h是图存储结构的“算法库”中的头文件）

#include <stdio.h>
#include <malloc.h>
#include "graph.h"
#define MaxSize 100
void Ppath(int path[][MAXV],int i,int j)  //前向递归查找路径上的顶点
{
    int k;
    k=path[i][j];
    if (k==-1) return;  //找到了起点则返回
    Ppath(path,i,k);    //找顶点i的前一个顶点k
    printf("%d,",k);
    Ppath(path,k,j);    //找顶点k的前一个顶点j
}
void Dispath(int A[][MAXV],int path[][MAXV],int n)
{
    int i,j;
    for (i=0; i<n; i++)
        for (j=0; j<n; j++)
        {
            if (A[i][j]==INF)
            {
                if (i!=j)
                    printf("从%d到%d没有路径\n",i,j);
            }
            else
            {
                printf("  从%d到%d=>路径长度:%d 路径:",i,j,A[i][j]);
                printf("%d,",i);    //输出路径上的起点
                Ppath(path,i,j);    //输出路径上的中间点
                printf("%d\n",j);   //输出路径上的终点
            }
        }
}
void Floyd(MGraph g)
{
    int A[MAXV][MAXV],path[MAXV][MAXV];
    int i,j,k;
    for (i=0; i<g.n; i++)
        for (j=0; j<g.n; j++)
        {
            A[i][j]=g.edges[i][j];
            path[i][j]=-1;
        }
    for (k=0; k<g.n; k++)
    {
        for (i=0; i<g.n; i++)
            for (j=0; j<g.n; j++)
                if (A[i][j]>A[i][k]+A[k][j])
                {
                    A[i][j]=A[i][k]+A[k][j];
                    path[i][j]=k;
                }
    }
    Dispath(A,path,g.n);   //输出最短路径
}
int main()
{
    MGraph g;
    int A[4][4]=
    {
        {0,  5,INF,7},
        {INF,0,  4,2},
        {3,  3,  0,2},
        {INF,INF,1,0}
    };
    ArrayToMat(A[0], 4, g);
    Floyd(g);
    return 0;
}
运行结果：



（5）


（程序中graph.h是图存储结构的“算法库”中的头文件）

#include <stdio.h>
#include <malloc.h>
#include "graph.h"

void TopSort(ALGraph *G)
{
    int i,j;
    int St[MAXV],top=-1;            //栈St的指针为top
    ArcNode *p;
    for (i=0; i<G->n; i++)          //入度置初值0
        G->adjlist[i].count=0;
    for (i=0; i<G->n; i++)          //求所有顶点的入度
    {
        p=G->adjlist[i].firstarc;
        while (p!=NULL)
        {
            G->adjlist[p->adjvex].count++;
            p=p->nextarc;
        }
    }
    for (i=0; i<G->n; i++)
        if (G->adjlist[i].count==0)  //入度为0的顶点进栈
        {
            top++;
            St[top]=i;
        }
    while (top>-1)                  //栈不为空时循环
    {
        i=St[top];
        top--;              //出栈
        printf("%d ",i);            //输出顶点
        p=G->adjlist[i].firstarc;   //找第一个相邻顶点
        while (p!=NULL)
        {
            j=p->adjvex;
            G->adjlist[j].count--;
            if (G->adjlist[j].count==0)//入度为0的相邻顶点进栈
            {
                top++;
                St[top]=j;
            }
            p=p->nextarc;       //找下一个相邻顶点
        }
    }
}

int main()
{
    ALGraph *G;
    int A[7][7]=
    {
        {0,0,1,0,0,0,0},
        {0,0,0,1,1,0,1},
        {0,0,0,1,0,0,0},
        {0,0,0,0,1,1,0},
        {0,0,0,0,0,0,0},
        {0,0,0,0,0,0,0},
        {0,0,0,0,0,1,0}
    };
    ArrayToList(A[0], 7, G);
    DispAdj(G);
    printf("\n");
    printf("拓扑序列:");
    TopSort(G);
    printf("\n");
    return 0;
}
运行结果：



雀仔JING
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
第十三周项目一C/C++验证算法
JING727708672的博客
11-30 376
/* *Copyright (c) 2017,烟台大学计算机与控制工程学院 *All rights reserved. *文件名称：.cpp *完成日期：2017年11月30日 *版 本 号：v1.0 * 验证算法 /* 1、认真阅读并验证折半查找算法。请用有序表{12,18,24,35,47,50,62,83,90,115,134}作为测试序列，分别对查找90
(第十一周项目1)二叉树算法验证
suzucheese的博客
12-01 492
运行并重复测试教学内容中涉及的算法。改变测试数据进行重复测试的意义在于，可以从更多角度体会算法，以达到逐渐掌握算法的程度。使用你的测试数据，并展示测试结果，观察运行结果，以此来领会算法。 （1）层次遍历算法的验证 #include #include "btree.h" void LevelOrder(BTNode *b) { BTNode *p; BTNode
c++网络验证
07-04
C++网络验证 测试不错的 很好用 你值得拥有 推荐 推荐
C++的一些验证
hchwwlhm1的博客
03-09 462
main 函数之前执行什么? #include &lt;iostream&gt; using namespace std; class A { public: A() { cout &lt;&lt; "constructor A ... \n"; } ~A() { ...
小白程序员的第一个C++项目——迷宫A*算法(上)
weixin_44991673的博客
12-11 868
C++迷宫实验迷宫生成迷宫解决A*算法 C++项目：玩转迷宫游戏 迷宫生成 迷宫搜索路径算法 Maze generation A* with motions limited to 1 cell A* with motions using straight lines A* with motions using corridors 迷宫生成 迷宫生成的代码在维基百科上面。下面我们...
java/c/c++经典算法
03-08
### Java/C/C++经典算法知识点解析 #### 一、算法概览 算法是解决特定问题的一系列明确步骤的集合。有效的算法能够高效地处理数据并解决问题。本章节将详细介绍算法的基本概念及其在Java、C/C++编程语言中的应用。...
08575.rar_数值算法/人工智能_Visual_C++_
08-11
"第12章 启发式搜索策略"介绍了一些能够指导搜索方向的高级技术，如A*算法、IDDFS（深度优先搜索）等，这些策略可以结合领域知识，降低搜索空间，提高解决问题的速度。 "第13章 更多搜索策略"可能包含其他优化搜索...
单片机与DSP中的使用C/C++语言编写基于DSP程序的注意事项
11-18
如果可能，应调用TI公司或第三方提供的DSPLIB等经过优化的子程序库，这些库通常由汇编语言编写并经过算法验证，适用于常见的数字信号处理任务。 7. **内联函数的应用**： 内联函数能提高代码执行效率，因为它避免...
2020年第十一届蓝桥杯省赛C++大学A组真题（第二场）
10-17
【标题】2020年第十一届蓝桥杯省赛C++大学A组真题（第二场）揭示了这是一场面向大学学生的编程竞赛，主要考察参赛者的C++编程技能和算法理解。蓝桥杯是知名的全国性编程比赛，旨在促进计算机科学与信息技术教育的...
一元多项式相加实验报告（C语言实现）
12-25
- **测试目的**：验证算法在各种特殊情况下的表现，例如系数互为相反数、单项相加、系数相加后为负数等。 - **测试结果**：通过不同的测试用例，证明了算法能够正确处理各种特殊情况，包括但不限于上述提到的情况。 ...
c/c++开发网络验证和本地验证
12-05
c/c++开发网络验证和本地验证,支持生成CDKEY验证和其他验证的代码示例,可以通过血与荣誉网络验证服务器配合使用
验证密码C++代码
09-11
用C++语言编制的“密码验证程序”的代码，简单便捷
C++模拟Apriori算法（先验算法）
12-01
使用C++模拟Apriori算法（先验算法），写的还是比较清楚的
C++算法提高项目.rar
08-15
内部包含几十个c++算法项目，给大家提供参考，欢迎下载学习 内部包含几十个c++算法项目，给大家提供参考，欢迎下载学习
c++登录验证程序
01-26
c++登录验证程序，平时自己用的今天拿出来分享。dev C++可用
C++算法项目实战篇：密码学算法，C++ 获取宽带ADSL的账号与密码
07-02 475
为了解决用户可能碰到关于"不知道宽带用户名和密码，怎么设置无线路由器连接"相关的问题，突袭网经过收集整理为用户提供相关的解决办法，用C实现获取本机ADSL的用户名与密码。获取宽带密码的一个小工具，修改自gh0st RAT 3.6的源码 项目结构： 代码截图： 我们现在使用互联网做各种事情：网上银行、股票交易、在线购物、网上缴费、社交网络、网络游戏、在线...
项目规划算法题-C++实现
icefieldwolf的博客
05-01 1139
前言 本文记录4月27日晚7点一场软件开发岗笔试的题目，思路以及代码实现。 一、题目简介 题目： 项目规划 具体描述： 公司做项目规划，当前三个团队（前端，后端，测试）共同规划完成M个项目，我们有三个团队的各自人力总和值。对于每个项目都需要多个团队共同投入完成（每个项目会有对3个项目的人力需求数量），每个项目会有一个预期价值。我们需要在M各项目中作项目规划，使得在人力允许的范围内，使能够承接的所有项目预期价值总和最大。 输入输出： 2 100 100 100 10000 8000 60 60 60 60 6
分享几个适合初学者的C语言/C++开源项目！涉及从基础语法到算法
HUYA69的博客
04-25 640
说在前面 今天分享几款我收藏的适合初学者的C语言和C++领域的开源项目，有涉及语言基础知识的、有涉及数据结构和算法题的、有涉及设计模式的代码实现的，甚至还有涉及效率工具和实践的，希望能有帮助。 项目一 项目名称：C 项目简介：是的，你没有看错，这个项目的名字就是单个字母C。C是一个宝藏项目，可以说是学习数据结构和刷算法题的利器，因为里面包含了几乎各种基础算法、数据结构、以及Lee...
C++验证码识别
11-09
详细的C++验证码代码书写，很全面，很详细，注释很全面
C++版数据结构与算法分析英文第二版详解及习题解答
《数据结构与算法分析答案（英文C++版）（第二版）》是由Clifford A. Shaffer所著，专为计算机科学领域的学生提供实践导向的数据结构和算法分析教程的配套教材。这本书旨在帮助读者深入理解数据结构的基本概念、核心...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值