图c语言实现

‘壹’ c语言怎样实现图中的功能，按任意键到第二张图

在主函数中先调用函数绘制第一个界面，然后在该函数后面加上getch();语句，再在getch()语句后调用绘制第二个界面的函数即可。实现的原理是：getch()语句将屏幕停留在当前的视图，并等待用户按键，一旦按键之后，系统就会执行getch()语句之后的一条语句，此时，系统会执行第二个绘制界面的函数，即可完成所需功能

‘贰’ 如何利用c语言实现像素图形的输出

1、可以变成灰度图也可以不变。这里假设你的图像都是IPL_DEPTH_8U类型。

2、如果变成灰度图，就是单通道图像，获取的就是每一个像素点的灰度值。
IplImage* img = cvLoadImage("test.bmp", 0);
for (int i = 0; i < img->height; i++)
{
for (int j = 0; j < img->width; j++)
{
//方法一：使用cvGet2D()函数间接访问
CvScalar s = cvGet2D(img, i, j); //其中i代表y轴（第i行），即height；j代表x轴（第j列），即width。
printf("gray value=%f\n",s.val[0]);

//方法二：使用直接访问
uchar val = ((uchar *)(img->imageData + i*img->widthStep))[j]; //i和j的意义同上
printf("gray value=%d\n",val);
}
}

3、如果不变成灰度图，就是3通道图像，获取的就是每一个像素点的BGR值，然后分别获取B值，G值和R值。
IplImage* img = cvLoadImage("test.bmp", 1);
for (int i = 0; i < img->height; i++)
{
for (int j = 0; j < img->width; j++)
{
//方法一：使用cvGet2D()函数间接访问
CvScalar s=cvGet2D(img,i,j); //其中i代表y轴（第i行），即height；j代表x轴（第j列），即width。
printf("B=%f, G=%f, R=%f\n",s.val[0],s.val[1],s.val[2]); //注意是BGR顺序

//方法二：使用直接访问
int bVal = ((uchar *)(img->imageData + i*img->widthStep))[j*img->nChannels + 0]; // B
int gVal = ((uchar *)(img->imageData + i*img->widthStep))[j*img->nChannels + 1]; // G
int rVal = ((uchar *)(img->imageData + i*img->widthStep))[j*img->nChannels + 2]; // R
printf("B=%d, G=%d, R=%d\n",bVal,gVal,rVal); //注意是BGR顺序
}
}

‘叁’ 如何利用C语言实现动画

基于擦除法的C语言动画设计与实现

Movie design implement in C language base on erasure way

东华理工学院计算机与通信系姜林何月顺江西南昌330013

摘要：

本文介绍了程序设计语言中动画设计的原理，在C语言中的动画设计常用方法，并提出了在C语言中新的动画设计方法――擦除法。阐述擦除法动画设计的原理，并通过一个具体的实例详细介绍了这种方法的设计实现，文中末尾总结了擦除法动画设计的优点及适用的范围。

关键字：擦除法；C语言；TurboC2.0；动画设计；原理；实现

中图分类号：TP312

Summary:

Through the principium of movie design in program design language, the thesis present movie design general way in C language, and bring forward new movie design way――erasure . The thesis also expatiate the principium of erasure way, particular describe the design implement of erasure by a instance. The end summarize the excellence and range of erasure way.

Key words: erasure way; C language ; TurboC 2.0; movie design; principium; implement

0． 引言

动画技术是计算机图形学中的重要内容，它广泛用于游戏娱乐，辅助教学，科学实验模拟等计算机辅助设计。用于动画设计的程序设计语言有多种，并且有多种方法。其中C语言程序设计又广泛用于各种软件开发项目中。因此，掌握C语言的动画设计方法对于软件开发很有必要。

1． 程序设计中动画原理

程序设计中动画设计的原理类似电影的方法，它利用人的视觉具有暂留的生理特点，即人眼对动态图像的变化仅能分辨出时间间隔为25毫秒左右的变化，如果图像变化太快，则人眼无法分辨。在程序设计中我们可以在屏幕上画出一张图像，而将这张图像在不同时间出现，然后一张张快速（时间间隔小于25毫秒）呈现在屏幕上，从视觉效果上看这些画面就如同电影在连续变化一样，给人以动的视觉感觉。

