数据结构——浙大版中国大学mooc(week6)

数据结构—图(简要理解) 图 本文前半部分参考的是浙大MOOC上陈越老师说讲解,但听到后面一半,觉得有点晦涩难懂,便去看了《大话数据结构》,因此后面的主要内容也是大多参考这本书,除了最后一节的关键路径算法,有点搞不太懂,其他的总算让我有了浅显的了解了。说实话,数据结构实在是太难啃了,书本上讲的所以然,还得靠多刷题,多做实验来解决。 什么是图 多对多 线性表,树都是图的特殊情况 包含: 一组顶点,通常用V(Vertex)表示顶点集合 一组边,通常用E(Edge)表示边的集合 边是顶点对,(v,w),可以互通 有向边,<v,w 阅读详情

课程给出代码

C语言:图的邻接矩阵实现建立

/* 图的邻接矩阵表示法 */
 
#define MaxVertexNum 100    /* 最大顶点数设为100 */
#define INFINITY 65535        /* ∞设为双字节无符号整数的最大值65535*/
typedef int Vertex;         /* 用顶点下标表示顶点,为整型 */
typedef int WeightType;        /* 边的权值设为整型 */
typedef char DataType;        /* 顶点存储的数据类型设为字符型 */
 
/* 边的定义 */
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;      /* 有向边<V1, V2> */
    WeightType Weight;  /* 权重 */
};
typedef PtrToENode Edge;
        
/* 图结点的定义 */
typedef struct GNode *PtrToGNode;
struct GNode{
    int Nv;  /* 顶点数 */
    int Ne;  /* 边数   */
    WeightType G[MaxVertexNum][MaxVertexNum]; /* 邻接矩阵 */
    DataType Data[MaxVertexNum];      /* 存顶点的数据 */
    /* 注意:很多情况下,顶点无数据,此时Data[]可以不用出现 */
};
typedef PtrToGNode MGraph; /* 以邻接矩阵存储的图类型 */
 
 
 
MGraph CreateGraph( int VertexNum )
{ /* 初始化一个有VertexNum个顶点但没有边的图 */
    Vertex V, W;
    MGraph Graph;
     
    Graph = (MGraph)malloc(sizeof(struct GNode)); /* 建立图 */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    /* 初始化邻接矩阵 */
    /* 注意:这里默认顶点编号从0开始,到(Graph->Nv - 1) */
    for (V=0; V<Graph->Nv; V++)
        for (W=0; W<Graph->Nv; W++)  
            Graph->G[V][W] = INFINITY;
             
    return Graph; 
}
        
void InsertEdge( MGraph Graph, Edge E )
{
     /* 插入边 <V1, V2> */
     Graph->G[E->V1][E->V2] = E->Weight;    
     /* 若是无向图,还要插入边<V2, V1> */
     Graph->G[E->V2][E->V1] = E->Weight;
}
 
MGraph BuildGraph()
{
    MGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;
     
    scanf("%d", &Nv);   /* 读入顶点个数 */
    Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */ 
     
    scanf("%d", &(Graph->Ne));   /* 读入边数 */
    if ( Graph->Ne != 0 ) { /* 如果有边 */ 
        E = (Edge)malloc(sizeof(struct ENode)); /* 建立边结点 */ 
        /* 读入边,格式为"起点 终点 权重",插入邻接矩阵 */
        for (i=0; i<Graph->Ne; i++) {
            scanf("%d %d %d", &E->V1, &E->V2, &E->Weight); 
            /* 注意:如果权重不是整型,Weight的读入格式要改 */
            InsertEdge( Graph, E );
        }
    } 
 
    /* 如果顶点有数据的话,读入数据 */
    for (V=0; V<Graph->Nv; V++) 
        scanf(" %c", &(Graph->Data[V]));
 
    return Graph;
}

C语言:图的邻接表实现建立

/* 图的邻接表表示法 */
 
#define MaxVertexNum 100    /* 最大顶点数设为100 */
typedef int Vertex;         /* 用顶点下标表示顶点,为整型 */
typedef int WeightType;        /* 边的权值设为整型 */
typedef char DataType;        /* 顶点存储的数据类型设为字符型 */
 
