精华内容
下载资源
问答
  • 算法与数据结构的是不常使用的,而且操作上比较繁琐,但不得不说花样很多所以我还是参考了很多其他博主的代码和书上的代码进行了实现 直接看代码: #include<stdio.h> #include<stdlib.h> #include<...

    算法与数据结构的图是不常使用的,而且操作上比较繁琐,但不得不说花样很多所以我还是参考了很多其他博主的代码和书上的代码进行了实现
    直接看代码:

    #include<stdio.h>
    #include<stdlib.h>
    #include<malloc.h>
    #include<string.h>
    
    //图的结构:多对多的关系
    //图中有点和边,点:数据,边:描述点之间的关系
    //主要描述方式:邻接矩阵,邻接表
    //邻接矩阵:基于数组->用一个一维数组存储顶点,用一个二位数组存储边
    //邻接表:基于链表->用一个一维数组或者一个链表来存储所有顶点
    //其中每个顶点都是一个链表的头结点,后面跟着所有能通过边到达的顶点
    
    #define max 100
    #define countless 32767
    typedef enum { FALSE, TRUE }sf;
    sf visit[max];
    
    //邻接矩阵
    typedef struct graph
    {
    	char vexs[max];//顶点
    	int arcs[max][max];//邻接矩阵
    	int vexnum;//顶点数
    	int edgenum;//边数
    }g;
    
    //获取顶点v的下标
    int location(g* node, char v)
    {
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		if (v == node->vexs[i])
    		{
    			return i;//返回下标
    		}
    		else
    		{
    			/*printf("顶点不存在\n");*/
    		}
    	}
    	return -1;
    }
    
    
    //创建无向图
    void creategraph1(g* node)
    {
    	//输入边数和顶点数
    	printf("输入顶点数:");
    	scanf_s("%d", &node->vexnum);
    	printf("输入边数:");
    	scanf_s("%d", &node->edgenum);
    	//用户输入顶点
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		printf("请输入第%d个顶点:",i+1);
    		scanf_s(" %c", &node->vexs[i], 1);
    		/*fflush(stdin);*/
    	}
    	//矩阵初始化
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		for (int j = 0; j < node->vexnum; j++)
    		{
    			node->arcs[i][j] = 0;//让矩阵置空为0,即点都不连通
    		}
    	}
    	//构建无向图的邻接矩阵
    	char v1, v2;
    	int n, m;
    	printf("请输入边之间的关系(例:AB连通->AB):\n");
    	for (int i = 0; i < node->edgenum; i++)
    	{
    		/*fflush(stdin);*/
    		scanf_s(" %c %c", &v1, 1, &v2, 1);
    		n = location(node, v1);//获取顶点的下标
    		m = location(node, v2);
    		if (n == -1 || m == -1)
    		{
    			printf("顶点不存在\n");
    			return;
    		}
    		else
    		{
    			node->arcs[n][m] = 1;//无向图只要连通就是1
    			node->arcs[m][n] = 1;
    		}
    	}
    }
    
    //创建有向图
    void creategraph2(g* node)
    {
    	//输入顶点数和边数
    	printf("请输入顶点数:");
    	scanf_s("%d", &node->vexnum);
    	printf("请输入边数:");
    	scanf_s("%d", &node->edgenum);
    	//输入顶点
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		printf("请输入第%d个顶点:", i + 1);
    		scanf_s(" %c", &node->vexs[i],1);
    	}
    	//邻接矩阵初始化
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		for (int j = 0; j < node->vexnum; j++)
    		{
    			node->arcs[i][j] = 0;
    		}
    	}
    	//创建有向图的邻接矩阵
    	char v1, v2;
    	int n, m;
    	printf("请输入边之间的关系(例:AB有序连通->AB):\n");
    	for (int i = 0; i < node->edgenum; i++)
    	{
    		scanf_s(" %c %c", &v1, 1, &v2, 1);
    		n = location(node, v1);
    		m = location(node, v2);
    		if (n == -1 || m == -1)
    		{
    			printf("顶点不存在\n");
    			return;
    		}
    		else
    		{
    			node->arcs[n][m] = 1;//有方向所以只要一个
    		}
    	}
    }
    
    void print1(g* node)
    {
    	printf("邻接矩阵为:\n");
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		printf("\t%c", node->vexs[i]);
    	}
    	printf("\n");
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		printf("%c\t", node->vexs[i]);
    		for (int j = 0; j < node->vexnum; j++)
    		{
    			printf("%d\t", node->arcs[i][j]);
    		}
    		printf("\n\n");
    	}
    }
    
    //邻接矩阵的深度优先遍历——类似与树的前序遍历。
    // 从图中的某个顶点v出发,访问此顶点,然后从v的未被访问到的邻接点进行遍历,
    //直到图中所有和v有路径相通的顶点都被访问到
    //(注:优先访问外层节点,访问到无新顶点时,会进行回退,访问未被访问过的分支顶点)。
    
    //广度优先遍历——类似于树的层序遍历。从图中的某个顶点w出发,让顶点w入队,
    // 然后顶点w再出队,并让所有和顶点w相连的顶点入队,
    //然后再出队一个顶点t,并让所有和t相连但未被访问过的顶点入队……由此循环,指定图中所有元素都出队。
    
    //队列结构体
    typedef struct queue
    {
    	int data[max];
    	int front;
    	int rear;
    }que;
    
    //初始化队列
    void initque(que* qu)
    {
    	qu->front = qu->rear = 0;
    }
    
    //判断队空
    int empty(que* qu)
    {
    	if (qu->front == qu->rear)
    	{
    		return 1;
    	}
    	else
    	{
    		return 0;
    	}
    }
    
    //入队
    void push(que* qu, int x)
    {
    	if (qu->rear + 1 == max)
    	{
    		printf("队满无法入队");
    	}
    	else
    	{
    		qu->data[qu->rear] = x;
    		qu->rear++;
    	}
    }
    
    //出队
    int pop(que* qu)
    {
    	int temp;
    	if (qu->rear == qu->front)
    	{
    		printf("队列为空无法出队\n");
    	}
    	else
    	{
    		qu->front++;
    		temp = qu->data[qu->front - 1];
    		return temp;
    	}
    }
    
    //打印队列
    void print(que* node)
    {
    	if (node->front == node->rear)
    	{
    		printf("队列为空无法打印\n");
    	}
    	else
    	{
    		printf("当前队列为:\n");
    		for (int i = node->front; i < node->rear; i++)
    		{
    			printf("%d\t", node->data[i]);
    		}
    		printf("\n");
    	}
    }
    
    //广度优先算法BFS
    void BFSuse1(g* node, int k)
    {
    	int i, j;
    	que* qu;
    	qu = (que*)malloc(sizeof(que));
    	initque(qu);
    	visit[k] = TRUE;
    	push(qu, k);
    	printf("%c\t", node->vexs[k]);
    	while (empty(qu) != 1)
    	{
    		i = pop(qu);
    		for (j = 0; j < node->vexnum; j++)
    		{
    			if (node->arcs[i][j] == 1 && !visit[j])
    			{
    				printf("%c\t", node->vexs[j]);
    				visit[j] = TRUE;
    				push(qu, j);
    			}
    		}
    	}
    }
    
    void BFS1(g* node)
    {
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		visit[i] = FALSE;
    	}
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		if (!visit[i])
    		{
    			BFSuse1(node, i);
    		}
    	}
    }
    
    //深度优先算法DFS
    void DFSuse1(g* node,int i)
    {
    	printf("%c\t", node->vexs[i]);
    	visit[i] = 1;
    	for (int j = 0; j < node->vexnum; j++)
    	{
    		if (node->arcs[i][j] == 1 && !visit[j])
    		{
    			DFSuse1(node, j);
    		}
    	}
    }
    
    void DFS1(g* node)
    {
    	int i;
    	for (i = 0; i < node->vexnum; i++)
    	{
    		visit[i] = FALSE;
    	}
    	for (i = 0; i < node->vexnum; i++)
    	{
    		if (!visit[i])
    		{
    			DFSuse1(node, i);
    		}
    	}
    }
    
    //========================================================================
    
    //图的邻接表实现
    //顶点存在一维数组中,边的信息存在链表中
    //边表的结构体
    typedef struct Edge
    {
    	int edgedata;//数据域,存储顶点的下标
    	struct Edge* next;//指针域
    }edge;
    
    //顶点表的结构体
    typedef struct Vnode
    {
    	char nodedata;//真实数据
    	edge* next_to_edge;
    }vn, vnode[max];
    
    //图的结构体
    typedef struct listgraph
    {
    	vnode nodelist;
    	int list_edgenum;
    	int list_vexnum;
    }lg;
    
    //邻接表创建无向图
    void creategraph3(lg* node)
    {
    	edge* e;
    	printf("输入顶点数:");
    	scanf_s("%d", &node->list_vexnum);
    	printf("输入边数:");
    	scanf_s("%d", &node->list_edgenum);
    	//输入顶点
    	for (int i = 0; i < node->list_vexnum; i++)
    	{
    		printf("请输入第%d个顶点:", i + 1);
    		scanf_s(" %c", &node->nodelist[i].nodedata,1);
    		node->nodelist[i].next_to_edge = NULL;
    	}
    	//邻接表初始化
    	int v1, v2;
    	printf("请输入边之间的关系(例:AB连通->0 1):\n");
    	for (int i = 0; i < node->list_edgenum; i++)
    	{
    		scanf_s(" %d %d", &v1, &v2);
    		e = (edge*)malloc(sizeof(edge));
    		if (e == NULL)
    		{
    			printf("error!内存申请失败\a");
    			return;
    		}
    		else
    		{
    			e->edgedata = v2;
    			e->next = node->nodelist[v1].next_to_edge;//把末尾结点的指针域给新结点
    			node->nodelist[v1].next_to_edge = e;//原结点指针域后继为新结点
    		}
    		e = (edge*)malloc(sizeof(edge));
    		if (e == NULL)
    		{
    			printf("error!内存申请失败\a");
    			return;
    		}
    		else
    		{
    			e->edgedata = v1;
    			e->next = node->nodelist[v2].next_to_edge;//把末尾结点的指针域给新结点
    			node->nodelist[v2].next_to_edge = e;//原结点指针域后继为新结点
    		}
    	}
    
    }
    
    //邻接表创建有向图
    void creategraph4(lg* node)
    {
    	//输入边数和顶点数
    	edge* e;
    	printf("输入顶点数:");
    	scanf_s("%d", &node->list_vexnum);
    	printf("输入边数:");
    	scanf_s("%d", &node->list_edgenum);
    	//输入顶点
    	for (int i = 0; i < node->list_vexnum; i++)
    	{
    		printf("请输入第%d个顶点:", i + 1);
    		scanf_s(" %c", &node->nodelist[i].nodedata, 1);
    		node->nodelist[i].next_to_edge = NULL;
    	}
    	//邻接表初始化
    	int v1, v2;
    	printf("请输入边之间的关系(例:AB连通->0 1):\n");
    	for (int i = 0; i < node->list_edgenum; i++)
    	{
    		scanf_s(" %d %d", &v1, &v2);
    		e = (edge*)malloc(sizeof(edge));
    		if (e == NULL)
    		{
    			printf("error!内存申请失败\a");
    			return;
    		}
    		else
    		{
    			e->edgedata = v2;
    			e->next = node->nodelist[v1].next_to_edge;//把末尾结点的指针域给新结点
    			node->nodelist[v1].next_to_edge = e;//原结点指针域后继为新结点
    		}
    	}
    }
    
    //邻接表的打印
    void print2(lg* node)
    {
    	edge* e;
    	printf("邻接表为:\n");
    	for (int i = 0; i < node->list_vexnum; i++)
    	{
    		e = node->nodelist[i].next_to_edge;
    		while (e != NULL)
    		{
    			printf("结点 %c ->结点 %c\t\t", node->nodelist[i].nodedata, node->nodelist[e->edgedata].nodedata);
    			e = e->next;
    		}
    		printf("\n\n");
    	}
    }
    
    //邻接表的BFS
    int visit2[max];
    void BFS2(lg* node)
    {
    	que* qu = (que*)malloc(sizeof(que));
    	for (int i = 0; i < node->list_vexnum; i++)
    	{
    		visit2[i] = 0;
    	}
    	initque(qu);
    	for (int i = 0; i < node->list_vexnum; i++)
    	{
    		visit2[i] = 1;
    		printf("%c\t", node->nodelist[i].nodedata);
    		push(qu, i);
    		while (empty(qu) != 1)
    		{
    			pop(qu);
    			edge* e = node->nodelist[i].next_to_edge;
    			while (e)
    			{
    				if (!visit2[e->edgedata])
    				{
    					visit2[e->edgedata] = 1;
    					printf("%c\t", node->nodelist[e->edgedata].nodedata);
    					push(qu, e->edgedata);
    				}
    				e = e->next;
    			}
    			printf("\n");
    		}
    	}
    }
    
    //邻接表的深度优先DFS
    int visited1[max];
    void DFSuse2(lg* node, int i)
    {
    	edge* p;
    	visited1[i] = 1;
    	printf("%c\t", node->nodelist[i].nodedata);
    	p = node->nodelist[i].next_to_edge;
    	while (p)
    	{
    		if (!visited1[p->edgedata])
    		{
    			DFSuse2(node, p->edgedata);
    		}
    		p = p->next;
    	}
    }
    void DFS2(lg* node)
    {
    	int i;
    	for (i = 0; i < node->list_vexnum; i++)
    	{
    		visited1[i] = 0;
    	}
    	for (i = 0; i < node->list_vexnum; i++)
    	{
    		if (!visited1[i])
    		{
    			DFSuse2(node, i);
    		}
    	}
    }
    
    //prime最小生成树
    void mintree_prime(g* node)
    {
    	int min, j, k;
    	int adjvex[max];
    	int lowcost[max];//最短路径,最小代价
    	//init
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		lowcost[i] = node->arcs[0][i];
    		adjvex[i] = 0;
    	}
    	for (int i = 0; i < node->vexnum; i++)
    	{
    		min = max;
    		j = 1;
    		k = 0;
    		while (j < node->vexnum)
    		{
    			if (lowcost[j] != 0 && lowcost[j] < min)
    			{
    				min = lowcost[j];
    				k = j;
    			}
    			j++;
    		}
    		//打印
    		printf("%d,%d", adjvex[k], k);
    		lowcost[k] = 0;
    		for (j = 1; j < node->vexnum; j++)
    		{
    			if (lowcost[j] != 0 && node->arcs[k][j] < lowcost[j]);
    			adjvex[j] = k;
    		}
    	}
    }
    
    
    int main()
    {
    	int choose;
    	g* node = (g*)malloc(sizeof(g));
    	lg* listnode = (lg*)malloc(sizeof(lg));
    	while (1)
    	{
    		printf("*****************************图的基本操作*****************************\n");
    		printf("*****************************1.创建无向图(邻接矩阵)*****************\n");
    		printf("*****************************2.创建有向图(邻接矩阵)*****************\n");
    		printf("*****************************3.创建无向图(邻接表)*******************\n");
    		printf("*****************************4.创建有向图(邻接表)*******************\n");
    		printf("*****************************5.广度优先算法(邻接矩阵)***************\n");
    		printf("*****************************6.深度优先算法(邻接矩阵)***************\n");
    		printf("*****************************7.广度优先算法(邻接表)*****************\n");
    		printf("*****************************8.深度优先算法(邻接表)*****************\n");
    		printf("*****************************9.Prime最小生成树************************\n");
    		printf("*****************************10.退出exit******************************\n");
    		printf("**********************************************************************\n");
    		printf("请输入你的选择:");
    		scanf_s("%d", &choose);
    		if (choose == 10)
    		{
    			printf("程序退出》》》");
    			break;
    		}
    		switch (choose)
    		{
    			case 1:
    				creategraph1(node);
    				print1(node);
    				break;
    			case 2:
    				creategraph2(node);
    				print1(node);
    				break;
    			case 3:
    				creategraph3(listnode);
    				print2(listnode);
    				break;
    			case 4:
    				creategraph4(listnode);
    				print2(listnode);
    				break;
    			case 5:
    				printf("图的邻接矩阵广度优先遍历为:\n");
    				BFS1(node);
    				printf("\n");
    				break;
    			case 6:
    				printf("图的邻接矩阵深度优先遍历为:\n");
    				DFS1(node);
    				printf("\n");
    				break;
    			case 7:
    				printf("图的邻接表广度优先遍历为:\n");
    				BFS2(listnode);
    				printf("\n");
    				break;
    			case 8:
    				printf("图的邻接表深度优先遍历为:\n");
    				DFS2(listnode);
    				printf("\n");
    				break;
    			case 9:
    				printf("prime最小生成树为:\n");
    				mintree_prime(node);
    				printf("\n");
    				break;
    			default:
    				printf("error!\a\n");
    				break;
    		}
    	}
    	return 0;
    }
    

    程序截图:
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    其中prime最小生成树的实现有一定的问题我会在后续进行改写和实现。

    展开全文
  • JPEG图像压缩c语言算法

    热门讨论 2010-08-10 09:59:54
    JPEG图像压缩算法.rar\有关图像jpeg压缩算法介绍及其源码
  • c语言算法

    2017-10-07 22:27:15
    包括需要什么数据(输入什么数据、输出什么结果)、采用什么结构、使用什么语句以及如何安排这些语句等,通常使用自然语言、结构化流程、伪代码等来描述算法。计算机算法可分为两大类别:数值运算算法和非数值运算...
    算法(Algorithm):计算机解题的基本思想方法和步骤。算法的描述:是对要解决一个问题或要完成一项任务所采取的方法和步骤的描述,包括需要什么数据(输入什么数据、输出什么结果)、采用什么结构、使用什么语句以及如何安排这些语句等,通常使用自然语言、结构化流程图、伪代码等来描述算法。计算机算法可分为两大类别:数值运算算法和非数值运算算法。算法的特点:①有穷性。②确定性。③有零个或多个输入。④有一个或多个输出。⑤有效性。算法的表示方式:①自然语言。②传统流程图。③结构化流程图。④伪代码。⑤PAD图。 3种基本结构:①顺序结构。②选择结构。③循环结构。⑴直到型循环结构。⑵当型循环结构。
     3种循环结构的共同点:①只有一个出口。②只有一个入口。③结构内的每一部分都有机会被执行到。④结构内不存在“死循环”。伪代码是用介于自然语言和计算机语言之间的文字和符号来描述算法。
    
    展开全文
  • C语言图算法

    2012-09-08 09:11:57
    这是采用C语言编写的图算法,是算法分析与设计课程里面的一个很重要的算法
  • 该课件是我在大学期间有用过的课件,结合严蔚敏老师的课本。感觉挺不错的。
  • 主要讲述C语言中常用算法 插值算法 排序 图形模式下读写屏幕 复数运算
  • c语言算法导航.rar

    2020-12-22 18:54:53
    c语言,文件读写,动态显示地图(利用dda算法),求最短路径,增删地点,算法校园导航,算法期末作业;也可以作为C的作业。
  • C语言算法基础

    千次阅读 2014-12-19 09:03:16
    C语言算法基础      算法(Algorithm):计算机解题的基本思想方法和步骤算法的描述:是对要解决一个问题或要完成一项任务所采取的方法和步骤的描述,包括需要什么数据(输入什么数据、输出什么...
    C语言算法基础
     
     

           算法(Algorithm):计算机解题的基本思想方法和步骤嵌入式培训,LINUX培训,C培训,Wince培训,Android培训算法的描述:是对要解决一个问题或要完成一项任务所采取的方法和步骤的描述,包括需要什么数据(输入什么数据、输出什么结果)、采用什么结构、使用什么语句以及如何安排这些语句等嵌入式培训,LINUX培训,C培训,Wince培训,Android培训通常使用自然语言、结构化流程图、伪代码等来描述算法嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        一、计数、求和、求阶乘等简单算法
        此类问题都要使用循环,要注意根据问题确定循环变量的初值、终值或结束条件,更要注意用来表示计数、和、阶乘的变量的初值嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        例:用随机函数产生100个[0,99]范围内的随机整数,统计个位上的数字分别为1,2,3,4,5,6,7,8,9,0的数的个数并打印出来嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        本题使用数组来处理,用数组a[100]存放产生的确100个随机整数,数组x[10]来存放个位上的数字分别为1,2,3,4,5,6,7,8,9,0的数的个数嵌入式培训,LINUX培训,C培训,Wince培训,Android培训即个位是1的个数存放在x[1]中,个位是2的个数存放在x[2]中,……个位是0的个数存放在x[10]嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        void main()
        { int a[101],x[11],i,p;
        for(i=0;i<=11;i++)
        x[i]=0;
        for(i=1;i<=100;i++)
        { a[i]=rand() % 100;
        printf(\"%4d\",a[i]);
        if(i%10==0)printf(\"\\n\");
        }
        for(i=1;i<=100;i++)
        { p=a[i]%10;
        if(p==0) p=10;
        x[p]=x[p]+1;
        }
        for(i=1;i<=10;i++)
        { p=i;
        if(i==10) p=0;
        printf(\"%d,%d\\n\",p,x[i]);
        }
        printf(\"\\n\");
        }
        二、求两个整数的最大公约数、最小公倍数
        分析:求最大公约数的算法思想:(最小公倍数=两个整数之积/最大公约数)
        (1) 对于已知两数m,n,使得m>n;
        (2) m除以n得余数r;
        (3) 若r=0,则n为求得的最大公约数,算法结束;否则执行(4);
        (4) m←n,n←r,再重复执行(2)嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        例如: 求 m=14 ,n=6 的最大公约数. m n r
        14 6 2
        6 2 0
        void main()
        { int nm,r,n,m,t;
        printf(\"please input two numbers:\\n\");
        scanf(\"%d,%d\",&m,&n);
        nm=n*m;
        if (m<n)
        { t=n; n=m; m=t; }
        r=m%n;
        while (r!=0)
        { m=n; n=r; r=m%n; }
        printf(\"最大公约数:%d\\n\",n);
        printf(\"最小公倍数:%d\\n\",nm/n);
        }
        三、判断素数
        只能被1或本身整除的数称为素数 基本思想:把m作为被除数,将2—INT( )作为除数,如果都除不尽,m就是素数,否则就不是嵌入式培训,LINUX培训,C培训,Wince培训,Android培训(可用以下程序段实现)
        void main()
        { int m,i,k;
        printf(\"please input a number:\\n\");
        scanf(\"%d\",&m);
        k=sqrt(m);
        for(i=2;i<k;i++)
        if(m%i==0) break;
        if(i>=k)
        printf(\"该数是素数\");
        else
        printf(\"该数不是素数\");
        }
        将其写成一函数,若为素数返回1,不是则返回0
        int prime( m%)
        {int i,k;
        k=sqrt(m);
        for(i=2;i<k;i++)
        if(m%i==0) return 0;
        return 1;
        }
        四、验证哥德巴赫猜想
        (任意一个大于等于6的偶数都可以分解为两个素数之和)
        基本思想:n为大于等于6的任一偶数,可分解为n1和n2两个数,分别检查n1和n2是否为素数,如都是,则为一组解嵌入式培训,LINUX培训,C培训,Wince培训,Android培训如n1不是素数,就不必再检查n2是否素数嵌入式培训,LINUX培训,C培训,Wince培训,Android培训先从n1=3开始,检验n1和n2(n2=N-n1)是否素数嵌入式培训,LINUX培训,C培训,Wince培训,Android培训然后使n1+2 再检验n1、n2是否素数,… 直到n1=n/2为止嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        利用上面的prime函数,验证哥德巴赫猜想的程序代码如下:
        #include \"math.h\" [Page]
        int prime(int m)
        { int i,k;
        k=sqrt(m);
        for(i=2;i<k;i++)
        if(m%i==0) break;
        if(i>=k)
        return 1;
        else
        return 0;
        }
        main()
        { int x,i;
        printf(\"please input a even number(>=6):\\n\");
        scanf(\"%d\",&x);
        if (x<6||x%2!=0)
        printf(\"data error!\\n\");
        else
        for(i=2;i<=x/2;i++)
        if (prime(i)&&prime(x-i))
        {
        printf(\"%d+%d\\n\",i,x-i);
        printf(\"验证成功!\");
        break;
        }
        }
        五、排序问题
        1.选择法排序(升序)
        基本思想:
        1)对有n个数的序列(存放在数组a(n)中),从中选出最小的数,与第1个数交换位置;
        2)除第1 个数外,其余n-1个数中选最小的数,与第2个数交换位置;
        3)依次类推,选择了n-1次后,这个数列已按升序排列嵌入式培训,LINUX培训,C培训,Wince培训,Android培训

        程序代码如下:
        void main()
        { int i,j,imin,s,a[10];
        printf(\"\\n input 10 numbers:\\n\");
        for(i=0;i<10;i++)
        scanf(\"%d\",&a[i]);
        for(i=0;i<9;i++)
        { imin=i;
        for(j=i+1;j<10;j++)
        if(a[imin]>a[j]) imin=j;
        if(i!=imin)
        {s=a[i]; a[i]=a[imin]; a[imin]=s; }
        printf(\"%d\\n\",a[i]);
        }
        }
        2.冒泡法排序(升序)
        基本思想:(将相邻两个数比较,小的调到前头)
        1)有n个数(存放在数组a(n)中),第一趟将每相邻两个数比较,小的调到前头,经n-1次两两相邻比较后,最大的数已“沉底”,放在最后一个位置,小数上升“浮起”;
        2)第二趟对余下的n-1个数(最大的数已“沉底”)按上法比较,经n-2次两两相邻比较后得次大的数;
        3)依次类推,n个数共进行n-1趟比较,在第j趟中要进行n-j次两两比较嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        程序段如下
        void main()
        { int a[10];
        int i,j,t;
        printf(\"input 10 numbers\\n\");
        for(i=0;i<10;i++)
        scanf(\"%d\",&a[i]);
        printf(\"\\n\");
        for(j=0;j<=8;j++)
        for(i=0;i<9-j;i++)
        if(a[i]>a[i+1])
        {t=a[i];a[i]=a[i+1];a[i+1]=t;}
        printf(\"the sorted numbers:\\n\");

     

        for(i=0;i<10;i++)
        printf(\"%d\\n\",a[i]);
        }
        3.合并法排序(将两个有序数组A、B合并成另一个有序的数组C,升序)
        基本思想:
        1)先在A、B数组中各取第一个元素进行比较,将小的元素放入C数组;
        2)取小的元素所在数组的下一个元素与另一数组中上次比较后较大的元素比较,重复上述比较过程,直到某个数组被先排完;
        3)将另一个数组剩余元素抄入C数组,合并排序完成嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        程序段如下:
        void main()
        { int a[10],b[10],c[20],i,ia,ib,ic;
        printf(\"please input the first array:\\n\");
        for(i=0;i<10;i++)
        scanf(\"%d\",&a[i]);
        for(i=0;i<10;i++)
        scanf(\"%d\",&b[i]);
        printf(\"\\n\");
        ia=0;ib=0;ic=0;
        while(ia<10&&ib<10)
        { if(a[ia]<b[ib])
        { c[ic]=a[ia];ia++;}
        else
        { c[ic]=b[ib];ib++;}
        ic++;
        }
        while(ia<=9)
        { c[ic]=a[ia];
        ia++;ic++;
        }
        while(ib<=9) [Page]
        { c[ic]=b[ib];
        b++;ic++;
        }
        for(i=0;i<20;i++)
        printf(\"%d\\n\",c[i]);
        }
        六、查找问题
        1.①顺序查找法(在一列数中查找某数x)
        基本思想:一列数放在数组a[1]---a[n]中,待查找的数放在x 中,把x与a数组中的元素从头到尾一一进行比较查找嵌入式培训,LINUX培训,C培训,Wince培训,Android培训用变量p表示a数组元素下标,p初值为1,使x与a[p]比较,如果x不等于a[p],则使p=p+1,不断重复这个过程;一旦x等于a[p]则退出循环;另外,如果p大于数组长度,循环也应该停止嵌入式培训,LINUX培训,C培训,Wince培训,Android培训(这个过程可由下语句实现)
        void main()
        { int a[10],p,x,i;
        printf(\"please input the array:\\n\");
        for(i=0;i<10;i++)
        scanf(\"%d\",&a[i]);
        printf(\"please input the number you want find:\\n\");
        scanf(\"%d\",&x);
        printf(\"\\n\");
        p=0;
        while(x!=a[p]&&p<10)
        p++;
        if(p>=10)
        printf(\"the number is not found!\\n\");
        else
        printf(\"the number is found the no%d!\\n\",p);
        }
        思考:将上面程序改写一查找函数Find,若找到则返回下标值,找不到返回-1
        ②基本思想:一列数放在数组a[1]---a[n]中,待查找的关键值为key,把key与a数组中的元素从头到尾一一进行比较查找,若相同,查找成功,若找不到,则查找失败嵌入式培训,LINUX培训,C培训,Wince培训,Android培训(查找子过程如下嵌入式培训,LINUX培训,C培训,Wince培训,Android培训index:存放找到元素的下标嵌入式培训,LINUX培训,C培训,Wince培训,Android培训)
        void main()
        { int a[10],index,x,i;
        printf(\"please input the array:\\n\");
        for(i=0;i<10;i++)
        scanf(\"%d\",&a[i]);
        printf(\"please input the number you want find:\\n\");
        scanf(\"%d\",&x);
        printf(\"\\n\");
        index=-1;
        for(i=0;i<10;i++)
        if(x==a[i])
        { index=i; break;
        }
        if(index==-1)
        printf(\"the number is not found!\\n\");
        else
        printf(\"the number is found the no%d!\\n\",index);
        }
        2.折半查找法(只能对有序数列进行查找)
        基本思想:设n个有序数(从小到大)存放在数组a[1]----a[n]中,要查找的数为x嵌入式培训,LINUX培训,C培训,Wince培训,Android培训用变量bot、top、mid 分别表示查找数据范围的底部(数组下界)、顶部(数组的上界)和中间,mid=(top+bot)/2,折半查找的算法如下:
        (1)x=a(mid),则已找到退出循环,否则进行下面的判断;
        (2)x<a(mid),x必定落在bot和mid-1的范围之内,即top=mid-1;
        (3)x>a(mid),x必定落在mid+1和top的范围之内,即bot=mid+1;
        (4)在确定了新的查找范围后,重复进行以上比较,直到找到或者bot<=top嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        将上面的算法写成如下程序:
        void main()
        {
        int a[10],mid,bot,top,x,i,find;
        printf(\"please input the array:\\n\");
        for(i=0;i<10;i++)
        scanf(\"%d\",&a[i]);
        printf(\"please input the number you want find:\\n\");
        scanf(\"%d\",&x);
        printf(\"\\n\");
        bot=0;top=9;find=0;
        while(bot<top&&find==0)
        { mid=(top+bot)/2; [Page]
        if(x==a[mid])
        {find=1;break;}
        else if(x<a[mid])
        top=mid-1;
        else
        bot=mid+1;
        }
        if (find==1)
        printf(\"the number is found the no%d!\\n\",mid);
        else
        printf(\"the number is not found!\\n\");
        }
        七、插入法
        把一个数插到有序数列中,插入后数列仍然有序
        基本思想:n个有序数(从小到大)存放在数组a(1)—a(n)中,要插入的数x嵌入式培训,LINUX培训,C培训,Wince培训,Android培训首先确定x插在数组中的位置P;(可由以下语句实现)
        #define N 10
        void insert(int a[],int x)
        { int p, i;
        p=0;
        while(x>a[p]&&p<N)
        p++;
        for(i=N; i>p; i--)
        a[i]=a[i-1];
        a[p]=x;
        }
        main()
        { int a[N+1]={1,3,4,7,8,11,13,18,56,78}, x, i;
        for(i=0; i<N; i++) printf(\"%d,\", a[i]);
        printf(\"\\nInput x:\");
        scanf(\"%d\", &x);
        insert(a, x);
        for(i=0; i<=N; i++) printf(\"%d,\", a[i]);
        printf(\"\\n\");
        }
        八、矩阵(二维数组)运算
        (1)矩阵的加、减运算
        C(i,j)=a(i,j)+b(i,j) 加法
        C(i,j)=a(i,j)-b(i,j) 减法
        (2)矩阵相乘
        (矩阵A有M*L个元素,矩阵B有L*N个元素,则矩阵C=A*B有M*N个元素)嵌入式培训,LINUX培训,C培训,Wince培训,Android培训矩阵C中任一元素 (i=1,2,…,m; j=1,2,…,n)
        #define M 2
        #define L 4
        #define N 3

    void mv(int a[M][L], int b[L][N], int c[M][N])
        { int i, j, k;
        for(i=0; i<M; i++)
        for(j=0; j<N; j++)
        { c[i][j]=0;
        for(k=0; k<L; k++)
        c[i][j]+=a[i][k]*b[k][j];
        }
        }
        main()
        { int a[M][L]={{1,2,3,4},{1,1,1,1}};
        int b[L][N]={{1,1,1},{1,2,1},{2,2,1},{2,3,1}}, c[M][N];
        int i, j;
        mv(a,b,c);
        for(i=0; i<M; i++)
        { for(j=0; j<N; j++)
        printf(\"%4d\", c[i][j]);
        printf(\"\\n\");
        }
        }
        (3)矩阵传置
        例:有二维数组a(5,5),要对它实现转置,可用下面两种方式:
        #define N 3
        void ch1(int a[N][N])
        { int i, j, t;
        for(i=0; i<N; i++)
        for(j=i+1; j<N; j++)
        { t=a[i][j];
        a[i][j]=a[j][i];
        a[j][i]=t;
        }
        }
        void ch2(int a[N][N])
        { int i, j, t;
        for(i=1; i<N; i++)
        for(j= 0; j<i; j++)
        { t=a[i][j];
        a[i][j]=a[j][i];
        a[j][i]=t;
        }
        }
        main()
        { int a[N][N]={{1,2,3},{4,5,6},{7,8,9}}, i, j;
        ch1(a); /*或ch2(a);*/
        for(i=0; i<N; i++)
        { for(j=0; j<N; j++)
        printf(\"%4d\", a[i][j]);
        printf(\"\\n\");
        }
        }
        (4)求二维数组中最小元素及其所在的行和列
        基本思路同一维数组,可用下面程序段实现(以二维数组a[3][4]为例): [Page]
        ‘变量max中存放最大值,row,column存放最大值所在行列号
        #define N 4
        #define M 3
        void min(int a[M][N])
        { int min, row, column, i, j;
        min=a[0][0];
        row=0;
        column=0;
        for(i=0; i<M; i++)
        for(j=0; j<N; j++)
        if(a[i][j]<min)
        { min=a[i][j];
        row=i;
        column=j;
        }
        printf(\"Min=%d\\nAt Row%d,Column%d\\n\", min, row, column);
        }
        main()
        { int a[M][N]={{1,23,45,-5},{5,6,-7,6},{0,33,8,15}};
        min(a);
        }
        九、迭代法
        算法思想:对于一个问题的求解x,可由给定的一个初值x0,根据某一迭代公式得到一个新的值x1,这个新值x1比初值x0更接近要求的值x;再以新值作为初值,即:x1→x0,重新按原来的方法求x1,重复这一过和直到|x1-x0|<ε(某一给定的精度)嵌入式培训,LINUX培训,C培训,Wince培训,Android培训此时可将x1作为问题的解嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        例:用迭代法求某个数的平方根嵌入式培训,LINUX培训,C培训,Wince培训,Android培训 已知求平方根的迭代公式为:
        #include<math.h>
        float fsqrt(float a)
        { float x0, x1;
        x1=a/2;
        do{
        x0=x1;
        x1=0.5*(x0+a/x0);
        }while(fabs(x1-x0)>0.00001);
        return(x1);
        }
        main()
        { float a;
        scanf(\"%f\", &a);
        printf(\"genhao =%f\\n\", fsqrt(a));
        }
        十、数制转换
        将一个十进制整数m转换成 →r(2-16)进制字符串嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        方法:将m不断除 r 取余数,直到商为零,以反序得到结果嵌入式培训,LINUX培训,C培训,Wince培训,Android培训下面写出一转换函数,参数idec为十进制数,ibase为要转换成数的基(如二进制的基是2,八进制的基是8等),函数输出结果是字符串嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        char *trdec(int idec, int ibase)
        { char strdr[20], t;
        int i, idr, p=0;
        while(idec!=0)
        { idr=idec % ibase;
        if(idr>=10)
        strdr[p++]=idr-10+65;
        else
        strdr[p++]=idr+48;
        idec/=ibase;
        }
        for(i=0; i<p/2; i++)
        { t=strdr[i];
        strdr[i]=strdr[p-i-1];
        strdr[p-i-1]=t;
        }
        strdr[p]=’\\0’;
        return(strdr);
        }
        main()
        { int x, d;
        scanf(\"%d%d\", &x, &d);
        printf(\"%s\\n\", trdec(x,d));
        }
        十一、字符串的一般处理
        1.简单加密和解密
        加密的思想是: 将每个字母C加(或减)一序数K,即用它后的第K个字母代替,变换式公式: c=c+k
        例如序数k为5,这时 A→ F, a→f,B→?G… 当加序数后的字母超过Z或z则 c=c+k -26
        例如:You are good→ Dtz fwj ltti
        解密为加密的逆过程
        将每个字母C减(或加)一序数K,即 c=c-k,
        例如序数k为5,这时 Z→U,z→u,Y→T… 当加序数后的字母小于A或a则 c=c-k +26
        下段程序是加密处理:
        #include<stdio.h>
        char *jiami(char stri[])
        { int i=0;
        char strp[50],ia;
        while(stri[i]!=’\\0’)
        { if(stri[i]>=’A’&&stri[i]<=’Z’) [Page]
        { ia=stri[i]+5;
        if (ia>’Z’) ia-=26;
        }
        else if(stri[i]>=’a’&&stri[i]<=’z’)
        { ia=stri[i]+5;
        if (ia>’z’) ia-=26;
        }
        else ia=stri[i];
        strp[i++]=ia;
        }
        strp[i]=’\\0’;
        return(strp);
        }
        main()
        { char s[50];
        gets(s);
        printf(\"%s\\n\", jiami(s));
        }
        2.统计文本单词的个数
        输入一行字符,统计其中有多少个单词,单词之间用格分隔开嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        算法思路:
        (1)从文本(字符串)的左边开始,取出一个字符;设逻辑量word表示所取字符是否是单词内的字符,初值设为0
        (2)若所取字符不是“空格”,“逗号”,“分号”或“感叹号”等单词的分隔符,再判断word是否为1,若word不为1则表是新单词的开始,让单词数num = num +1,让word =1;

     

        (3)若所取字符是“空格”,“逗号”,“分号”或“感叹号”等单词的分隔符, 则表示字符不是单词内字符,让word=0;
        (4) 再依次取下一个字符,重得(2)(3)直到文本结束嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        下面程序段是字符串string中包含的单词数
        #include \"stdio.h\"
        main()
        {char c,string[80];
        int i,num=0,word=0;
        gets(string);
        for(i=0;(c=string[i])!=’\\0’;i++)
        if(c==’ ’) word=0;
        else if(word==0)
        { word=1;
        num++;}
        printf(\"There are %d word in the line.\\n\",num);
        }
        十二、穷举法
        穷举法(又称“枚举法”)的基本思想是:一一列举各种可能的情况,并判断哪一种可能是符合要求的解,这是一种“在没有其它办法的情况的方法”,是一种最“笨”的方法,然而对一些无法用解析法求解的问题往往能奏效,通常采用循环来处理穷举问题嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        例: 将一张面值为100元的人民币等值换成100张5元、1元和0.5元的零钞,要求每种零钞不少于1张,问有哪几种组合?
        main()
        { int i, j, k;
        printf(\" 5元 1元 5角\\n\");
        for(i=1; i<=20; i++)
        for(j=1; j<=100-i; j++)
        { k=100-i-j;
        if(5*i+1*j+0.5*k==100)
        printf(\" %3d %3d %3d\\n\", i, j, k);
        }
        }
        十三、递归算法
        用自身的结构来描述自身,称递归
        VB允许在一个Sub子过程和Function过程的定义内部调用自己,即递归Sub子过程和递归Function函数嵌入式培训,LINUX培训,C培训,Wince培训,Android培训递归处理一般用栈来实现,每调用一次自身,把当前参数压栈,直到递归结束条件;然后从栈中弹出当前参数,直到栈空嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        递归条件:(1)递归结束条件及结束时的值;(2)能用递归形式表示,且递归向终止条件发展嵌入式培训,LINUX培训,C培训,Wince培训,Android培训
        例:编fac(n)=n! 的递归函数
        int fac(int n)
        { if(n==1)
        return(1);
        else
        return(n*fac(n-1));
        }
        main()
        { int n;
        scanf(\"%d\", &n);
        printf(\"n!=%d\\n\", fac(n));
        }
    展开全文
  • 主要介绍了C语言实现的搜索算法,结合具体实例形式分析了C语言实现的定义及搜索相关操作技巧,需要的朋友可以参考下
  • C语言 算法与数据结构 的邻接矩阵 邻接链表 深度 广度 遍历 实验要求: 1.实现无向邻接矩阵的创建;设计算法输无向邻接矩阵, 并利用邻接矩阵作为存储结构实现无向的深度优先遍历; 2.实现无向邻接表的...

    C语言 算法与数据结构 图的邻接矩阵 邻接链表 深度 广度 遍历

    实验要求:

    1.实现无向图邻接矩阵的创建;设计算法输无向图邻接矩阵, 并利用邻接矩阵作为存储结构实现无向图的深度优先遍历;
    2.实现无向图邻接表的创建;设计算法输无向图邻接表,并利用邻接表作为存储结构实现无向图的广度优先遍历;

    #include <stdio.h>
    #include <conio.h>
    #include <stdlib.h>
    #include <Windows.h>
    #include <time.h>
    #include <math.h>
    #define TRUE 1
    #define FALSE 0
    #define MAXVER 100
    /*
    Item:
    1.实现无向图邻接矩阵的创建;设计算法输无向图邻接矩阵, 并利用邻接矩阵作为存储结构实现无向图的深度优先遍历;
    2.实现无向图邻接表的创建;设计算法输无向图邻接表,并利用邻接表作为存储结构实现无向图的广度优先遍历;
    */
    
    /*Data design*/
    /*1*/
    typedef int vertype;
    typedef struct
    {
        vertype vex[MAXVER];
        int adjmatrix[MAXVER][MAXVER];
        int n,e;
    } MapGraph;
    /*2*/
    typedef struct vernode
    {
        int adjvex;
        struct vernode * next;
    } nodetype;
    typedef struct
    {
        vertype data;
        nodetype * fnext;
    } headnode;
    typedef struct
    {
        headnode maplist[MAXVER];
        int len;
    } adjlist;
    
    
    /*Function define*/
    char Meau();    /*获得选择*/
    void Help();    /*查看说明*/
    void ChangeEndFlage();  /*修改结束标志符*/
    /*1*/
    void BuildGraph(MapGraph * map);    /*建立邻接矩阵*/
    void DeepTravers(MapGraph * map);   /*借鉴教材函数实现,深度遍历函数顶点部分*/
    void DeepTreversNext(MapGraph * map,int node);  /*深度遍历函数剩下尾部部分*/
    int visit[MAXVER]= {0}; /*记录邻接矩阵深度遍历的数组*/
    /*2*/
    void BuildGraList(adjlist * adjlistmap);    /*建立邻接表*/
    void BroadTravers(adjlist * adjlistmap);    /*广度遍历邻接表*/
    
    int endflag=-999;
    int main()
    {
        system("color f5");
        system("title PhotoMap Dev Ice2Faith");
        ChangeEndFlage();
        char sel;
        do
        {
            sel=Meau();
            system("cls");
            switch(sel)
            {
            case '1':
            {
                MapGraph * map=(MapGraph *)malloc(sizeof(MapGraph));
                BuildGraph(map);
                printf("深度遍历结果:\n>/ ");
                DeepTravers(map);
                break;
            }
            case '2':
            {
                adjlist * adjlistmap=(adjlist *)malloc(sizeof(adjlist));
                BuildGraList(adjlistmap);
                printf("广度遍历结果:\n>/ ");
                BroadTravers(adjlistmap);
                break;
            }
            case '3':
            {
                Help();
                break;
            }
            case '0':
            {
                printf("正在退出程序,请稍候. . . \n\n");
                Sleep(800);
                break;
            }
            }
            if(sel!='0')
            {
                printf("\n\n");
                system("pause");
            }
    
        }
        while(sel!='0');
    
        return 0;
    }
    
    char Meau()
    {
        system("cls");
        char sel='+';
        printf("----------------------------\n\n");
        printf("\t1.邻接矩阵\n\n");
        printf("\t2.邻接表\n\n");
        printf("\t3.帮助&说明\n\n");
        printf("\t0.退出程序\n\n");
        printf("----------------------------\n\n");
        printf(">/ ");
        do
        {
            sel=getch();
        }
        while(sel<'0'||sel>'3');
        printf("%c\n",sel);
        return sel;
    }
    void Help()
    {
        printf("--------------------------------------------------------\n\n");
        printf("\t1.设计的图均是无向图,切均是面向整数(int)进行操作\n\n");
        printf("\t2.输入顶点之间的关系时本程序不负责检验是否合法\n\n");
        printf("\t3.部分函数借鉴书本参考\n\n");
        printf("\t4.请注意输入格式要求,默认结束标记 \"-999\" && \"-999+-999\"\n\n");
        printf("\t5.结束标记可支持修改\n\n");
        printf("\t6.Dev: Ice2Faith\n\n");
        printf("--------------------------------------------------------\n\n");
    
    }
    void ChangeEndFlage()
    {
        system("cls");
        printf("您即将会输入使用的结束标志为:\"%d\"  && \"%d+%d\"\n",endflag,endflag,endflag);
        printf("需要修改请输入 1 \n>/ ");
        if(getch()=='1')
        {
            printf("请输入结束标记(int):\n>/ ");
            scanf("%d",&endflag);
            printf("结束标记符已修改为:\"%d\"  && \"%d+%d\"\n\n",endflag,endflag,endflag);
            system("pause");
        }
    }
    void BuildGraph(MapGraph * map)
    {
        for(int m=0; m<MAXVER; m++)
            for(int n=0; n<MAXVER; n++) /*清空邻接矩阵*/
                map->adjmatrix[m][n]=0;
        printf("请输入所有元素,以%d结束:\n",endflag);
        int i=0;
        int tempnum;
        do
        {
            scanf("%d",&tempnum);
            if(tempnum!=endflag)
                map->vex[i++]=tempnum;
            else
                break;
        }
        while(tempnum!=endflag);   /*读入元素*/
        map->n=i;   /*记录元素个数*/
    
        printf("请输入他们的关系,以%d+%d结束:例如11+12\n",endflag,endflag);
        int line,col;
        int j;
        int e=0;
        do
        {
            scanf("%d+%d",&line,&col);
            if(line==endflag&&col==endflag)
                break;
            for(i=0; i<map->n; i++)
            {
                if(map->vex[i]==line)
                    break;
            }
            for(j=0; j<map->n; j++)
            {
                if(map->vex[j]==col)
                    break;
            }
            map->adjmatrix[i][j]=1;
            map->adjmatrix[j][i]=1;
            e++;
        }
        while(line!=endflag&&col!=endflag);   /*读写关系到矩阵*/
        map->e=e;   /*记录边数*/
    }
    
    void DeepTravers(MapGraph * map)
    {
        for(int j=0; j<MAXVER; j++) /*清空访问数组*/
            visit[j]=0;
        for(int i=0; i<map->n; i++) /*扫描每个元素*/
        {
            if(!visit[i])   /*若元素未被访问,则访问与它临街的第一个元素*/
            {
                DeepTreversNext(map,i);
            }
        }
    
    }
    void DeepTreversNext(MapGraph * map,int node)
    {
        printf("->%d",map->vex[node]);  /*输出当前未访问并记录已访问*/
        visit[node]=1;
        for(int i=0; i<map->n; i++) /*查找对应矩阵行,找到第一个未访问进行访问,递归调用*/
        {
            if(!visit[i]&&map->adjmatrix[node][i])
            {
                DeepTreversNext(map,i);
            }
        }
    }
    
    void BuildGraList(adjlist * adjlistmap)
    {
        printf("请输入顶点,以%d结束:\n",endflag);
        int tempnum;
        int i=0;
        do
        {
            scanf("%d",&tempnum);
            if(tempnum==endflag)
                break;
            adjlistmap->maplist[i].data=tempnum; /*顶点赋值并初始化第一个指针域*/
            adjlistmap->maplist[i].fnext=NULL;
            adjlistmap->len++;
            i++;
        }
        while(tempnum!=endflag);   /*获得顶点*/
        printf("顶点间的关系,例如3+5:以%d+%d结束:\n",endflag,endflag);
        int tempnum2;
        int j;
        nodetype * exnode=NULL;
        do
        {
            scanf("%d+%d",&tempnum,&tempnum2);
            if(tempnum2==endflag&&tempnum==endflag)
                break;
            nodetype * node=(nodetype *)malloc(sizeof(nodetype));
            node->next=NULL;
            nodetype * node1=(nodetype *)malloc(sizeof(nodetype));  /*创建两个节点*/
            node1->next=NULL;
            i=0;
            while(adjlistmap->maplist[i].data!=tempnum && i<adjlistmap->len)
            {
                i++;
            }
            j=0;
            while(adjlistmap->maplist[j].data!=tempnum2 && j<adjlistmap->len)   /*获得输入顶点之间关系对应的数组的下标*/
            {
                j++;
            }
    
            exnode=adjlistmap->maplist[i].fnext;
            adjlistmap->maplist[i].fnext=node;
            node->next=exnode;
            node->adjvex=j; /*对无向图一遍进行操作*/
    
            exnode=adjlistmap->maplist[j].fnext;
            adjlistmap->maplist[j].fnext=node1;
            node1->next=exnode;
            node1->adjvex=i;    /*另一边进行操作*/
    
    
        }
        while(tempnum2!=endflag&&tempnum!=endflag);   /*读入边之间的关系*/
    
    }
    
    void BroadTravers(adjlist * adjlistmap)
    {
        int visit[MAXVER]= {0};
        for(int i=0; i<=adjlistmap->len; i++) /*初始化访问数组*/
            visit[i]=0;
    
        nodetype * tempnode=NULL;
        for(int i=0; i<adjlistmap->len; i++) /*遍历每个顶点*/
        {
            if(!visit[i])
            {
                printf("->%d",adjlistmap->maplist[i].data); /*对头指针进行遍历操作*/
                visit[i]=1;
            }
            tempnode=adjlistmap->maplist[i].fnext;
            while(tempnode) /*对此头指针之后的关系进行遍历*/
            {
                if(!visit[tempnode->adjvex])
                {
                    printf("->%d",adjlistmap->maplist[tempnode->adjvex].data);
                    visit[tempnode->adjvex]=1;
                }
    
                tempnode=tempnode->next;
            }
        }
    }
    
    
    展开全文
  • c语言函数和算法图文.pptx
  • c语言算法(内容很多)

    2012-11-12 00:52:57
    c语言算法 内容很多 包括 数字处理 图形输出 数据处理 等
  • c语言算法实现功能![图片](https://img-ask.csdn.net/upload/201611/13/1479036546_389932.jpg)
  • 离散模型图论相关C语言的矩阵表示及习题
  • C 2. 下列输入是否合法. 语 main ( 言 { 程 int a , b , c , d , e , f ; 序 scanf ( %d %d , &a , &b ; 设 scanf ( %d %d , &c , &d ; 计 scanf ( %d , &e ; scanf ( %d , &f ; 第 } 三 章 输入: 1?...
  • C语言学习路线:(阶段二) C语言常用算法分析 带有详细标签,高清PDF
  • 题目来源:王晓东《算法设计与分析》 假设要在足够多的会场里安排一批活动,并希望使用尽可能少的会场。设计一个有效的 贪心算法进行安排。(这个问题实际上是著名的着色问题。若将每一个活动作为的一个 顶点,...
  • 图算法 C语言描述

    2018-09-01 21:28:11
    图算法 C语言描述
  • 1.6.分治算法.wmv 1.5.递归算法.wmv 1.4.枚举(穷举)算法.wmv 3.2.网状关系:(2).wmv 3.2.网状关系:(1).wmv 3.1.层次关系结构:树(3).wmv 3.1.层次关系结构:树(2).wmv 3.1.层次关系结构:树(1).wmv 2.3.后进先...
  • 用c实现是算法程序 不说非常完美 但也还是很好的我可花了不少时间的
  • 第二章-C语言算法.pptx

    2020-06-28 01:09:56
    第2章 程序的灵魂算法;2.1 算法的概念;2.2 简单算法举例;例2.2 对一个大于或等于3的正整数判断它是不是一个素数;2.3 算法的特性;2.4 算法的表示方法;2.4.1自然语言表示;2.4.2流程表示; 2.4 2.5; 三种基本...
  • 通常使用自然语言、结构化流程、伪代码等来描述算法。一、计数、求和、求阶乘等简单算法此类问题都要使用循环,要注意根据问题确定循环变量的初值、终值或结束条件,更要注意用来表示计数、和、阶乘的变量的初值。...
  • 主要为大家详细介绍了C语言实现的最短路径Floyd算法,具有一定的参考价值,感兴趣的小伙伴们可以参考一下
  • C语言算法集——不少高手正在找的 插值算法 常用滤波算法 非线性方程组 复数运算 极值问题 图形模式下读写屏幕 等等
  • Problem Description Miceren finds a huge country named HY. HY has N cities numbered from 1 to N connected by N − 1 bidirectional roads. There exists a path between any two cities....
  • C语言实现的相关算法

    千次阅读 2019-03-08 20:52:03
    该程序主要是用C语言来实现与相关的算法,目的在于加深对于这种数据结构的理解以及探索其应用场景。 程序中涉及的有向如下: /*-------------------------------------------- 功能:关于的存储及操作...
  • c语言算法求大神这个错误怎么改?,怎么改,怎么改。。。。怎么改。。。![图片说明](https://img-ask.csdn.net/upload/201610/30/1477815155_751816.png)
  • 利用c语言实现寻找二分最大匹配算法。给定一个二分和二分中的任一匹配,通过最大匹配算法,确定该匹配是否是最大匹配并输出最大匹配的边集。最大匹配:M是一个二分边集的子集,当M中任意两个边在顶点处不...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,024
精华内容 1,609
关键字:

c语言算法图

c语言 订阅