‘壹’ 大学c语言课程设计，急求急求啊，这2天就要，求大神帮忙！！！！！！！
C++行贺旦不？这是我们的一个禅冲扰小项目，你拿去稍微修改判漏下：http://yunpan.cn/QevHf26VQMZqH
‘贰’ 数据结构课程设计（C版语言）二叉排序树算法
下面的程序包含了树二叉树的所有操作
在二叉树的应用中有二叉排序树。
都是C语言，只不过用了C++的cin(输入)和cout（输出）,因为这两个不需要格式控制符。
//建一个工程：包含头文件：bittree.h Cpp文件：bittree.cpp main函数:main.cpp
编译运行就可以了。
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//头文件 bittree.h
#ifndef _DEF
#define _DEF
#include <stdlib.h>
#include <stdio.h>
#include <iostream>
using namespace std;
#define TURE 1
#define OK 1
#define FALSE 0
#define ERROR 0
#define INFEASIBLE -1//不可实行的
#define OVERFLOW -2
typedef int stas;
typedef char Telemtype;
//typedef int Telemtype2;//为了二叉排序树的创建
typedef char ElemType;
#define STACK_SIZE 100;
#define STACKINCREMENT 10;
//二叉树
typedef struct bitnode{
Telemtype data;
struct bitnode *lchild,*rchild;
}BitNode,*BitTree;
extern stas CreateBitTree(BitTree &T);
extern stas PreOrderTraverse(BitTree T);
extern stas InOrderTraverse(BitTree T);
extern stas PostOrderTraverse(BitTree T);
typedef BitNode selemtypechar;
typedef BitTree selemtypechar2;
// 栈
typedef struct SqStack{
selemtypechar2 *base;
selemtypechar2 *top;
int stacksize;
}sqstack;
extern stas initstackC(sqstack &S);
extern stas gettopC(sqstack S,selemtypechar2 &e);
extern stas pushC(sqstack &S,selemtypechar2 e);
extern stas popC(sqstack &S,selemtypechar2 &e);
extern stas destroyC(sqstack &S);//销毁
extern stas clearC(sqstack &S);//置空
extern stas stackempty(sqstack S);
//栈实现二叉树的输出
extern stas PreOrderTraverse2(BitTree T);
extern stas InOrderTraverse2(BitTree T);
extern stas PostOrderTraverse2(BitTree T);
//二叉树的应用
extern stas Depth(BitTree T);
extern stas Single(BitTree T);
extern stas Double(BitTree T);
extern stas CountLeaf(BitTree T);
extern void Change_Left_Right(BitTree T);
//二叉层次遍历用到队列
typedef BitTree Qelemtype;
typedef struct QNode{
Qelemtype data;
struct QNode *next;
}qnode,*QueuePtr;
typedef struct {
QueuePtr front;
QueuePtr rear;
}LinkQueue;
extern stas InitQueue(LinkQueue &Q);
extern stas DestroyQueue(LinkQueue &Q);
extern stas EnterQueue(LinkQueue &Q,Qelemtype e);
extern stas DeQueue(LinkQueue &Q,Qelemtype &e);
//二叉层次遍历
extern stas LevelOrder(BitTree T);
//二叉排序树
extern void insert(BitTree &T,ElemType x);
extern void CreateBiTree2(BitTree &root);
#endif
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//cpp文件 bittree.cpp
#include "bittree.h"
#include <stdlib.h>
stas initstackC (sqstack &s)
{
s.base=(selemtypechar2 *)malloc(100*sizeof(selemtypechar));//用STACKINCREMENT会报错？？？
if (!s.base) exit(OVERFLOW);
s.top=s.base;
s.stacksize=100;
return OK;
}
stas gettopC(sqstack s,selemtypechar2 &e)
{
if(s.base==s.top) return ERROR;
e=*(s.top-1);
return OK;
}
stas pushC(sqstack &s,selemtypechar2 e)
{
if ((s.top-s.base)>=s.stacksize)
{
s.base=(selemtypechar2 *)realloc(s.base,((s.stacksize+10)*(sizeof(selemtypechar))));
if(!s.base) exit(OVERFLOW);
s.top=s.base+s.stacksize;
s.stacksize+=10;
}
*(s.top++)=e;
//s.top++;
return OK;
}
stas popC(sqstack &s,selemtypechar2 &e)
{
if(s.top==s.base) return ERROR;
--s.top;
e=*(s.top);
return OK;
}
stas destroyC(sqstack &s)
{
free(s.base); s.base=NULL;s.top=NULL;
return OK;
}
stas clearC(sqstack &s)
{
s.top=s.base;
return OK;
}
stas stackempty(sqstack s)
{
if(s.top!=s.base) return ERROR;
else
return OK;
}
//二叉树
stas CreateBitTree(BitTree &T)//创建
{
Telemtype ch;
cin>>ch;
if(ch=='#') T=NULL;
else{
T=(BitTree)malloc(sizeof(BitNode));
if (!T) exit (OVERFLOW);
T->data=ch;
CreateBitTree(T->lchild);
CreateBitTree(T->rchild);
}
return OK;
}
stas PreOrderTraverse(BitTree T)//先序访问
{
if(!T) return ERROR;
else if (T)
{
cout<<T->data<<" ";
PreOrderTraverse(T->lchild);
PreOrderTraverse(T->rchild);
}
return OK;
}
stas InOrderTraverse(BitTree T)//中序
{
if(!T) return ERROR;
else if (T)
{
InOrderTraverse(T->lchild);
cout<<T->data<<" ";
InOrderTraverse(T->rchild);
}
return OK;
}
stas PostOrderTraverse(BitTree T)//后序
{
if(!T) return ERROR;
else if (T)
{
PostOrderTraverse(T->lchild);
PostOrderTraverse(T->rchild);
cout<<T->data<<" ";
}
return OK;
}
//栈实现二叉树的访问
stas PreOrderTraverse2(BitTree T)//先序
{
sqstack s;
BitTree p;
initstackC(s);
p=T;
//pushC(s,p);
while (p||!stackempty(s))
{
//popC(s,p);
if (p)
{
pushC(s,p);
if(!p->data)return ERROR;
cout<<p->data<<" ";
//p1=p;
p=p->lchild;
if (p==NULL)
{
popC(s,p);
p=p->rchild;
}
else
pushC(s,p);
}
else {
popC(s,p);
popC(s,p);
p=p->rchild;
if (p==NULL)
{
popC(s,p);
if (p==NULL)
{
return OK;
}
else
{
p=p->rchild;
}
}
else{
pushC(s,p);
if(!p->data)return ERROR;
cout<<p->data<<" ";
p=p->lchild;//左空不压栈
if (p==NULL)
{
popC(s,p);
p=p->rchild;
}
else
pushC(s,p);
}
}
}
destroyC(s);
return OK;
}
stas InOrderTraverse2(BitTree T)//中序
{
sqstack s;
BitTree p;
initstackC(s);
p=T;
while (p||!stackempty(s))
{
if (p)
{
pushC(s,p);
p=p->lchild;
}
else {
popC(s,p);
if(!p->data)return ERROR;
cout<<p->data<<" ";
p=p->rchild;
}
}
destroyC(s);
return OK;
}
stas PostOrderTraverse2(BitTree T)//后序
{
sqstack s;
BitTree p;
initstackC(s);
p=T;
while (p||!stackempty(s))
{
if (p)
{
pushC(s,p);
p=p->lchild;
if (p==NULL)
{
popC(s,p);
//p=p->rchild;
if (p->rchild==NULL)
{
if(!p->data)return ERROR;
cout<<p->data<<" ";
//p=p->rchild;
popC(s,p);
if (p==NULL)
{
return OK;
}
else
{
//pushC(s,p);//???右结点重复压栈？？？
//p1=p;
p=p->rchild;
//p->rchild=NULL;
}
}
else
{
p=p->rchild;
}
}
else
continue ;
}
else
{
//popC(s,p);
if(!p->data)return ERROR;
cout<<p->data<<" ";
popC(s,p);
if (p==NULL)
{
return OK;
}
else
{
//pushC(s,p);
//p1=p;
p=p->rchild;
//p->rchild=NULL;
}
}
}
destroyC(s);
return OK;
}
//二叉树的应用
//二叉树的深度
stas Depth(BitTree T)
{
int depthval,depthLeft,depthRight;
if (!T) depthval=0;
else{
depthLeft=Depth(T->lchild);
depthRight=Depth(T->rchild);
depthval=1+(depthLeft>depthRight?depthLeft:depthRight);
}
return depthval;
}
//二叉树的单分支结点数
stas Single(BitTree T)
{
if (T==NULL) return 0; //空树
else if (T->lchild==NULL && T->rchild==NULL) return 0; //叶子结点
else{
if (!T->lchild && T->rchild) return Single(T->rchild)+1;//只有左单分支
if (T->lchild && !T->rchild) return Single(T->lchild)+1;//只有右单分支
if(T->lchild && T->rchild) return Single(T->lchild)+Single(T->rchild);//双分支结点
}
}
//二叉树的多分支结点数
stas Double(BitTree T)
{
if (T==NULL) return 0; //空树
else if (T->lchild==NULL && T->rchild==NULL) return 0; //叶子结点
else{
if (!T->lchild && T->rchild) return Double(T->rchild);//只有左单分支
if (T->lchild && !T->rchild) return Double(T->lchild);//只有右单分支
if(T->lchild && T->rchild) return Double(T->lchild)+Double(T->rchild)+1;//双分支结点
}
}
//叶子结点
stas CountLeaf(BitTree T)
{
int num,num1,num2;
if(T==NULL) num=0;
else if(T->lchild==NULL&&T->rchild==NULL)
num=1;
else
{
num1=CountLeaf(T->lchild);
num2=CountLeaf(T->rchild);
num=num1+num2;
}
return num;
}
//交换左右子树
void Change_Left_Right(BitTree T)
{
BitTree Temp;
if (T)
{
Change_Left_Right(T->lchild);
Change_Left_Right(T->rchild);
Temp=T->lchild;
T->lchild=T->rchild;
T->rchild=Temp;
}
}
//二叉层次遍历用到队列
stas InitQueue(LinkQueue &Q)
{
Q.front=Q.rear=(QueuePtr)malloc(100*sizeof(qnode));
if(!Q.front) exit(OVERFLOW);
Q.front->next=NULL;
return OK;
}
stas DestroyQueue(LinkQueue &Q)
{
while (Q.front)
{
Q.rear=Q.front->next;
free(Q.front);
Q.front=Q.rear;
}
return OK;
}
stas EnterQueue(LinkQueue &Q,Qelemtype e)
{
QueuePtr p;
p=(QueuePtr)malloc(sizeof(qnode));
if(!p) return ERROR;
p->data=e;
p->next=NULL;
Q.rear->next=p;
Q.rear=p;
return OK;
}
stas DeQueue(LinkQueue &Q,Qelemtype &e)
{ QueuePtr p;
if(Q.front==Q.rear) return ERROR;
p=Q.front->next;e=p->data;
Q.front->next=p->next;
if(Q.rear==p)Q.rear=Q.front;
free(p);
return OK;
}
//二叉层次遍历
stas LevelOrder(BitTree T)
{
LinkQueue Q;
BitTree B;
InitQueue(Q);
if (T!=NULL)
{
EnterQueue(Q,T);
while (!(Q.front==Q.rear))
{
DeQueue(Q,B);
cout<<B->data<<" ";
if(B->lchild!=NULL) EnterQueue(Q,B->lchild);
if(B->rchild!=NULL) EnterQueue(Q,B->rchild);
}
}
return OK;
}
//二叉排序树
void insert(BitTree &T,ElemType x)
{
if (T==NULL)
{
T=(BitTree)malloc(sizeof(BitNode));
T->data=x;
T->lchild=T->rchild=NULL;
}
else
{
if(x<T->data)insert(T->lchild,x);
if(x>=T->data)insert(T->rchild,x);
}
}
void CreateBiTree2(BitTree &root)
{
ElemType x;
root=NULL;
cout<<"二叉排序树的创建<以'#'结束!!!>"<<endl;
cout<<"<请输入字母，没写整型!!!>"<<endl;
cin>>x;
while (x!='#')
{
insert(root,x);
cin>>x;
}
}
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//主函数 main.cpp
#include "bittree.h"
void main()
{
system("cls");
system("color f0");
BitTree T;
Create:
cout<<'\t'<<'\t'<<"先序创建二叉树<以'#'表示左右孩子为空!!!>："<<endl;
CreateBitTree(T);
BitTree T1(T);
select:
cout<<'\t'<<'\t'<<"----------------MAIN-MENU----------------"<<endl;
cout<<'\t'<<'\t'<<"&1、先序输出 2、中序输出 3、后序输出 &"<<endl;
cout<<'\t'<<'\t'<<"&4、栈实现输出 5、重新创建二叉树 0、退出&"<<endl;
cout<<'\t'<<'\t'<<"------------6、二叉树的应用-------------"<<endl;
char sel;
getchar();
cin>>sel;
switch (sel)//总
{
case '0':
break;
case '1':cout<<endl<<"---------------------------------"<<endl;
PreOrderTraverse(T);
cout<<endl<<"---------------------------------"<<endl;
goto select;
case '2':cout<<endl<<"---------------------------------"<<endl;
InOrderTraverse(T);
cout<<endl<<"---------------------------------"<<endl;
goto select;
case '3':cout<<endl<<"---------------------------------"<<endl;
PostOrderTraverse(T);
cout<<endl<<"---------------------------------"<<endl;
goto select;
case '4':
stackcout:
cout<<endl<<'\t'<<" -------------------SUB-MENU1---------------------"<<endl;
cout<<'\t'<<" &1、先序输出 2、中序输出 3、后序输出 4、返回 &"<<endl;
cout<<'\t'<<" ------------------------------------------------"<<endl;
cin>>sel;
switch (sel)//栈关于树的输出
{
case '1':cout<<endl<<"---------------------------------"<<endl;
PreOrderTraverse2(T1);//p->lchild==null,时 T 的值被修改！！！！！！！！
cout<<endl<<"---------------------------------"<<endl;
goto stackcout;
case '2':cout<<endl<<"---------------------------------"<<endl;
InOrderTraverse2(T);
cout<<endl<<"---------------------------------"<<endl;
goto stackcout;
case '3':cout<<endl<<"---------------------------------"<<endl;
PostOrderTraverse(T1);//栈实现未写完
cout<<endl<<"---------------------------------"<<endl;
goto stackcout;
case '4':goto select;
default:cout<<"选择错误!!!"<<endl;
goto stackcout;
}
case '5':
goto Create;
case '6':
{
SUB_MENU2:
cout<<'\t'<<'\t'<<"-------------------------SUB-MENU2---------------------"<<endl;
cout<<'\t'<<'\t'<<"&1、二叉树的深度 2、二叉树的单分支结点数 &"<<endl;
cout<<'\t'<<'\t'<<"&3、二叉树的多分支结点数 4、二叉树的叶子结点数 &"<<endl;
cout<<'\t'<<'\t'<<"&5、二叉层次遍历 6、二叉排序树 7、交换左右子树 &"<<endl;
cout<<'\t'<<'\t'<<"&------------------8、输出 0、返回--------------------&"<<endl;
cin>>sel;
switch (sel)//二叉树的应用
{
case '0':
goto select;
case '1':
{
int deepth=0;
deepth=Depth(T);
cout<<endl<<"---------------------------------"<<endl;
cout<<"树的深度为："<<deepth<<endl;
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '2':
{
int cou_sig;
cou_sig=Single(T);
cout<<endl<<"---------------------------------"<<endl;
cout<<"此树的单分支结点为数："<<cou_sig<<endl;
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '3':
{
int cou_dou;
cou_dou=Double(T);
cout<<endl<<"---------------------------------"<<endl;
cout<<"此树的双分支结点数为："<<cou_dou<<endl;
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '4':
{
int cou_leaf;
cou_leaf=CountLeaf(T);
cout<<endl<<"---------------------------------"<<endl;
cout<<"此树的叶子结点数为："<<cou_leaf<<endl;
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '5':
{
cout<<"二叉层次遍历的结果为："<<endl;
cout<<endl<<"---------------------------------"<<endl;
LevelOrder(T);
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '6':
{
BitTree T3;
CreateBiTree2(T3);
SUB3:
cout<<'\t'<<"-------------------------SUB-MENU2-------------------"<<endl;
cout<<'\t'<<" &1、先序输出 2、中序输出 3、后序输出 0、返回 &"<<endl;
cout<<'\t'<<"-----------------------------------------------------"<<endl;
cin>>sel;
switch (sel)//二叉树的层次遍历
{
case '0':
break;
case '1':cout<<endl<<"---------------------------------"<<endl;
PreOrderTraverse(T3);
cout<<endl<<"---------------------------------"<<endl;
goto SUB3;
case '2':cout<<endl<<"---------------------------------"<<endl;
InOrderTraverse(T3);
cout<<endl<<"---------------------------------"<<endl;
goto SUB3;
case '3':cout<<endl<<"---------------------------------"<<endl;
PostOrderTraverse(T3);
cout<<endl<<"---------------------------------"<<endl;
goto SUB3;
default:
cout<<"选择错误!!!"<<endl;
goto SUB3;
}
}
goto SUB_MENU2;
case '7':
{
Change_Left_Right(T);
cout<<endl<<"---------------------------------"<<endl;
cout<<"交换完成，请选择8输出查看!!!"<<endl;
cout<<endl<<"---------------------------------"<<endl;
}
goto SUB_MENU2;
case '8':
goto select;
default:
cout<<"选择错误!!!"<<endl;
goto SUB_MENU2;
}
}
break;
default :
cout<<endl<<"选择错误!!!"<<endl;
goto select;
}
}
‘叁’ C语言教程的内容是
C语言学习从入门到精通的一套经典视频教程，本课程通过高清晰的视频、概念详解、实例精讲、习题测试让你很快的掌握C语言的相关知识，并领略运用到实例中去。在针对一些用户认为C语言比较难学的情况下，本课程从初中级用户的角度出发，进行合理的内容安排，突出学、练、用、巩固相结合的特点，以通俗易懂的语言，丰富多彩的实例，详细介绍了使用C语言进行程序开发应该掌握的各方面知识。本课程主要给大家讲解了C语言概述，算法，数据类型，运算符与表达式，常用的数据输入、输出函数，选择结构程序设计，循环控制，数组，函数，指针，结构体和共用体，位运算，预处理，模块化编程，编程规范，C语言常见问题及分析，习题测试等内容。所有知识都结合具体实例进行介绍，涉及的程序代码给出了详细的讲解，可以使读者轻松领会C语言程序开发的精髓，快速提高开发技能。
课程内容详尽，实例丰富，非常适合作为单片机及编程初学者的学习课程，也可作为大中院校相关专业在校学生及毕业生的教学辅导课程、短期C语言培训课程，是C语言编程爱好者从入门到深入的经典课程。
课程共分为15讲，每节课的内容大纲如下：
第1课 C语言概述
1、几种常见的程序设计语言
2、C语言出现的历史背景
3、C语言的特点
4、简单的C程序介绍
5、C程序的上机步骤
6、习题测试
第2课 程序的灵魂-算法
1、程序设计过程
2、算法的基本概念
3、算法的特征
4、算法的表示方法（流程图）
5、结构化程序设计方法
6、习题测试
第3课 C语言的数据类型
1、预备知识
2、C语言的数据类型
3、常量与变量
4、不同数据类型之间的转换
5、运算符号和表达
6、习题测试
第4课 C语言顺序程序设计
1、C语句概述
2、赋值语句
3、数据的输入输出
4、字符数据输入输出
5、格式输入输出
6、顺序程序举例
7、习题测试
第5课 C语言选择程序设计
1、关系运算符和关系表达式
2、逻辑运算符和逻辑表达式
3、if 语句---条件判断
4、条件运算符
5、switch 语句
6、选择程序举例
7、习题测试
第6课 C语言的循环控制
1、概述
2、goto语句及与if语句构成循环
3、while语句
4、do …while语句
5、for语句
6、循环的嵌套
7、几种循环的比较
8、break语句和contiune语句
9、程序举例
10、习题测试
第7课 C语言数组
1、一维数组
2、二维数组及多维数组
3、字符数组和字符串
4、程序举例
5、习题测试
第8课 函数
1、概述
2、函数定义的一般格式
3、函数的返回值
4、函数的调用
5、函数参数及其传递方式
6、函数的嵌套与递归调用
7、数组作为函数参数
8、变量的存储属性
9、内部函数和外部函数
10、习题测试
第9课 C语言预处理命令
1、编译预处理
2、宏定义
3、文件包含
4、条件编译
5、习题测试
第10课 指针
1、指针的概念
2、指针变量
3、指针与数组
4、指针与字符串
5、指针与函数
6、返回指针值的函数
7、指针数组和多级指针
8、习题测试
第11课 结构体与共用体
1、结构类型与结构变量的定义
2、结构变量的引用与初始化
5、结构数组
6、指向结构类型数据的指针
7、用指针处理链表
8、共用体
9、枚举类型
10、用typedef定义别名
11、程序举例
12、习题测试
第12课 位运算
1、位运算概述
2、位运算符的使用方法
3、习题测试
第13课 单片机C语言的模块化编程
1、模块化编程的优点
2、C语言源文件(*.c)文件和头文件(*.h)的的作用
3、模块化编程设计步骤
4、程序实例
5、模块化程序的移植
6、习题测试
第14课 C语言编程规范
1、编码规范概述
2、编程排版规范
3、编程注释规范
4、命名规则
5、可读性规范
6、变量与结构规范
7、函数与过程规范
8、编程效率规范
9、质量保证规范
10、宏规范
11、代码编辑
12、编译
13、审查
14、代码测试
15、维护
16、习题测试
第15课 C语言编程常见出错问题及分析
1、C语言的一些基本概念
2、位(bit)和字节(byte)
3、变量和数据存储
4、数据文件
5、字符串操作
6、数组
7、指针和内存分配
8、函数
9、编译预处理
10、标准库函数
11、系统调用
12、可移植性
13、编程风格和标准
14、程序的编写和编译
15、调试
‘肆’ C语言课程设计，贪吃蛇应该怎么做
2.1程序功能介绍
贪吃蛇游戏是一个经典小游戏，一条蛇在封闭围墙里，围墙里随机出现一个食物，通过按键盘四个光标键控制蛇向上下左右四个方向移动，蛇头撞倒食物，则食物被吃掉，蛇身体长一节，同时记10分，接着又出现食物，等待蛇来吃，如果蛇在移动中撞到墙或身体交叉蛇头撞倒自己身体游戏结束。
2.2程序整体设计说明
一个游戏要有开始部分，运行部分，结束部分（实际上开始部分与运行部分是一体的）。
2.2.1设计思路
这个程序的关键是表示蛇的图形以及蛇的移动。用一个小矩形表示蛇的一节身体，身体每长一节，增加一个矩形块，蛇头用两节表示。移动时必须从蛇头开始，所以蛇不能向相反方向移动，也就是蛇尾不能改作蛇头。如果不按任何键，蛇自行在当前方向上前移，当游戏者按了有效的方向键后，蛇头朝着指定的方向移动，一步移动一节身体，所以当按了有效的方向键后，先确定蛇头的位置，然后蛇身体随着蛇头移动，图形的实现是从蛇头的新位置开始画出蛇，这时由于没有庆平的原因，原来蛇的位置和新蛇的位置差一个单位，所以看起来社会多一节身体，所以将蛇的最后一节用背景色覆盖。食物的出现和消失也是画矩形块和覆盖矩形块
2.2.2数据结构设计及用法说明
开始部分：
游戏是运行在图形模式下的，所以第一步一定是初始化图形模式，接着要有开始的界面，就像书有封面一样，我设置了一个游戏的标题画面，除了游戏标题画面我还设置了一个欢迎画面。标题画面以后，还要为游戏的运行部分作初始化，包括绘制游戏运行时的背景，对游戏某些重 要变量的初始化。
运行部分：
作为游戏的核心部分，这里包括的函数比较多，也就是模块比较多，首先让我模拟一下贪吃蛇的游戏模式：某个世界上突然出现一条蛇，它很短，它的运动神经异常，它没法停止自己的多动症在它的世界里就只有食物，它很饿，也很贪吃；同样在不明原因的情况下，食物从天而降，可惜的是没有落到嘴边；饥饿的主人公，不管它有没有毒，也不问食物的来历，径直向食物爬去；它吃到食物啦，它超出想象的同化能力让食物很快的成为自己身体的一部分，它的身子变长啦。当它吃到第一颗食物时，上帝有给它第二颗，于是它吃了第二颗，于是又变长了，于是又有第三颗??它的身子是一直的加长，它不管自己过长身体的麻烦——转身不便，继续吃下去，现在它是直接把巴张大，好让食物有个绿色通道。但是在某天的下午，它咬到了自己，它才想起自己是一条毒蛇，于是晕死过去（不是毒死）；又或者它往食物冲锋的时候，它失去控制，撞到了墙上。
第一轮循环：第一步，出现食物；第二步，蛇不停运动；第三步，检查蛇是撞到自己或墙壁；由第四步起游戏有两条支线（A、B）：
A ：第四步，蛇没有碰到自己或墙壁，蛇继续前进，绘制蛇的动作；第五步，判断蛇是否吃到食物，如果蛇吃到食物，身子变长，原来的食物消失；第六步，让玩家输入控制指令，让蛇在下一轮循环的第二步改变运动方向；第七步，第二轮循环的第一步，重复第一轮的步骤；
B：第四步，蛇碰到自己或墙壁，终止游戏。
结束部分：
游戏结束时，显示“GAME OVER”，已经是约定俗成的规律了，我的游戏也不例外。除了游戏结束画面外，我还设置了一个游戏退出画面，“善始善终”嘛。
有了上述的大致划分，我把整个程序划分成（13+2）个模块（其实就是函数）
2.2.3程序结构（流程图）
图2.1流程图
依据所需要处理的任务要求，规划输入数据和输出结果，决定存放数据的数据结构。
C语言中数据结构集中体现在数据类型上，因此在进行C语言程序设计时，应统筹规划程序中所使用的变量，数组，指针等，以及它们的类型等。这点是很重要的，如果在此期间选择不合适的变量或者数组，将来修改就十分困难。
现在分析一下贪吃蛇游戏中的元素，继而得出与它们对应的在程序中的描述：
蛇：
基本描述：长度，颜色，位置。
对应数据与数据类型：长度—虽然可以用坐标表示，但是这样的话，运算量将很大，所以换算成较大的单位—节数，以固定长度的每节描述；坐标--整型；颜色--整型； 位置--X，Y坐标。
增加的描述：蛇运动的方向，蛇的生命。
对应数据与数据类型：这些描述是为了与程序的按键的输入部分与判断游戏结束部分相联系而设的。方向只有四个方向：上下左右。可以设置与之对应的四个整型数：3、4、2、1。生命就只有两种情况：死或生，对应0或1。
食物：
基本描述：颜色，位置。
对应数据与数据类型：由于颜色设成固定的，所以不再讨论。位置—X、Y坐标。
增加的描述：食物的存在。
对应数据与数据类型：这是为了避免重复出现食物而设置的，与绘制食物的函数有联系。只有两个值：0或1（没有食物或有食物）
其他的元素：墙，由于它在显示上是作为背景而存在的，所以并没有什么说明实际的墙壁就是四条直线组成的边框，由坐标描述。
还需要的变量：键盘键入的键值（作为全局变量，整型）；经常要使用的循环变量；自定义的填充图案；说明文字的字符数组；游戏的记分；游戏的速度（蛇的速度）。
图2.2蛇的不停运动的关键算法的流程图
2.2.4各模块的功能及程序说明
主要模块的实现思路和算法的流程图说明：
关键所在——蛇不停移动的Snakemove()：
蛇的不停移动，就是蛇的下一节取代前一节的位置，在计算机中就是蛇下一节的位置坐标变成前一节的位置坐标。在上文中，已定义蛇的位置坐标为数组类型，一组坐标对应一节的位置，假设有i+1节，由0到i节，第i节的坐标取第i-1节的坐标，第i-1节的坐标取第i-2节的坐标??直到第1节取第0节的坐标。而第0节的坐标，即蛇头的坐标要往某个方向变化，变化量为蛇每节的长度。蛇的这种坐标轮换需要循环语句使其继续下去。
2.2.5程序结果
运行程序得到如下初始界面图：
图2.3程序结果图
用一个小矩形表示蛇的一节身体，身体每长一节，增加一个矩形块，蛇头用两节表示：
图2.4程序结果图
蛇没有碰到自己或墙壁，蛇继续前进：
图2.5程序结果图
游戏结束时，显示“GAME OVER”
图2.6程序结果图
2.3程序源代码及注释
#define N 200
#include <graphics.h>
#include <stdlib.h>
#include <dos.h>
#define LEFT 0x4b00
#define RIGHT 0x4d00
#define DOWN 0x5000
#define UP 0x4800
#define ESC 0x011b
int i,key;
int score=0;/*得分*/
int gamespeed=50000;/*游戏速度自己调整*/
struct Food{
int x;/*食物的横坐标*/
int y;/*食物的纵坐标*/
int yes;/*判断是否要出现食物的变量*/
}food;/*食物的结构体*/
struct Snake{
int x[N];
int y[N];
int node;/*蛇的节数*/
int direction;/*蛇移动方向*/
int life;/* 蛇的生命,0活着,1死亡*/
}snake;
void Init(void);/*图形驱动*/
void Close(void);/*图形结束*/
void DrawK(void);/*开始画面*/
void GameOver(void);/*结束游戏*/
void GamePlay(void);/*玩游戏具体过程*/
void PrScore(void);/*输出成绩*/
/*主函数*/
void main(void){
Init();/*图形驱动*/
DrawK();/*开始画面*/
GamePlay();/*玩游戏具体过程*/
Close();/*图形结束*/}
/*图形驱动*/
void Init(void){
int gd=DETECT,gm;
registerbgidriver(EGAVGA_driver);
initgraph(&gd,&gm,"c:\program files\winyes\tc20h\bgi");
cleardevice();}
/*开始画面，左上角坐标为（50，40），右下角坐标为（610，460）的围墙*/
void DrawK(void){
/*setbkcolor(LIGHTGREEN);*/
setcolor(11);
setlinestyle(SOLID_LINE,0,THICK_WIDTH);/*设置线型*/
for(i=50;i<=600;i+=10)/*画围墙*/ {
rectangle(i,40,i+10,49); /*上边*/
rectangle(i,451,i+10,460);/*下边*/ }
for(i=40;i<=450;i+=10) {
rectangle(50,i,59,i+10); /*左边*/
rectangle(601,i,610,i+10);/*右边*/ }}
/*玩游戏具体过程*/
void GamePlay(void){
randomize();/*随机数发生器*/
food.yes=1;/*1表示需要出现新食物,0表示已经存在食物*/
snake.life=0;/*活着*/
snake.direction=1;/*方向往右*/
snake.x[0]=100;snake.y[0]=100;/*蛇头*/
snake.x[1]=110;snake.y[1]=100;
snake.node=2;/*节数*/
PrScore();/*输出得分*/
while(1)/*可以重复玩游戏,压ESC键结束*/ {
while(!kbhit())/*在没有按键的情况下,蛇自己移动身体*/ {
if(food.yes==1)/*需要出现新食物*/ {
food.x=rand()%400+60;
food.y=rand()%350+60;
while(food.x%10!=0)/*食物随机出现后必须让食物能够在整格内,这样才可以让蛇吃到*/
food.x++;
while(food.y%10!=0)
food.y++;
food.yes=0;/*画面上有食物了*/ }
if(food.yes==0)/*画面上有食物了就要显示*/ {
setcolor(GREEN);
rectangle(food.x,food.y,food.x+10,food.y-10); }
for(i=snake.node-1;i>0;i--)/*蛇的每个环节往前移动,也就是贪吃蛇的关键算法*/ {
snake.x[i]=snake.x[i-1];
snake.y[i]=snake.y[i-1]; }
/*1,2,3,4表示右,左,上,下四个方向,通过这个判断来移动蛇头*/
switch(snake.direction) {
case 1:snake.x[0]+=10;break;
case 2: snake.x[0]-=10;break;
case 3: snake.y[0]-=10;break;
case 4: snake.y[0]+=10;break; }
for(i=3;i<snake.node;i++)/*从蛇的第四节开始判断是否撞到自己了，因为蛇头为两节，第三节不可能拐过来*/ {
if(snake.x[i]==snake.x[0]&&snake.y[i]==snake.y[0]) {
GameOver();/*显示失败*/
snake.life=1;
break; } }
if(snake.x[0]<55||snake.x[0]>595||snake.y[0]<55||
snake.y[0]>455)/*蛇是否撞到墙壁*/ {
GameOver();/*本次游戏结束*/
snake.life=1; /*蛇死*/ }
if(snake.life==1)/*以上两种判断以后,如果蛇死就跳出内循环，重新开始*/
break;
if(snake.x[0]==food.x&&snake.y[0]==food.y)/*吃到食物以后*/ {
setcolor(0);/*把画面上的食物东西去掉*/
rectangle(food.x,food.y,food.x+10,food.y-10);
snake.x[snake.node]=-20;snake.y[snake.node]=-20;
/*新的一节先放在看不见的位置,下次循环就取前一节的位置*/
snake.node++;/*蛇的身体长一节*/
food.yes=1;/*画面上需要出现新的食物*/
score+=10;
PrScore();/*输出新得分*/ }
setcolor(4);/*画出蛇*/
for(i=0;i<snake.node;i++)
rectangle(snake.x[i],snake.y[i],snake.x[i]+10,
snake.y[i]-10);
delay(gamespeed);
setcolor(0);/*用黑色去除蛇的的最后一节*/
rectangle(snake.x[snake.node-1],snake.y[snake.node-1],
snake.x[snake.node-1]+10,snake.y[snake.node-1]-10); } /*endwhile（！kbhit）*/
if(snake.life==1)/*如果蛇死就跳出循环*/
break;
key=bioskey(0);/*接收按键*/
if(key==ESC)/*按ESC键退出*/
break;
else
if(key==UP&&snake.direction!=4)
/*判断是否往相反的方向移动*/
snake.direction=3;
else
if(key==RIGHT&&snake.direction!=2)
snake.direction=1;
else
if(key==LEFT&&snake.direction!=1)
snake.direction=2;
else
if(key==DOWN&&snake.direction!=3)
snake.direction=4;
}/*endwhile(1)*/}
/*游戏结束*/
void GameOver(void){
cleardevice();
PrScore();
setcolor(RED);
settextstyle(0,0,4);
outtextxy(200,200,"GAME OVER");
getch();}
/*输出成绩*/
void PrScore(void){
char str[10];
setfillstyle(SOLID_FILL,YELLOW);
bar(50,15,220,35);
setcolor(6);
settextstyle(0,0,2);
sprintf(str,"score:%d",score);
outtextxy(55,20,str);}
/*图形结束*/
void Close(void){
getch();
closegraph();
}
‘伍’ 学习C语言需要掌握哪些基本知识
1.入门程序
#include <stdio.h>
int main()
{
printf("Hello World!");
return 0;
}
2.数据类型
数据类型:
1.基本数据类型：
1.1. 整型:int 4个字节
1.2. 字符型:char 1个字节
1.3. 实型(浮点型)
1.3.1.单精度型:float 4个字节
1.3.2.双精度型:double 8个字节
2.构造类型：
2.1.枚举类型
2.2.数组类型
2.3.结构体类型
2.4.共用体类型
3.指针类型：
4.空类型：
3.格式化输出语句
%d:十进制整数;
%c:单个字符;
%s:字符串;
%f:6位小数;
学好C++才是入职大厂的敲门砖！ 当年要是有这课，我的C++也不至于这样
已失效
4.常量
值不发生改变的量成为常量;
定义字符常量(注意后面没有;)
5.运算符
5.1.算数运算符:+,-,*,/,%,++,--;前++/--,先运算,再取值.后++/--,先取值,再运算;
5.2.赋值运算符:
5.3.关系运算符;
5.4.逻辑运算符;
5.5.三目运算符:
表达式1 ? 表达式2 : 表达式3;
6.水仙花数计算
输出所有三位数的水仙花数字
所谓“水仙花数”是指一个三位数，其各位数字立方和等于该数，如：153就是一个水仙花数，153=111+555+333。
7.打印正三角形的*
8.臭名远扬的goto语句
很少使用
9.形参与实参
形参:形参是在定义函数名和函数体的时候使用的参数,目的是用来接收调用该函数时传入的参数;
实参:实参是在调用时传递该函数的参数。
函数的形参和实参具有以下特点：
形参只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只有在函数内部有效。函数调用结束返回主调函数后则不能再使用该形参变量。
实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须具有确定的值，以便把这些值传送给形参。因此应预先用赋值等办法使实参获得确定值。
在参数传递时，实参和形参在数量上，类型上，顺序上应严格一致，否则会发生类型不匹配”的错误。
10.函数返回值注意
注意：void函数中可以有执行代码块，但是不能有返回值，另void函数中如果有return语句，该语句只能起到结束函数运行的功能。其格式为：return;
11.递归
12.变量存储类别 !
12.1.生存周期划分存储方式
C语言根据变量的生存周期来划分，可以分为静态存储方式和动态存储方式。
静态存储方式：是指在程序运行期间分配固定的存储空间的方式。静态存储区中存放了在整个程序执行过程中都存在的变量，如全局变量。
动态存储方式：是指在程序运行期间根据需要进行动态的分配存储空间的方式。动态存储区中存放的变量是根据程序运行的需要而建立和释放的，通常包括：函数形式参数；自动变量；函数调用时的现场保护和返回地址等。
12.2.存储类型划分
C语言中存储类别又分为四类：自动（auto）、静态（static）、寄存器的（register）和外部的（extern） ;
用关键字auto定义的变量为自动变量，auto可以省略，auto不写则隐含定为“自动存储类别”，属于动态存储方式。
用static修饰的为静态变量，如果定义在函数内部的，称之为静态局部变量；如果定义在函数外部，称之为静态外部变量。
注意：静态局部变量属于静态存储类别，在静态存储区内分配存储单元，在程序整个运行期间都不释放；静态局部变量在编译时赋初值，即只赋初值一次；如果在定义局部变量时不赋初值的话，则对静态局部变量来说，编译时自动赋初值0（对数值型变量）或空字符（对字符变量）
为了提高效率，C语言允许将局部变量的值放在CPU中的寄存器中，这种变量叫“寄存器变量”，用关键字register作声明。
注意：只有局部自动变量和形式参数可以作为寄存器变量；一个计算机系统中的寄存器数目有限，不能定义任意多个寄存器变量；局部静态变量不能定义为寄存器变量。
用extern声明的的变量是外部变量，外部变量的意义是某函数可以调用在该函数之后定义的变量。
13.内部函数外部函数 !
在C语言中不能被其他源文件调用的函数称为内部函数 ，内部函数由static关键字来定义，因此又被称为静态函数，形式为：
static [数据类型] 函数名（[参数]）
这里的static是对函数的作用范围的一个限定，限定该函数只能在其所处的源文件中使用，因此在不同文件中出现相同的函数名称的内部函数是没有问题的。
在C语言中能被其他源文件调用的函数称为外部函数 ，外部函数由extern关键字来定义，形式为：
extern [数据类型] 函数名([参数])
C语言规定，在没有指定函数的作用范围时，系统会默认认为是外部函数，因此当需要定义外部函数时extern也可以省略。 extern可以省略; 14.数组 数组:一块连续的，大小固定并且里面的数据类型一致的内存空间， 数组的声明:数据类型 数组名称[长度n]
数据类型 数组名称[长度n] = {元素1,元素2,元素3,......};
数据类型 数组名称[] = {元素1,元素2,元素3,......};
数类类型 数组名称[长度n]; 数组名称[0] = 元素1;数组名称[1] = 元素2;...... 注意： 1、数组的下标均以0开始； 2、数组在初始化的时候，数组内元素的个数不能大于声明的数组长度； 3、如果采用第一种初始化方式，元素个数小于数组的长度时，多余的数组元素初始化为0； 4、在声明数组后没有进行初始化的时候，静态（static）和外部（extern）类型的数组元素初始化元素为0，自动（auto）类型的数组的元素初始化值不确定。
15.数组遍历
数组的冒泡排序
冒泡排序的思想：相邻元素两两比较，将较大的数字放在后面，直到将所有数字全部排序。
字符串与数组
在C语言中,是没有办法直接定义子字符串数据类型的,需使用数组来定义所要的字符串,形式如下:
char 字符串名称[长度] = "字符串内容";
char 字符串名称[长度] = {'字符串1','字符串2',....,'字符串n',' '};
注:
[]中的长度可以省略不写;
采用第二种方式最后一个元素必须是' ',表示结束;
第二种方式不能写中文!; 输出字符串时,要使用:printf("%s",字符数组名);或puts(字符数组名);
16.字符串函数
strlen(s):获取字符串s的长度;
strcmp(s1,s2):比较字符串;比较的时候会把字符串转换成ASCII码再进行比较,返回结果为0表示s1和s2的ASCII码值相等,返回结果为1表示s1比s2的ASCII码大,返回结果为-1表示s1比s2的ACSII码小;
strcpy(s1,s2):字符串拷贝;s2会取代s1中的内容;
strcat(s1,s2)将s2拼接到s1后面;注意:s1的length要足够才可以!
atoi(s1)将字符串转为整数!
17.多维数组
数据类型 数组名称[常量表达式1]...[常量表达式n];
多维数组的初始化与一维数组的初始化类似也是分两种：
数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n] = {{值1,..,值n},{值1,..,值n},...,{值1,..,值n}};
数据类型 数组名称[常量表达式1][常量表达式2]...[常量表达式n]; 数组名称[下标1][下标2]...[下标n] = 值;
多维数组初始化要注意以下事项：
采用第一种始化时数组声明必须指定列的维数。因为系统会根据数组中元素的总个数来分配空间，当知道元素总个数以及列的维数后，会直接计算出行的维数；
采用第二种初始化时数组声明必须同时指定行和列的维数。
18.多维度数组的遍历
使用嵌套循环
注意:多维数组的每一维下标均不能越界!
19.结构体
C 数组允许定义可存储相同类型数据项的变量，结构是 C 编程中另一种用户自定义的可用的数据类型，它允许您存储不同类型的数据项。
结构用于表示一条记录，假设您想要跟踪图书馆中书本的动态，您可能需要跟踪每本书的下列属性：
Title
Author
Subject
Book ID
定义结构
为了定义结构，您必须使用 struct 语句。struct 语句定义了一个包含多个成员的新的数据类型，struct 语句的格式如下：
tag 是结构体标签。
member-list 是标准的变量定义，比如 int i; 或者 float f，或者其他有效的变量定义。
variable-list 结构变量，定义在结构的末尾，最后一个分号之前，您可以指定一个或多个结构变量。下面是声明 Book 结构的方式：
在一般情况下，tag、member-list、variable-list 这 3 部分至少要出现 2 个。以下为实例：
访问结构成员
为了访问结构的成员，我们使用成员访问运算符（.）。成员访问运算符是结构变量名称和我们要访问的结构成员之间的一个句号。您可以使用 struct 关键字来定义结构类型的变量。下面的实例演示了结构的用法：
学好C++才是入职大厂的敲门砖！ 当年要是有这课，我的C++也不至于这样
已失效
20.共用体
共用体是一种特殊的数据类型，允许您在相同的内存位置存储不同的数据类型。您可以定义一个带有多成员的共用体，但是任何时候只能有一个成员带有值。共用体提供了一种使用相同的内存位置的有效方式。
21.指针
22.文件读写
写入文件
读取文件
C语言与C++学习路线
23.排序算法
十大经典排序算法(动态演示+代码)
24.查找算法
九种查找算法
25.面试知识
C语言与C++面试知识总结
26.字符串操作
字符串操作的全面总结
27.C语言常用标准库解读
C语言常用标准库解读
28. C语言最常用的贪心算法
C语言最常用的贪心算法就这么被攻克了
29. 常见的C语言内存错误及对策
常见的C语言内存错误及对策
30. C语言实现面向对象的原理
C语言实现面向对象的原理
31. C语言/C++内存管理
看完这篇你还能不懂C语言/C++内存管理？
32. 再谈C语言指针
再谈指针：大佬给你拨开 C 指针的云雾
C语言函数指针之回调函数
C语言指针详解(文末有福利)
33. C语言预处理命令
长文详解：C语言预处理命令
34. C语言高效编程与代码优化
C语言高效编程与代码优化
35. C语言结构体
C语言之结构体就这样被攻克了！值得收藏！
36. 原码, 反码, 补码 详解
原码, 反码, 补码 详解
37. C语言宏定义
简述C语言宏定义的使用
38. c语言之共用体union、枚举、大小端模式
c语言之共用体union、枚举、大小端模式
‘陆’ C语言课程设计：shell排序、堆排序、快速排序、归并(递归和非递归)排序5种算法效率分析！求能运行的源码！
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
#include <Windows.h>
void shellSort(int *a,int len)
{
int step;
int i,j;
int temp;
for(step=len/2; step>0;step/=2)
{
for(i=step;i<len;i++)
{
temp = a[i];
for(j=i-step;(j>=0 && temp < a[j]);j-=step)
{
a[j+step] = a[j];
}
a[j+step] = temp;
}
}
}
void swap(int *a,int *b)
{
int temp = *a;
*a = *b;
*b = temp;
}
void heapify(int *a,int n,int k)
{
int l,r,lg = -1;
l = 2*k;
r = l+1;
if (l <= n && a[l-1] > a[k-1])
{
lg = l;
}
else
{
lg = k;
}
if (r <= n && a[r-1] > a[lg-1])
{
lg = r;
}
if (lg != k)
{
swap(&a[lg-1],&a[k-1]);
heapify(a,n,lg);
}
}
void build_heap(int a[],int n)
{
for (int i=n/2+1; i>0; i--)
{
heapify(a,n,i);
}
}
void heap_sort(int a[],int n)
{
build_heap(a,n);
for (int i=n; i>0; i--)
{
swap(&a[0],&a[i-1]);
heapify(a,i-1,1);
}
}
int partitions(int a[],long p,long q)
{
long i,j=p-1;
for (i=p; i<q; i++)
{
if (a[i-1] <= a[q-1])
{
j++;
swap(&a[i-1],&a[j-1]);
}
}
j++;
swap(&a[j-1],&a[q-1]);
return j;
}
void quicksort(int a[],long p,long q)
{
long i;
if (p<q)
{
i = partitions(a,p,q);
quicksort(a,p,i-1);
quicksort(a,i+1,q);
}
}
void merge(int *a,int start, int mid, int end)
{
int n1 = mid - start + 1;
int n2 = end - mid;
int *left = (int *)malloc(sizeof(int)*n1), *right=(int *)malloc(sizeof(int)*n2);
int i, j, k;
for (i = 0; i <棚孝 n1; i++) /* left holds a[start..mid] */
left[i] = a[start+i];
for (j = 0; j < n2; j++) /* right holds a[mid+1..end] */链拦稿
right[j] = a[mid+1+j];
i = j = 0;
k = start;
while (i < n1 && j < n2)
if (left[i] < right[j])
a[k++] = left[i++];
else
a[k++] = right[j++];
while (i < n1) /* left[] is not exhausted */
a[k++] = left[i++];
while (j <衡友 n2) /* right[] is not exhausted */
a[k++] = right[j++];
free(left);
free(right);
}
void MergeSort(int *a,int start, int end)
{
int mid;
if (start < end)
{
mid = (start + end) / 2;
MergeSort(a,start, mid);
MergeSort(a,mid+1, end);
merge(a,start, mid, end);
}
}
double gettime(LARGE_INTEGER t,LARGE_INTEGER t1,LARGE_INTEGER t2)
{
double time;
if (t.LowPart==0 && t.HighPart==0)
time = -1;
else
{
time = (float)(t2.LowPart - t1.LowPart);
if (time < 0) time += 2^32;
time /= (t.LowPart+t.HighPart * 2^32);
}
return time;
}
int main()
{
const int NUM = 1000;
srand(time(NULL));
int data[NUM];
int i;
for (i=0; i<NUM; ++i)
{
data[i] = rand()/(RAND_MAX/20000+1);
}
LARGE_INTEGER t,t1,t2;
QueryPerformanceFrequency(&t);
QueryPerformanceFrequency(&t1);
shellSort(data,NUM);
QueryPerformanceFrequency(&t2);
printf("shell time:%0.4f\n",gettime(t,t1,t2));
QueryPerformanceFrequency(&t1);
heap_sort(data,NUM);
QueryPerformanceFrequency(&t2);
printf("shell time:%0.4f\n",gettime(t,t1,t2));
QueryPerformanceFrequency(&t1);
quicksort(data,1,NUM);
QueryPerformanceFrequency(&t2);
printf("shell time:%0.4f\n",gettime(t,t1,t2));
QueryPerformanceFrequency(&t1);
MergeSort(data,0,NUM);
QueryPerformanceFrequency(&t2);
printf("shell time:%0.4f\n",gettime(t,t1,t2));
return 0;
}
‘柒’ 数据结构与算法分析 课程设计 c/c++语言
头大啦！
‘捌’ C语言课程设计：查找算法设计
折半查找
#include <stdio.h>
#define N 51
void main(void)
{
int a[N];
int i,n,num;
int top,bottom,mid;
int flag=1; //如果在表列中找到数字，则值为1，否则为0
int loc=-1;//要查找的数在表列中的位置，如果loca=-1表枣碰示表列中没有这个数;如果有这个数,则它的值为所在的位置
printf("你想在多少个数中进行折半查找，请输入（1--50）：");
scanf("%d",&n);
while(n<1 || n>50)
{
printf("你输入的数不正确，请重新输入。\n");
printf("你想在多少个数中进行折半查找，请输入（1--50）：");
scanf("%d",&n);
}
printf("请你输入一个整数 a[1](需保证递增有序):");
scanf("%d",&a[1]);
i=2;
while(i<=n) //输入从小到大的表列
{
printf("请你输入一个整数 a[%d](需保证递增有序):",i);
scanf("%d",&a[i]);
if(a[i] > a[i-1])
i++;
else
printf("你输入的数不满足要求，请重新输入。\n");
}
//输出表列
printf("\n输出表列\n");
for(i=1; i<=n; i++)
{
printf("%6d",a[i]);
}
printf("\n");
printf("请你输入要查找的数：");
scanf("%d",&num);
flag=1; //假设输入的数在表列中
top=n;
bottom=1;
mid=(top+bottom)/2;
while(flag)
{
//printf("top=%d, bottom=%d, mid=%d, a[%d]=%d\n",top,bottom,mid,mid,a[mid]);
if( (num>a[top]) || (num<a[bottom]) ) //输野伍入的数 num>a[top] 或者 num<a[bottom]，肯定num不在这个表列中
{
loc=-1;
flag=0;
}
else if(a[mid]==num) //如果num 等于找到的数
{
loc=mid;
printf("找到数颂岩或 %6d 的位置%2d\n",num,loc);
break;
}
else if(a[mid]>num) //若 a[mid]>num，则num 一定在 a[bottom]和a[mid-1]范围之内
{
top=mid-1;
mid=(top+bottom)/2;
}
else if(a[mid]<num) //若 a[mid]<num，则num 一定在 a[mid+1]和a[top]范围之内
{
bottom=mid+1;
mid=(top+bottom)/2;
}
}
if(loc==-1)
{
printf("%d 这个数在表列中没有找到。\n",num);
}
printf("折半查找结束,按任意键退出：\n");
}