/* 边的定义 */
typedef struct ENode *PtrToENode;
struct ENode{
    Vertex V1, V2;      /* 有向边<V1, V2> */
    WeightType Weight;  /* 权重 */
};
typedef PtrToENode Edge;
 
/* 邻接点的定义 */
typedef struct AdjVNode *PtrToAdjVNode; 
struct AdjVNode{
    Vertex AdjV;        /* 邻接点下标 */
    WeightType Weight;  /* 边权重 */
    PtrToAdjVNode Next;    /* 指向下一个邻接点的指针 */
};
 
/* 顶点表头结点的定义 */
typedef struct Vnode{
    PtrToAdjVNode FirstEdge;/* 边表头指针 */
    DataType Data;            /* 存顶点的数据 */
    /* 注意:很多情况下,顶点无数据,此时Data可以不用出现 */
} AdjList[MaxVertexNum];    /* AdjList是邻接表类型 */
 
/* 图结点的定义 */
typedef struct GNode *PtrToGNode;
struct GNode{  
    int Nv;     /* 顶点数 */
    int Ne;     /* 边数   */
    AdjList G;  /* 邻接表 */
};
typedef PtrToGNode LGraph; /* 以邻接表方式存储的图类型 */
 
 
 
LGraph CreateGraph( int VertexNum )
{ /* 初始化一个有VertexNum个顶点但没有边的图 */
    Vertex V;
    LGraph Graph;
     
    Graph = (LGraph)malloc( sizeof(struct GNode) ); /* 建立图 */
    Graph->Nv = VertexNum;
    Graph->Ne = 0;
    /* 初始化邻接表头指针 */
    /* 注意:这里默认顶点编号从0开始,到(Graph->Nv - 1) */
       for (V=0; V<Graph->Nv; V++)
        Graph->G[V].FirstEdge = NULL;
             
    return Graph; 
}
        
void InsertEdge( LGraph Graph, Edge E )
{
    PtrToAdjVNode NewNode;
     
    /* 插入边 <V1, V2> */
    /* 为V2建立新的邻接点 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V2;
    NewNode->Weight = E->Weight;
    /* 将V2插入V1的表头 */
    NewNode->Next = Graph->G[E->V1].FirstEdge;
    Graph->G[E->V1].FirstEdge = NewNode;
         
    /* 若是无向图,还要插入边 <V2, V1> */
    /* 为V1建立新的邻接点 */
    NewNode = (PtrToAdjVNode)malloc(sizeof(struct AdjVNode));
    NewNode->AdjV = E->V1;
    NewNode->Weight = E->Weight;
    /* 将V1插入V2的表头 */
    NewNode->Next = Graph->G[E->V2].FirstEdge;
    Graph->G[E->V2].FirstEdge = NewNode;
}
 
LGraph BuildGraph()
{
    LGraph Graph;
    Edge E;
    Vertex V;
    int Nv, i;
     
    scanf("%d", &Nv);   /* 读入顶点个数 */
    Graph = CreateGraph(Nv); /* 初始化有Nv个顶点但没有边的图 */ 
     
    scanf("%d", &(Graph->Ne));   /* 读入边数 */
    if ( Graph->Ne != 0 ) { /* 如果有边 */ 
        E = (Edge)malloc( sizeof(struct ENode) ); /* 建立边结点 */ 
        /* 读入边,格式为"起点 终点 权重",插入邻接矩阵 */
        for (i=0; i<Graph->Ne; i++) {
            scanf("%d %d %d", &E->V1, &E->V2, &E->Weight); 
            /* 注意:如果权重不是整型,Weight的读入格式要改 */
            InsertEdge( Graph, E );
        }
    } 
 
    /* 如果顶点有数据的话,读入数据 */
    for (V=0; V<Graph->Nv; V++) 
        scanf(" %c", &(Graph->G[V].Data));
 
    return Graph;
}

C语言:图的存储

/* 邻接表存储的图 - DFS */
 