2． C语言动画设计常用方法C语言常用动画设计方法[1]：

2.1利用动态开辟图视口方法

在位置动态变化，但大小不变的图视口中（用setviewpot()函数[2]），设置固定图形，这样呈现在观察者面前的是当前图视口位置在动态变化，因而在屏上看到的图像就好像在动态变化一样。

2.2 利用显示页和编辑页交替变化

将当前显示页和编辑页分开（用setvisualpage()和setactivepage()函数），在编辑页上

画好图形后，立即令该页变为显示页，然后在上次显示页上进行画图，画好后，再交换，如此反复，在观察者的视觉上，就出现了动画的效果。

2.3 利用画面存储再重放的方法

如同制作幻灯片一样，将整个动画过程变成一个个片断，然后存储到显示缓冲区内，当把它们按顺序重放到屏幕上时，就出现了动画效果。

2.4 直接对图像动态存储器进行操作

利用显示适配器上控制图像显示的各种寄存器和图像存储器VRAM，对其进行直接操作和控制，从而可以高效快速的实现动画效果。

上述4种方法均可以实现动画效果，但其操作比较复杂，且在程序中要对图像不断进行存取操作，这需要耗费大量内存资源。下面的擦除法动画设计可以解决上述问题。

3． 擦除法动画设计原理

擦除法动画设计方法在很多的动画制作工具（如flash）中大量使用，但在程序设计中却鲜有人用。它的设计原理是：利用同色原理，当图形色与背景色相同时人眼不能感知。在动画设计中，当在一个位置画了一张图像时，使图像色与背景色相异，然后再到另一个位置画一张图像并使图像色与背景色也相异，此时将先前画的图像在原位置再画一张，并使图像色与背景色相同，这样人眼只能看到新画的一张图像而看不到先前画的图像，从而先前画的图像感觉被擦除了。这样连续画多张图像并在每画一张新的图像，将原来的图像擦除，从而在观察者来看就实现了动画的效果。

4． 擦除法的动画设计实现

下面以一个上下翻滚的圆作为一个例子来讲解在TurboC2.0开发环境下用C语言来实现动画的设计过程，其中动画设计的方法是擦除法。具体的实现步骤如下：

4.1 TC的图形系统的初始化

TurboC2.0为用户提供了一个功能强大的画图软件库，它包括图形库文件（graphics.lib），图形头文件（graphics.h）和许多图形显示器的驱动程序。在TurboC2.0开始进行图形设计前必须对之进行初始化，使系统知道要用什么类型的图形显示器的驱动程序，采用什么模式的图形方式，以及该适配器驱动程序的寻找路径名。这个初始化的函数是initgraph()。在本程序中的初始化如下：
gdriver=DETECT;
initgraph(&gdriver, &gmode, "");//图形显示器、显示模式、路径自动检测

4.2 画图
setcolor(LIGHTRED);//设置圆的线条颜色为淡红色

setlinestyle(0,0,1);//设置线条为形状为实线，线宽为一点宽
setfillstyle(1, 10);//设置圆的填充式样为以实填充，填充色为淡绿色
circle(300, 10+10*y,15);//画一个圆心在坐标（300，10＋10y），半径为15的圆
这个地方我们需要画一个圆（用draw()函数实现），并且设置圆的圆周线条的颜色（用setcolor()函数），设置线条类型（用setlinestyle()函数），设置圆的填充色和填充模式（用setfillstyle()函数），设置圆的填充色（用floodfill()），最后是画圆（用circle()函数）。在本程序（draw()函数）中的代码如下：
floodfill(300, 10+10*y, 12);//给圆填充如上stfillstyle中的淡绿色

为了实现擦除操作需在同一个位置再画一个圆（用clear()函数实现），该操作只需将上面的画圆函数（draw()函数）改动两个设置即可，如下示：

setcolor(BLUE);//设置圆的线条颜色为蓝色（与背景色相同）
setfillstyle(1, 10);//设置圆的填充式样为以实填充，填充色为淡绿色

4.3 动画实现