void Visit( Vertex V )
{
    printf("正在访问顶点%d\n", V);
}
 
/* Visited[]为全局变量,已经初始化为false */
void DFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) )
{   /* 以V为出发点对邻接表存储的图Graph进行DFS搜索 */
    PtrToAdjVNode W;
     
    Visit( V ); /* 访问第V个顶点 */
    Visited[V] = true; /* 标记V已访问 */
 
    for( W=Graph->G[V].FirstEdge; W; W=W->Next ) /* 对V的每个邻接点W->AdjV */
        if ( !Visited[W->AdjV] )    /* 若W->AdjV未被访问 */
            DFS( Graph, W->AdjV, Visit );    /* 则递归访问之 */
}


/* 邻接矩阵存储的图 - BFS */
 
/* IsEdge(Graph, V, W)检查<V, W>是否图Graph中的一条边,即W是否V的邻接点。  */
/* 此函数根据图的不同类型要做不同的实现,关键取决于对不存在的边的表示方法。*/
/* 例如对有权图, 如果不存在的边被初始化为INFINITY, 则函数实现如下:         */
bool IsEdge( MGraph Graph, Vertex V, Vertex W )
{
    return Graph->G[V][W]<INFINITY ? true : false;
}
 
/* Visited[]为全局变量,已经初始化为false */
void BFS ( MGraph Graph, Vertex S, void (*Visit)(Vertex) )
{   /* 以S为出发点对邻接矩阵存储的图Graph进行BFS搜索 */
    Queue Q;     
    Vertex V, W;
 
    Q = CreateQueue( MaxSize ); /* 创建空队列, MaxSize为外部定义的常数 */
    /* 访问顶点S:此处可根据具体访问需要改写 */
    Visit( S );
    Visited[S] = true; /* 标记S已访问 */
    AddQ(Q, S); /* S入队列 */
     
    while ( !IsEmpty(Q) ) {
        V = DeleteQ(Q);  /* 弹出V */
        for( W=0; W<Graph->Nv; W++ ) /* 对图中的每个顶点W */
            /* 若W是V的邻接点并且未访问过 */
            if ( !Visited[W] && IsEdge(Graph, V, W) ) {
                /* 访问顶点W */
                Visit( W );
                Visited[W] = true; /* 标记W已访问 */
                AddQ(Q, W); /* W入队列 */
            }
    } /* while结束*/
}

06-图1 列出连通集 (25 分)

给定一个有N个顶点和E条边的无向图,请用DFS和BFS分别列出其所有的连通集。假设顶点从0到N−1编号。进行搜索时,假设我们总是从编号最小的顶点出发,按编号递增的顺序访问邻接点。
输入格式:
输入第1行给出2个整数N(0<N≤10)和E,分别是图的顶点数和边数。随后E行,每行给出一条边的两个端点。每行中的数字之间用1空格分隔。
输出格式:
按照"{ v​1 v​2 … v​k }"的格式,每行输出一个连通集。先输出DFS的结果,再输出BFS的结果。

#include<stdio.h>
#include<stdlib.h>
 
#define MAXN 10
int visited[MAXN] = {0};
 
//建立邻接矩阵 //Create Graph
int G[MAXN][MAXN]={0},NV,NE;
 
void BuildGraph(){
	int i,j,v1,v2;
	scanf("%d%d",&NV,&NE);
	for( i=0; i<NE; i++){
		scanf("%d%d",&v1,&v2);               //InsertEdge
		G[v1][v2] = 1;
		G[v2][v1] = 1;
	}
}
//DFS
void DFS(int v)
{
	visited[v] = 1;
	printf("%d ",v);                        //输出这个点 
	for(int i=0; i<NV; i++){
		if(G[v][i] && !visited[i]){         //如果联通这个点且没有访问过 
			DFS(i);
		}
	}
} 
 
void ListComponentsDFS(){
	int i;	
	for(i=0; i<NV; i++){
		if(!visited[i]){ 
			printf("{ "); 
			DFS(i);
			printf("}\n");
		}
	}
}
//初始化visited
void isvisited(){
	for(int i=0; i<MAXN; i++){
		visited[i] = 0;
	}
}  
//BFS
void BFS(int v){
	const int MAXSIZE=100;                 //队列
	int quene[MAXSIZE];
	int first = -1, rear = -1; 
	quene[++rear] = v;//入队 
	visited[v] = 1;
	while(first < rear){                   //队列不为空
		int de = quene[++first];           //出队
		printf("%d ",de);
		for(int i=0; i<NV; i++){
			if(!visited[i]&&G[de][i]){
				visited[i] = 1;
				quene[++rear] = i;
			}
		} 
	} 
}
 
 
void ListComponentsBFS(){
	int i;	
	for(i=0; i<NV; i++){
		if(!visited[i]){
			printf("{ "); 
			BFS(i);
			printf("}\n");
		}
	}
}
 
int main(){
	BuildGraph();                     //建图
	ListComponentsDFS();              //DFS遍历连通集
	isvisited();                      //BFS遍历连通集 
	ListComponentsBFS();	
	return 0;
}

06-图2 Saving James Bond - Easy Version (25 分)

This time let us consider the situation in the movie “Live and Let Die” in which James Bond, the world’s most famous spy, was captured by a group of drug dealers. He was sent to a small piece of land at the center of a lake filled with crocodiles. There he performed the most daring action to escape – he jumped onto the head of the nearest crocodile! Before the animal realized what was happening, James jumped again onto the next big head… Finally he reached the bank before the last crocodile could bite him (actually the stunt man was caught by the big mouth and barely escaped with his extra thick boot).
Assume that the lake is a 100 by 100 square one. Assume that the center of the lake is at (0,0) and the northeast corner at (50,50). The central island is a disk centered at (0,0) with the diameter of 15. A number of crocodiles are in the lake at various positions. Given the coordinates of each crocodile and the distance that James could jump, you must tell him whether or not he can escape.
Input Specification:
Each input file contains one test case. Each case starts with a line containing two positive integers N (≤100), the number of crocodiles, and D, the maximum distance that James could jump. Then N lines follow, each containing the (x,y) location of a crocodile. Note that no two crocodiles are staying at the same position.
Output Specification:
For each test case, print in a line “Yes” if James can escape, or “No” if not.

#include<stdio.h>
#include <math.h>
#include<stdbool.h>

int n, m;
#define MINLEN 42.5

struct Pointer {
    int x;
    int y;
}p[101];

bool answer = false;           /* 记录007能否安全逃生~~ */
bool visited[101] = {false};   /* 判断当前点是否被访问过 */

bool isSave(int x) {           /* 判断从当前点能否跳到岸上 */
    if ((p[x].x - m <= -50) || (p[x].x + m >= 50) || (p[x].y - m <= -50) || (p[x].y + m >= 50))
        return true;
    return false;
}

bool jump(int x, int y) {       /* 判断2个点距离是否在跳跃能力内 */
        int p1 = pow(p[x].x - p[y].x, 2);
        int p2 = pow(p[x].y - p[y].y, 2);
        int r = m * m;
        if (p1 + p2 <= r)
            return true;
        return false;
}

bool firstJump(int x) {         /* 第一次可以选择跳的鳄鱼由于小岛半径的原因算法不同单独判断 */
    int p1 = pow(p[x].x , 2);
    int p2 = pow(p[x].y , 2);
    int r = (m+7.5) * (m+7.5);
    if (p1 + p2 <= r){
        return true;
    }
    return false;
}
bool dfs(int x) {               /* DFS */
    visited[x] = true;
    if (isSave(x)) {
        answer = true;
    }
    for (int i = 0; i < n; i++) {
        if (!visited[i] && jump(x, i)){ /* 没访问过且在可跳 */
            answer = dfs(i);
            if (answer == true)
                break;
        }
    }
    return answer;
}