本部分是核心部分，先设置背景色为蓝色（用setbkcolor()函数），再在屏幕上画一个填充色为淡绿色的圆（draw()函数）。设置一个循环控制语句实现在屏幕上不同的位置画圆，同时在每画一个圆后作一个时间的延迟（用delay()函数），再在延迟后实现擦除操作，即调用clear()函数。其流程图及代码如下：
setbkcolor(BLUE);//设置背景色为蓝色

for(j=20;j>0;j=j-4)//控制动画实现的次数为20次

{ for(i=j;i<30;i++)//实现动画从上向下闪烁

{ draw(i);//画圆

delay(100000);//延迟0.1秒

clear(i);//擦除已画的圆

}

for(i=30;i>j;i--)//实现动画从下向上闪烁

{ draw(i);//画圆

delay(100000);//延迟0.1秒

clear(i);//擦除已画的圆

}

}

动画实现后的最后效果图如下示。

4.4 关闭图形系统

当图形实现结束后需要关闭图形系统，利用函数closegraph()即可实现。

5． 总结

擦除法动画设计原理易于理解，便于操作。并且它的程序运行所需内存空间也比上述四种常用方法要少得多，因为它在程序执行过程中不需将图形存入内存再从内存调出，这节省了大量的内存空间。如果程序运行在内存紧张的环境中，如嵌入式系统中，这种方法尤其适用

‘肆’ C语言编写程序实现图的遍历操作

楼主你好，下面是源程序！

/*/////////////////////////////////////////////////////////////*/
/* 图的深度优先遍历 */
/*/////////////////////////////////////////////////////////////*/
#include <stdlib.h>
#include <stdio.h>
struct node /* 图顶点结构定义 */
{
int vertex; /* 顶点数据信息 */
struct node *nextnode; /* 指下一顶点的指标 */
};
typedef struct node *graph; /* 图形的结构新型态 */
struct node head[9]; /* 图形顶点数组 */
int visited[9]; /* 遍历标记数组 */

/********************根据已有的信息建立邻接表********************/
void creategraph(int node[20][2],int num)/*num指的是图的边数*/
{
graph newnode; /*指向新节点的指针定义*/
graph ptr;
int from; /* 边的起点 */
int to; /* 边的终点 */
int i;
for ( i = 0; i < num; i++ ) /* 读取边线信息，插入邻接表*/
{
from = node[i][0]; /* 边线的起点 */
to = node[i][1]; /* 边线的终点 */

/* 建立新顶点 */
newnode = ( graph ) malloc(sizeof(struct node));
newnode->vertex = to; /* 建立顶点内容 */
newnode->nextnode = NULL; /* 设定指标初值 */
ptr = &(head[from]); /* 顶点位置 */
while ( ptr->nextnode != NULL ) /* 遍历至链表尾 */
ptr = ptr->nextnode; /* 下一个顶点 */
ptr->nextnode = newnode; /* 插入节点 */
}
}

/********************** 图的深度优先搜寻法********************/
void dfs(int current)
{
graph ptr;
visited[current] = 1; /* 记录已遍历过 */
printf("vertex[%d]\n",current); /* 输出遍历顶点值 */
ptr = head[current].nextnode; /* 顶点位置 */
while ( ptr != NULL ) /* 遍历至链表尾 */
{
if ( visited[ptr->vertex] == 0 ) /* 如过没遍历过 */
dfs(ptr->vertex); /* 递回遍历呼叫 */
ptr = ptr->nextnode; /* 下一个顶点 */
}
}

/****************************** 主程序******************************/
void main()
{
graph ptr;
int node[20][2] = { {1, 2}, {2, 1}, /* 边线数组 */
{1, 3}, {3, 1},
{1, 4}, {4, 1},
{2, 5}, {5, 2},
{2, 6}, {6, 2},
{3, 7}, {7, 3},
{4, 7}, {4, 4},
{5, 8}, {8, 5},
{6, 7}, {7, 6},
{7, 8}, {8, 7} };
int i;
clrscr();
for ( i = 1; i <= 8; i++ ) /* 顶点数组初始化 */
{
head[i].vertex = i; /* 设定顶点值 */
head[i].nextnode = NULL; /* 指针为空 */
visited[i] = 0; /* 设定遍历初始标志 */
}
creategraph(node,20); /* 建立邻接表 */
printf("Content of the gragh's ADlist is:\n");
for ( i = 1; i <= 8; i++ )
{
printf("vertex%d ->",head[i].vertex); /* 顶点值 */
ptr = head[i].nextnode; /* 顶点位置 */
while ( ptr != NULL ) /* 遍历至链表尾 */
{
printf(" %d ",ptr->vertex); /* 印出顶点内容 */
ptr = ptr->nextnode; /* 下一个顶点 */
}
printf("\n"); /* 换行 */
}
printf("\nThe end of the dfs are:\n");
dfs(1); /* 打印输出遍历过程 */
printf("\n"); /* 换行 */
puts(" Press any key to quit...");
getch();
}