int main() {
	scanf("%d %d",&n,&m);
    for (int i = 0; i < n; i++) {
		scanf("%d %d",&p[i].x,&p[i].y);
    }
    if (m >= MINLEN) {                   /* 节点可上岸 */
        printf("Yes\n");
        return 0;
    }
    for (int i = 0; i < n; i++) {
        if (firstJump(i) && !visited[i]) { /* 如果第一次能够跳的 并且之前没有访问过的节点 则深搜该节点 */
            if (dfs(i))
                break;
        }
    }
    if (answer == true)
        printf("Yes\n");
    else
        printf("No\n");
    return 0;
}

06-图3 六度空间 (30 分)

这题没时间做了参照,博客https://blog.youkuaiyun.com/qq_36589706/article/details/84334446
在这里插入图片描述

#include<cstdio>
#include<queue>
#include<string.h>
using namespace std;
int const maxn=10000;
int N, M;
int visit[maxn];
int arr[maxn][maxn];
int BFS(int v){
	queue<int> q;
	int temp, level=0, tail, last=v, count=1;
	q.push(v);
	visit[v]=1;
	while(!q.empty()){
		temp=q.front();
		q.pop();
		for(int i=1; i<=N; i++){
			if(arr[temp][i]&&visit[i]==0){
				count++;
				tail=i;
				visit[i]=1;
				q.push(i);
			}
		}
		if(temp==last){
			level++;
			last=tail;
		}
		if(level==6)break;
	}
	return count;
}
int main(){
	scanf("%d%d", &N, &M);
	int a, b;
	for(int i=0; i<M; i++){
		scanf("%d%d", &a, &b);
		arr[a][b]=1;
		arr[b][a]=1;
	}
	for(int i=1; i<=N; i++){
		int cnt=BFS(i);
		memset(visit, 0, sizeof(visit));
		double f=100.00*cnt/N;
		printf("%d: %.02f%%\n", i, f);
	}
 
	return 0;
}
数据结构——浙大版中国大学mooc(week10) 排序(下)课程给出代码10-排序4 统计工龄 (20 分)10-排序5 PAT Judge (25 分)10-排序6 Sort with Swap(0, i) (25 分) 课程给出代码 C语言:快速排序 /* 快速排序 - 直接调用库函数 */ #include <stdlib.h> /*---------------简单整数排序--------------------*/ ... 阅读详情

相关推荐

EDK2多平台编译实战:从树莓派到RK3399的UEFI固件构建

本文提供了从树莓派到RK3399的EDK2多平台编译实战指南。详细介绍了UEFI固件构建的环境搭建、交叉编译配置、平台描述文件修改及常见问题排查,帮助开发者掌握为不同ARM架构硬件构建标准化启动固件的核心技能。

weixin_29193259的博客 839

数据结构学习记录——如何建立图(邻接矩阵、邻接表-图节点的结构、创建并初始化、插入变、完整图的建立)