/*//////////////////////////////////////////*/
/* 图形的广度优先搜寻法 */
/* ///////////////////////////////////////*/
#include <stdlib.h>
#include <stdio.h>
#define MAXQUEUE 10 /* 队列的最大容量 */
struct node /* 图的顶点结构定义 */
{
int vertex;
struct node *nextnode;
};
typedef struct node *graph; /* 图的结构指针 */
struct node head[9]; /* 图的顶点数组 */
int visited[9]; /* 遍历标记数组 */
int queue[MAXQUEUE]; /* 定义序列数组 */
int front = -1; /* 序列前端 */
int rear = -1; /* 序列后端 */

/***********************二维数组向邻接表的转化****************************/
void creategraph(int node[20][2],int num)
{
graph newnode; /* 顶点指针 */
graph ptr;
int from; /* 边起点 */
int to; /* 边终点 */
int i;
for ( i = 0; i < num; i++ ) /* 第i条边的信息处理 */
{
from = node[i][0]; /* 边的起点 */
to = node[i][1]; /* 边的终点 */
/* 建立新顶点 */
newnode = ( graph ) malloc(sizeof(struct node));
newnode->vertex = to; /* 顶点内容 */
newnode->nextnode = NULL; /* 设定指针初值 */
ptr = &(head[from]); /* 顶点位置 */
while ( ptr->nextnode != NULL ) /* 遍历至链表尾 */
ptr = ptr->nextnode; /* 下一个顶点 */
ptr->nextnode = newnode; /* 插入第i个节点的链表尾部 */
}
}

/************************ 数值入队列************************************/
int enqueue(int value)
{
if ( rear >= MAXQUEUE ) /* 检查伫列是否全满 */
return -1; /* 无法存入 */
rear++; /* 后端指标往前移 */
queue[rear] = value; /* 存入伫列 */
}

/************************* 数值出队列*********************************/
int dequeue()
{
if ( front == rear ) /* 队列是否为空 */
return -1; /* 为空，无法取出 */
front++; /* 前端指标往前移 */
return queue[front]; /* 从队列中取出信息 */
}

/*********************** 图形的广度优先遍历************************/
void bfs(int current)
{
graph ptr;
/* 处理第一个顶点 */
enqueue(current); /* 将顶点存入队列 */
visited[current] = 1; /* 已遍历过记录标志置疑1*/
printf(" Vertex[%d]\n",current); /* 打印输出遍历顶点值 */
while ( front != rear ) /* 队列是否为空 */
{
current = dequeue(); /* 将顶点从队列列取出 */
ptr = head[current].nextnode; /* 顶点位置 */
while ( ptr != NULL ) /* 遍历至链表尾 */
{
if ( visited[ptr->vertex] == 0 ) /*顶点没有遍历过*/
{
enqueue(ptr->vertex); /* 奖定点放入队列 */
visited[ptr->vertex] = 1; /* 置遍历标记为1 */
printf(" Vertex[%d]\n",ptr->vertex);/* 印出遍历顶点值 */
}
ptr = ptr->nextnode; /* 下一个顶点 */
}
}
}