二维数组表示图的邻接矩阵。它的大小是MaxVertexNum × MaxVertexNum,用于存储顶点之间边的权重或者存在的情况。(无权重且存在边用1表示,无权重且不存在边则用0表示;有权重且存在边用其权重表示,有权重且不存在边则用一个极大值表示。其中,DataType Data[MaxVertexNum],可以用来存储与每个顶点相关的其他数据。例如:如果图表示一个社交网络,则可以存储每个顶点的个人资料信息(姓名、性别、年龄等),故而它的类型可以是整型,也可以是结构体类型。

li13437542099的博客 2118

推荐系统(1):推荐系统评测

对于可以离线优化的指标,我个人的看法是应该在给定覆盖率、多样性、新颖性等限制条件下,尽量优化预测准确度。用一个数学公式表达,离线实验的优化目标是:最大化预测准确度使得 覆盖率 > A多样性 > B新颖性 > C其中,A、B、C的取值应该视不同的应用而定。

数据不会骗人 2527

用邻接表来表示图

typedef struct GNode *PtrToGNode; struct GNode{ int Nv;//顶点数 int Ne;//边数 AdjList G;//邻接表。AdjList要自己去定义 }; typedef PtrToGNode LGraph;//以邻接表存储的图类型 typedef struct VNode{ PtrToAdjVNode FirstEdge;

chy89224的博客 709

HID报告描述符实战解析:从Usage到Item的完整设计流程

本文深入解析了HID报告描述符的设计流程,从核心概念Usage(用途定义)入手,详细阐述了如何通过Item(条目)的三种角色——全局、局部与主干,构建出能被系统正确识别的设备“说明书”。文章以标准USB鼠标和键盘为例进行实战拆解,并介绍了使用Report ID与自定义设备等进阶设计方法,帮助开发者掌握这一实现USB设备即插即用的关键技术。

weixin_29230865的博客 282

[V-10]ARMv8/v9-CPU Virtualization-CPU虚拟化架构简介(vCPU/vPE)

本文简要介绍了CPU虚拟化架构的基础知识。

基层架构师的分享 1267

最短路径问题(2)

承接上一篇博客,展示另一道PTA问题    4-2 Shortest Path [4]   (25分) Write a program to find the weighted shortest distances from any vertex to a given source vertex in a digraph. If there is more than one mini

csucbMIT的博客 820

lammps案例:reaxff势模拟Fe(OH)3高温反应过程

所有的reaxff模拟,如:氧化、腐蚀、热裂解、燃烧等模拟,均可采用此模拟框架,只需要更换data文件、势文件,代码中的control文件可以不写,电荷平衡文件也可以用reaxff替换。该案例主要模拟Fe(OH)3在高温下的反应过程,主要代码来自lammps自带的案例。lammps自带案例没有产物输出,故在此基础上稍加修改,增加了产物输出命令。如果需要系统学习反应势的模拟,可考虑报名培训课程。本文分享一个reaxff反应势的案例。in文件代码已经注释,以供参考。大家好,我是小马老师。

lammps_jiayou的博客 1966

6-2 邻接表存储图的广度优先遍历 (20 分)第七章--图--基本概念-计算机17级

6-2 邻接表存储图的广度优先遍历 (20 分) 试实现邻接表存储图的广度优先遍历。 函数接口定义: void BFS ( LGraph Graph, Vertex S, void (*Visit)(Vertex) ); 其中LGraph是邻接表存储的图,定义如下: /* 邻接点的定义 */ typedef struct AdjVNode *PtrToAdjVNode; stru...

markconca的博客 6938

14 | TensorFlow2对阿拉伯语手写字符数据集进行识别

该数据集由 60 名参与者书写的16,800 个字符组成,年龄范围在 19 至 40 岁之间,90% 的参与者是右手。每个参与者在两种形式上写下每个字符(从“alef”到“yeh”)十次,如图 7(a)和 7(b)所示。表格以 300 dpi 的分辨率扫描。使用 Matlab 2016a 自动分割每个块以确定每个块的坐标。该数据库分为两组:训练集(每类 13,440 个字符到 480 个图像)和测试集(每类 3,360 个字符到 120 个图像)。数据标签为1到28个类别。

微信号:RunsenLiu 2881

量化交易零基础入门教程

特点 从零开始教编程。靠谱的量化交易学习资源稀少,且具有不讲编程、代码较难、过多等不适合新手等问题,本教程中则会从零开始教编程,解决量化入门过难过编程门槛这一问题。 量化与编程相结合。本教程不仅会教编程,而且会尽量结合量化情景,减少“我要做量化交易为什么要看这些用来培训程序员的东西”的愤懑。 简易精炼,快速入门。尽量只讲最核心最常用的知识,助你快速摆脱想学习量化却处处陌生不知所措的茫然的新手阶段。 读前说明 文后会有自测与自学,包括一些额外的延伸自学内容以及稍有难度的自测题目。 最最最基础的股票.

JanLEE 2889

数据结构——浙大版中国大学mooc(week5)

树(下)课程给出代码05-树7 堆中的路径 (25 分)05-树8 File Transfer (25 分)05-树9 Huffman Codes (30 分) 课程给出代码 C语言描述:堆的描述和操作 typedef struct HNode *Heap; /* 堆的类型定义 */ struct HNode { ElementType *Data; /* 存储元素的数组 */ i...

CodingW的博客 393

Unitree G1仿人机器人协同搬箱:从仿真搭建到多机协同部署完整指南

Unitree G1仿人机器人协同搬箱技术方案摘要 本文提供了一套完整的Unitree G1人形机器人协同搬箱解决方案,涵盖从仿真环境搭建到多机协同部署的全流程。核心内容包括: 双仿真环境配置:同时搭建Gazebo+ROS Noetic基础仿真环境与Isaac Gym+Mujoco高性能RL训练环境,支持Sim2Sim迁移验证 训练框架搭建:详细配置unitree_rl_gym框架,提供PPO算法定制化训练流程和参数优化方案 数据集应用:整合宇树开源真机数据集(UnifoLM-WBT-Dataset)~~~

huanghm88的专栏 477

数据结构——浙大版中国大学mooc(week8)

图(下)课程给出代码08-图7 公路村村通 (30 分)08-图8 How Long Does It Take (25 分)08-图9 关键活动 (30 分) 课程给出代码 C语言:邻接矩阵存储 - Prim最小生成树算法 /* 邻接矩阵存储 - Prim最小生成树算法 */ Vertex FindMinDist( MGraph Graph, WeightType dist[] ) { /* ...

CodingW的博客 365

大中型超市收银系统(可直接运行)

光步前台收银系统系统功能:商品销售、商品退货、挂单、收银员权限、会员销售、单品取消、整单取消、商品查询、脱机销售、脱机数据上传,基本资料下载,开钱箱、小票打印、收款结算,支持多币种付款方式(现金、储值卡、礼券、微信等),支持多种促销。运行环境:.net 4.0登陆信息用户名:1001 密码:123456内置商品信息,商品编码可输入00001000 - 00010000,测试效果相关功能键F5 结算 F9挂单 F11商品查询 F8退货 Insert单品取消 Del整单取消 F12开钱箱F2 会员 Ctrl+Z退出系统 Home 锁屏 相关源码待公开

数学建模模型总结

这是本人在两年内准备参加数学建模竞赛搜集到的模型资料,已经经过了本人的筛选和整理,希望能够对准备参加数学建模竞赛的学弟学妹们提供一些帮助!

数据结构——浙大版中国大学mooc(week2)

线性表02-线性结构1 两个有序链表序列的合并 (15 分)02-线性结构2 一元多项式的乘法与加法运算 (20 分)02-线性结构3 Reversing Linked List (25 分)02-线性结构4 Pop Sequence (25 分) 02-线性结构1 两个有序链表序列的合并 (15 分) List Merge( List L1, List L2 )//合并函数本题需要写的函数 {...

CodingW的博客 336

老版QQ原生表情gif动态

这是老版的QQ表情,不过全是动态的的,Windows照片查看器是不会动的,可以右击用浏览器打开查看,再说一遍是老版的,只是分享给宁愿用老版也要动态的人。

数据结构——浙大版中国大学mooc(week3)

树(上)03-树1 树的同构 (25 分)03-树2 List Leaves (25 分)03-树3 Tree Traversals Again (25 分) 03-树1 树的同构 (25 分) 题目:给定两棵树T1和T2。如果T1可以通过若干次左右孩子互换就变成T2,则我们称两棵树是“同构”的。例如图1给出的两棵树就是同构的,因为我们把其中一棵树的结点A、B、G的左右孩子互换后,就得到另外一棵树...

CodingW的博客 300

efm32 入门.pdf

本PDF共计22页,介绍的是操作驱动API,下载与否自己斟酌。

数据结构——浙大版中国大学mooc(week9)

排序(上)课程给出代码09-排序1 排序 (25 分)09-排序2 Insert or Merge (25 分)09-排序3 Insertion or Heap Sort (25 分) 课程给出代码 C语言:插入排序 void InsertionSort( ElementType A[], int N ) { /* 插入排序 */ int P, i; ElementType T...

CodingW的博客 403

数据结构——浙大版中国大学mooc(week7)

图(中)课程给出代码07-图4 哈利·波特的考试 (25 分)07-图5 Saving James Bond - Hard Version (30 分)07-图6 旅游规划 (25 分) 课程给出代码 C语言:邻接表存储 - 无权图的单源最短路算法 /* 邻接表存储 - 无权图的单源最短路算法 */ /* dist[]和path[]全部初始化为-1 */ void Unweighted ( L...

CodingW的博客 485

数据结构——浙大版中国大学mooc(week1)

二分查找与最大子列和课程给出代码01-复杂度3 二分查找 (20 分)01-复杂度1 最大子列和问题 (20 分)01-复杂度2 Maximum Subsequence Sum (25 分) 课程给出代码 第一周的课程主要就是给出了一个例子即最大子数列和的问题,在这基础上提出了四种解决方案,其中第三种和第四种最为实用,下面代码给出的是第三种方法即分而治之。有点像二分法但采用了递归,对内存的损耗较大...

CodingW的博客 274

数据结构——浙大版中国大学mooc(week4)

树(中)课程给出代码课程给出代码课程给出代码课程给出代码课程给出代码 课程给出代码 C语言表示二叉搜索树的插入和搜索 BinTree Insert( BinTree BST, ElementType X ) { if( !BST ){ /* 若原树为空,生成并返回一个结点的二叉搜索树 */ BST = (BinTree)malloc(sizeof(struct TNode)...

CodingW的博客 315

MOOC 数据结构 | 6. 图(上)

六度空间理论(Six Degrees of Separation): 你和任何一个陌生人之间所间隔的人不会超过六个,也就是说,最多通过五个中间人你就能够认识任何一个陌生人 1.什么是图(Graph) 表示“多对多”的关系 包含 一组顶点:通常用V(Vertex)表示顶点集合 一组边:通常用E(Edge)表示边的集合 边是顶点对:,其中v, wV ...

明朗晨光的专栏 1676

图的遍历-DFS与BFS

图的遍历 一般的对图来说有两种遍历方式,可以把树当成特殊的图,可以使用DFS与BFS来达到遍历的目的。 接下来以例子说明: C++代码 #include<bits/stdc++.h> using namespace std;const int maxn=50; const int INF=32767; int G[maxn][maxn]; int vsit[maxn];void dfs(in

Lin's Blog 332

图的遍历。

图的遍历:从图中的任意顶点出发,对图中的所有顶点访问一次且只访问一次的次序序列。 深度优先搜索 深度优先搜索(Depth First Search)类似于树的先序遍历,共同的思想为,先访问根节点(当然图里面好像没有根节点这个说法),再去递归地访问根节点的所有邻接点。核心还是递归,只不过由于图更加复杂,所以需要一个访问标志数组Visited[ ],来记录哪些顶点被访问过。 按照陈越姥姥的说法,深度优先搜索是从图中的某个顶点V0出发,访问此顶点,然后依次从V0的未被访问的邻接点出发递归进行同样的深度优先搜索,直

weixin_55746099的博客 304

数据结构pta图作业

选择判断知识点 无向连通图所有顶点的度之和为偶数。无向连通图:任何两个结点之间是连通的,都存在一条路径,且图中无方向。性质:①无向连通图所有顶点的度之和为边数*2。②边数等于顶点个数。 无向连通图边数一定大于顶点个数减1。(F) 三个顶点,两条边。 用邻接表法存储图,占用的存储空间数只与图中结点个数有关,而与边数无关。(F) 解析:设结点数为n,边数m,空间复杂度O(n+m)。如图,节点个数为V0~V5,边数用箭头表示,故只要两个节点之间有边相连,就会分配存储空间。 用邻接矩阵法存储图,占.

Stella218的博客 5225

图1-2、图的遍历

1、深度优先搜索 /* 邻接表存储的图 - DFS */ void Visit( Vertex V ) { printf("正在访问顶点%d\n", V); } /* Visited[]为全局变量,已经初始化为false */ void DFS( LGraph Graph, Vertex V, void (*Visit)(Vertex) ) {...

ditai7690的博客 323
上一篇: 数据结构——浙大版中国大学mooc(week5)
下一篇: 数据结构——浙大版中国大学mooc(week7)
CodingW
博客等级 码龄8年 3粉丝 16原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明:

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

余额充值