/*********************** 主程序 ************************************/
/*********************************************************************/
void main()
{
graph ptr;
int node[20][2] = { {1, 2}, {2, 1}, /* 边信息数组 */
{6, 3}, {3, 6},
{2, 4}, {4, 2},
{1, 5}, {5, 1},
{3, 7}, {7, 3},
{1, 7}, {7, 1},
{4, 8}, {8, 4},
{5, 8}, {8, 5},
{2, 8}, {8, 2},
{7, 8}, {8, 7} };
int i;
clrscr();
puts("This is an example of Width Preferred Traverse of Gragh.\n");
for ( i = 1; i <= 8; i++ ) /*顶点结构数组初始化*/
{
head[i].vertex = i;
head[i].nextnode = NULL;
visited[i] = 0;
}
creategraph(node,20); /* 图信息转换，邻接表的建立 */
printf("The content of the graph's allist is:\n");
for ( i = 1; i <= 8; i++ )
{
printf(" vertex%d =>",head[i].vertex); /* 顶点值 */
ptr = head[i].nextnode; /* 顶点位置 */
while ( ptr != NULL ) /* 遍历至链表尾 */
{
printf(" %d ",ptr->vertex); /* 打印输出顶点内容 */
ptr = ptr->nextnode; /* 下一个顶点 */
}
printf("\n"); /* 换行 */
}
printf("The contents of BFS are:\n");
bfs(1); /* 打印输出遍历过程 */
printf("\n"); /* 换行 */
puts(" Press any key to quit...");
getch();
}


‘伍’ C语言编程 图的创建与遍历

在C语言编程中，图的创建和遍历：

#include<stdio.h>

#define N 20

#define TRUE 1

#define FALSE 0

int visited[N];

typedef struct /*队列的定义*/

{

int data[N];

int front,rear;

}queue;

typedef struct /*图的邻接矩阵*/

{

int vexnum,arcnum;

char vexs[N];

int arcs[N][N];

}

graph;

void createGraph(graph *g); /*建立一个无向图的邻接矩阵*/

void dfs(int i,graph *g); /*从第i个顶点出发深度优先搜索*/

void tdfs(graph *g); /*深度优先搜索整个图*/

void bfs(int k,graph *g); /*从第k个顶点广度优先搜索*/

void tbfs(graph *g); /*广度优先搜索整个图*/

void init_visit(); /*初始化访问标识数组*/

void createGraph(graph *g) /*建立一个无向图的邻接矩阵*/

{ int i,j;

char v;

g->vexnum=0;

g->arcnum=0;

i=0;

printf("输入顶点序列(以#结束)：

");

while((v=getchar())!='#')

{

g->vexs[i]=v; /*读入顶点信息*/

i++;

}

g->vexnum=i; /*顶点数目*/

for(i=0;i<g->vexnum;i++) /*邻接矩阵初始化*/

for(j=0;j<g->vexnum;j++)

g->arcs[i][j]=0;

printf("输入边的信息：

");

scanf("%d,%d",&i,&j); /*读入边i,j*/

while(i!=-1) /*读入i,j为－1时结束*/

{

g->arcs[i][j]=1;

g->arcs[j][i]=1;

scanf("%d,%d",&i,&j);

}

}

void dfs(int i,graph *g) /*从第i个顶点出发深度优先搜索*/

{

int j;

printf("%c",g->vexs[i]);

visited[i]=TRUE;

for(j=0;j<g->vexnum;j++)

if((g->arcs[i][j]==1)&&(!visited[j]))

dfs(j,g);

}

void tdfs(graph *g) /*深度优先搜索整个图*/

{

int i;

printf("

从顶点%C开始深度优先搜索序列：",g->vexs[0]);

for(i=0;i<g->vexnum;i++)

if(visited[i]!=TRUE)

dfs(i,g);

}

void bfs(int k,graph *g) /*从第k个顶点广度优先搜索*/

{

int i,j;

queue qlist,*q;

q=&qlist;

q->rear=0;

q->front=0;

printf("%c",g->vexs[k]);

visited[k]=TRUE;

q->data[q->rear]=k;

q->rear=(q->rear+1)%N;

while(q->rear!=q->front)

{

i=q->data[q->front];

q->front=(q->front+1)%N;

for(j=0;j<g->vexnum;j++)

if((g->arcs[i][j]==1)&&(!visited[j]))

{

printf("%c",g->vexs[j]);

visited[j]=TRUE;

q->data[q->rear]=j;

q->rear=(q->rear+1)%N;

}

}

}

void tbfs(graph *g) /*广度优先搜索整个图*/

{

int i;

printf("

从顶点%C开始广度优先搜索序列：",g->vexs[0]);

for(i=0;i<g->vexnum;i++)

if(visited[i]!=TRUE)

bfs(i,g);

printf("

");

}

void init_visit() /*初始化访问标识数组*/

{

int i;

for(i=0;i<N;i++)

visited[i]=FALSE;

}

int main()

{

graph ga;

int i,j;

createGraph(&ga);

printf("无向图的邻接矩阵：

");

for(i=0;i<ga.vexnum;i++)

{

for(j=0;j<ga.vexnum;j++)

printf("%3d",ga.arcs[i][j]);

printf("

");

}

init_visit();

tdfs(&ga);

init_visit();

tbfs(&ga);

return 0;

}

‘陆’ C语言实现无向图

可以用邻接矩阵表示法：

#define max 100
typedef struct
{
int vex[max];//存储顶点值，类型可以变
int edge[max][max];//存储顶点之间的关系，以1或者0表示，1为有边，0为无
int e,v;//vertex存储顶点数，edge存储边的条数，所以无向图1的个数是边的个数的两倍，谢谢。
}m;

‘柒’ 如何用c语言读取图片

#include

using namespace std;

#define Twoto1(i,j,w) i*w+j

void createimage(unsigned char *&img, int w, int h)

{img = new unsigned char[w*h];}

void delateimage(unsigned char*img)

{delete []img;}

void readimage(unsigned char*img, int w, int h, char *fname)

{

FILE *fp;

fopen_s(&fp,fname, "rb");

if (fp == NULL){ cout << "error" << endl; return; }

size_t result;

result=fread(img , sizeof(unsigned char), w*h, fp);

if (result != w*h)

{

cout << "Reading error" << endl;

return;

}

else

cout << "Reading Ok!" << endl;

fclose(fp);

}

void mobanjuanji(unsigned char image, unsigned char*image1, int w, int h, float moban[5][5])

{

for (int i = 0; i for (int j = 0; j if (iw - 3 || j>h - 3)

image1[Twoto1(i,j,w)] = 0;

else

{

float temp = 0;

for (int m = 0; m<5; m++)

for (int n = 0; n<5; n++)

{

temp += (image[Twoto1(i-2+m,j-2+n,w)] moban[m][n]);

}

if (temp>255) image1[Twoto1(i, j, w)] = 255;

else if (temp<0) image1[Twoto1(i, j, w)] = 0;

else image1[Twoto1(i, j, w)] = temp;

}

}

void saveimage(unsigned char *img, int w, int h, char *fname)

{

FILE *fp;

fopen_s(&fp, fname, "wb");

if (fp == NULL) { cout << "error" << endl; return; }

size_t result;

result = fwrite(img, sizeof(unsigned char), w*h, fp);

if (result != w*h)

{

cout << "Write error" << endl;

return;

}

else

cout << "Write Ok!" << endl;

fclose(fp);

}

void main()

{

unsigned char *img;

unsigned char *img1;

float moban[5][5] = { {0,0,0,0,0},{0, -1, 0, 1, 0 }, { 0, -2, 0, 2, 0 }, { 0, -1, 0, 1, 0 }, { 0,0,0,0,0 } };

//float moban[5][5] = { 0 };

int w = 512, h = 512;

createimage(img, w, h);

createimage(img1, w, h);

readimage(img, w, h, "E:ss.raw");

mobanjuanji(img, img1,w, h, moban);

saveimage(img, w, h, "E:ss_1.raw");

saveimage(img1, w, h, "E:ss_2.raw");

delateimage(img);

delateimage(img1);

}

(7)图c语言实现扩展阅读

C语言实现一个图片的读出和写入

#include <stdlib.h>

#include <windows.h>

int file_size(char* filename)//获取文件名为filename的文件大小。

{

FILE *fp = fopen(filename, "rb");//打开文件。

int size;

if(fp == NULL) // 打开文件失败

return -1;

fseek(fp, 0, SEEK_END);//定位文件指针到文件尾。

size=ftell(fp);//获取文件指针偏移量，即文件大小。

fclose(fp);//关闭文件。

return size;

}

int main ()

{

int size=0;

size=file_size("qw");

printf("%d ",size);

FILE * pFile,*qw;

char *buffer=(char*)malloc(sizeof(char)*size);

qw =fopen("qw","r");

pFile = fopen ( "qwe" , "wb" );

printf("%d== ",pFile);

printf("%d ",size);

fread(buffer,1,size,qw);

fwrite (buffer , sizeof(byte), size , pFile );

fclose (pFile);

rename("qwe","Groot.jpg");

return 0;

}

‘捌’ 图 (c语言)

我来做，等等

/*编写无向图的邻接矩阵类AdjMWGraph,实现无向图的广度遍历和深度遍历。
其中，图中顶点数据类型为字符。Input第一行图中顶点的个数n(4<=n<=26)
第二行是图中边的条数m(3<=m<=351) 第三行是顶点信息(全为大写字母)
后面的输入数据是依附于一条边的两个顶点，有多少条边，就输入多少组信息。
注意：根结点都为A；并且所给字符连续，也就是说A B C D ……。
Output广度优先搜索序列。 深度优先搜索序列。
Sample Input
7
6
A B C D E F G
A B
A C
B D
B E
C F
C G
Sample Output
A B C D E F G
A B D E C F G
*/

#include <stdio.h>#include <stdlib.h>
unsigned char arrMap[26][26] = {0};
int nV = 0;
void deep_prior_scan(int j);
void spread_prior_scan(int j);

void GetResult()
{
int nL = 0;//存储边数
int i;
char arrV[26] = {0};
char temp, pairV[2];

//输入过程
printf("\n请输入顶点数：");
scanf("%d", &nV);
printf("\n请输入边数:");
scanf("%d", &nL);
printf("\n请依次输入顶点：\n");
for (i = 0, temp = 'A'; i < nV; )
{
temp = getchar();
if (temp >= 'A' && temp <= 'Z')
{
arrV[i++] = temp;
}
}

printf("\n请依次输入边:\n");
for (i = 0; i < nL*2; )
{
temp = getchar();
if (temp >= 'A' && temp <= 'Z')
{
pairV[i%2] = temp;
if (i%2 == 1)
{
arrMap[pairV[0] - 'A'][pairV[1] - 'A'] = 1;
}
++i;
}
}

//printf("\n广度优先遍历：\n");
//spread_prior_scan(0);
//printf("\n");
printf("\n深度优先遍历：\n");
deep_prior_scan(0);
printf("\n");
}

int main()
{
GetResult();
system("pause");
return 0;
}

void deep_prior_scan(int j)
{
int i;
printf("%c ", j + 'A');
for (i = 0; i < nV; i++)
{
if (arrMap[j][i] != 0)
{
arrMap[j][i] = 0;
deep_prior_scan(i);
}
}
}
void spread_prior_scan(int j)
{
int i;
if (j == 0)
{
printf("\nA ");
}
if (j >= 26)
{
printf("\nj=%d\n", j);
}
for (i = 0; i < nV; i++)
{
if (arrMap[j][i] != 0)
{
printf("%c ", i + 'A');
}
}

for (i = 0; i < nV; i++)
{
if (arrMap[j][i] != 0)
{
arrMap[j][i] = 0;
spread_prior_scan(i);
}
}
}

因为懒得复制数组，所以两种遍历方法要分开运行，你可以通过打开和关闭对相应函数的注释来得到两次的结果

‘玖’ 请问下c语言如何实现插入图片功能

1. C语言写控制台程序是无法加图片的，只能用命令行输出，最多就是设置下背景和字体，颜色之类的。如果开发API窗口程序，完全依赖于操作系统的函数库。C语言本身并不提供这类函数。

2. 下面是windows系统下实现的函数代码，第一个参数是图片的存放的位置，第二个参数是窗口句柄。
   

3. HRESULTShowPic(char*lpstrFile,HWNDhWnd)
   {
   HDChDC_Temp=GetDC(hWnd);
   IPicture*pPic;
   IStream*pStm;
   BOOLbResult;
   HANDLEhFile=NULL;
   DWORDdwFileSize,dwByteRead;
   //打开图形文件
   hFile=CreateFile(lpstrFile,GENERIC_READ,
   FILE_SHARE_READ,NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL,NULL);
   if(hFile!=INVALID_HANDLE_VALUE)
   {
   dwFileSize=GetFileSize(hFile,NULL);//获取文件字节数
   if(dwFileSize==0xFFFFFFFF)
   returnE_FAIL;
   }
   else
   {
   returnE_FAIL;
   }
   //分配全局存储空间
   HGLOBALhGlobal=GlobalAlloc(GMEM_MOVEABLE,dwFileSize);
   LPVOIDpvData=NULL;
   if(hGlobal==NULL)
   returnE_FAIL;
   if((pvData=GlobalLock(hGlobal))==NULL)//锁定分配内存块
   returnE_FAIL;
   ReadFile(hFile,pvData,dwFileSize,&dwByteRead,NULL);//把文件读入内存缓冲区
   GlobalUnlock(hGlobal);
   CreateStreamOnHGlobal(hGlobal,TRUE,&pStm);
   //装入图形文件
   bResult=OleLoadPicture(pStm,dwFileSize,TRUE,IID_IPicture,(LPVOID*)&pPic);
   if(FAILED(bResult))
   returnE_FAIL;
   OLE_XSIZE_HIMETRIChmWidth;//图片的真实宽度,单位为英寸
   OLE_YSIZE_HIMETRIChmHeight;//图片的真实高度,单位为英寸
   pPic->get_Width(&hmWidth);
   pPic->get_Height(&hmHeight);
   //转换hmWidth和hmHeight为pixels距离，1英寸=25.4毫米
   intnWidth=MulDiv(hmWidth,GetDeviceCaps(hDC_Temp,LOGPIXELSX),2540);
   intnHeight=MulDiv(hmHeight,GetDeviceCaps(hDC_Temp,LOGPIXELSY),2540);
   //将图形输出到屏幕上（有点像BitBlt）
   bResult=pPic->Render(hDC_Temp,0,0,nWidth,nHeight,0,hmHeight,hmWidth,-hmHeight,NULL);
   hmHeight,NULL);
   pPic->Release();
   CloseHandle(hFile);//关闭打开的文件
   if(SUCCEEDED(bResult))
   {
   returnS_OK;
   }
   else
   {
   returnE_FAIL;
   }
   }

‘拾’ 用C语言编程实现图的遍历算法

图的遍历是指按某条搜索路径访问图中每个结点，使得每个结点均被访问一次，而且仅被访问一次。图的遍历有深度遍历算法和广度遍历算法，最近阿杰做了关于图的遍历的算法，下面是图的遍历深度优先的算法（C语言程序）：
#include<stdio.h>
#include<malloc.h>
#define MaxVertexNum 5
#define m 5
#define TRUE 1
#define NULL 0
typedef struct node
{
int adjvex;
struct node *next;
}JD;
typedef struct EdgeNode
{
int vexdata;
JD *firstarc;
}TD;
typedef struct
{
TD ag[m];
int n;
}ALGRAPH;
void DFS(ALGRAPH *G,int i)
{
JD *p;
int visited[80];
printf("visit vertex:%d->",G->ag[i].vexdata);
visited[i]=1;
p=G->ag[i].firstarc;
while(p)
{
if (!visited[p->adjvex])
DFS(G,p->adjvex);
p=p->next;
}
}
void creat(ALGRAPH *G)
{
int i,m1,j;
JD *p,*p1;
printf("please input the number of graph\n");
scanf("%d",&G->n);
for(i=0;i<G->n;i++)
{
printf("please input the info of node %d",i);
scanf("%d",&G->ag[i].vexdata);
printf("please input the number of arcs which adj to %d",i);
scanf("%d",&m1);
printf("please input the adjvex position of the first arc\n");
p=(JD *)malloc(sizeof(JD));
scanf("%d",&p->adjvex);
p->next=NULL;
G->ag[i].firstarc=p;
p1=p;
for(j=2 ;j<=m1;j++)
{
printf("please input the position of the next arc vexdata\n");
p=(JD *)malloc(sizeof(JD));
scanf("%d",&p->adjvex);
p->next=NULL;
p1->next=p;
p1=p;
}
}
}
int visited[MaxVertexNum];
void DFSTraverse(ALGRAPH *G)
{
int i;
for(i=0;i<G->n;i++)
visited[i]=0;
for(i=0;i<G->n;i++)
if(!visited[i])
DFS(G,i);
}
int main()
{
ALGRAPH *G;
printf("下面以临接表存储一个图；\n");
creat(G);
printf("下面以深度优先遍历该图 \n");
DFSTraverse(G);
getchar();
}