课程设计数据

A. 谁有机械设计课程设计的原始数据急急

机械设计课程设计zdd-2-c我给你都搞定。

B. 数据结构课程设计

#include "stdio.h"
#include "time.h"
#define MAXNUM 5 //停车场车位数
#define PRICE 2.0 //每小时收费
typedef struct car //定义车的结构体
{
char num[10]; //车牌号(最多10个字节)
struct tm intime; //进入时间
struct tm outtime; //离开时间
int expense; //费用
int length; //停车时长
int position; //停车位
}CAR;
typedef struct //栈结构
{
CAR car[MAXNUM]; //车辆信息
int top; //栈顶指针
} SeqStack;
void StackInit(SeqStack * s) //初始化栈
{
s->top = -1;
}
int StackIsEmpty(SeqStack * s) //判断栈是否为空
{
if (s->top == -1)
return 1;
else
return 0;
}
int StackIsFull(SeqStack *s) //判断栈是否为满
{
if (s->top == MAXNUM - 1)
return 1;
else
return 0;
}
void StackPush(SeqStack *s, CAR car) // 进栈
{
if (!StackIsFull(s)) //若栈未满
{
s->top++; //修改栈顶指针
s->car[s->top] = car; //将车辆信息入栈
}
}
CAR StackPop(SeqStack *s) //出栈
{
CAR car;
if (s->top != -1) //栈不为空
{
car = s->car[s->top];
s->top--;
return car;
}
}
CAR StackGetTop(SeqStack * s) //取栈顶元素
{
CAR car;
if (s->top != -1)
{
car = s->car[s->top];
return car;
}

}
//队列链表
typedef struct carnode //定义链队列的节点
{
CAR data;
struct carnode *next;
}CarNodeType;
typedef struct //链队列
{
CarNodeType *head; //头指针
CarNodeType *rear; //尾指针
}CarChainQueue;
void ChainQueueInit(CarChainQueue * q) //初始化链队列接点性质
{
if(!(q->head = (CarNodeType *) malloc(sizeof(CarNodeType))))
{
printf("内存分配失败!\n");
exit(0);
}
q->rear = q->head; //头尾指针相同
q->head->next = NULL; //头尾指针后下一个节点为空
q->rear->next = NULL;
}
void ChainQueueIn(CarChainQueue * q, CAR car) //入队列
{
CarNodeType *p;
if(!(p = (CarNodeType *) malloc(sizeof(CarNodeType))))
{
printf("内存分配失败!\n");
exit(0);
}
p->data = car;
p->next = NULL;
q->rear->next = p;
q->rear = p;
}
CAR ChainQueueOut(CarChainQueue * q) //出队列
{
CarNodeType *p;
CAR car;
if (q->head != q->rear)
{
p = q->head->next;
if (p->next == NULL)
{
car = p->data;
q->rear = q->head;
free(p);
} else
{
q->head->next = p->next;
car = p->data;
free(p);
}
return car;
}

}
int ChainQueueIsEmpty(CarChainQueue * q) //判断链队列是否为空
{
if (q->rear == q->head) //若队首等于列尾
return 1; //返回空
else
return 0; //返回非空

}
void separator(int n,char ch,char newline) //输出多个字符
{
int i;
for(i=0;i<n;i++)
printf("%c",ch);
if(newline==1)
printf("\n");
}
void PrintDate(struct tm gm_date)
{
printf("%d/%d %02d:%02d:%02d\n", gm_date.tm_mon,gm_date.tm_mday,gm_date.tm_hour+8, gm_date.tm_min, gm_date.tm_sec);
}
void ShowPark(SeqStack *s) //查看车位状态
{
int i;
struct tm gm_date;
printf("\n车位使用情况\n");
separator(40,'_',1);
if (StackIsEmpty(s)) //若栈是空
printf("停车场内已没有车辆!\n");
else
{
printf("位置\t车牌号\t进站时间\n");
for (i = 0; i <= s->top; i++)
{
printf("%d\t", s->car[i].position);
printf("%s\t", s->car[i].num);
PrintDate(s->car[i].intime); //输出日期
}
printf("\t\t\t共%d辆", s->top + 1);
if (s->top == MAXNUM - 1)
printf("(已满)\n");
else
printf("(还可停放放%d辆)\n", MAXNUM - 1 - s->top);
printf("\n");
}
separator(40,'_',1);
}
void ShowAisle(CarChainQueue * q)//显示过道上车辆的情况
{
if (!ChainQueueIsEmpty(q)) //若队列不为空
{
CarNodeType *p;
p = q->head->next; //队列中的第1辆车
printf("\n\n过道使用情况\n");
separator(30,'_',1);
printf("车牌\t进入时间\n");
while (p!= NULL) //队列不为空
{
printf("%s\t", p->data.num);
PrintDate(p->data.intime);; //显示该辆车的信息
p = p->next; //下一辆
}
} else
printf("\n过道上没有车在等待\n");
separator(30,'_',1);
printf("\n\n");
}
void ShowAll(SeqStack *s, CarChainQueue *q) //查看车位和过道使用情况
{
ShowPark(s); //显示车位使用情况
ShowAisle(q); //显示过道使用情况
}
void InPark(SeqStack * s, CarChainQueue * q) //车辆进入停车场
{
CAR car;
struct tm *gm_date;
time_t seconds;
time(&seconds);
gm_date = gmtime(&seconds);;

printf("\n车牌号:");
scanf("%s",&car.num);
car.intime=*gm_date; //进入停车场的时间

if (!StackIsFull(s) && ChainQueueIsEmpty(q)) //如果车位未占完，且过道上没有车
{
car.position = (s->top) + 2; //车位号
StackPush(s, car); //车辆直接进入车位
ShowPark(s); //输出现在停车场的情况
}
else if (StackIsFull(s) || !ChainQueueIsEmpty(q)) //如果车位已满，过道上还有车，则必须放在过道上
{
printf("提示：车位满,只有先停放在过道中。\n");
car.position = MAXNUM;
ChainQueueIn(q, car); //停放在过道

ShowPark(s); //显示车位的情况
ShowAisle(q); //输出过道上的情况
}
}
void PrintRate(CAR *car) //离开时输出费用等情况
{
printf("\n\n 账单\n" );
separator(30,'_',1);
printf("车牌:%s\n", car->num);
printf("停车位置:%d\n", car->position);
printf("进入时间:");
PrintDate(car->intime);
printf("离开时间:");
PrintDate(car->outtime);
printf("停车时间(秒):%d\n", car->length);
printf("费用(元):%d\n", car->expense);
separator(30,'_',1);
printf("\n\n");
}
void OutPark(SeqStack *s, CarChainQueue *q) //车出站出当时过道上的情况放在过道上直接进入车站
{
struct tm *gm_date;
time_t seconds;

SeqStack p; //申请临时放车的地方
StackInit(&p);
char nowtime[10];
int i, pos;
CAR car;

if (StackIsEmpty(s)) //如果车位中没有车辆停放
{
printf("所有车位都为空，没有车辆需要离开!\n");
}
else
{
printf("现在车位使用情况是:\n");
ShowPark(s); //输出车位使用情况
printf("哪个车位的车辆要离开:");
scanf("%d", &pos);
if (pos > 0 && pos <= s->top + 1) //输入车位号正确
{
for (i = s->top + 1; i > pos; i--) //在将pos车位之后停的车放入临时栈，以使pos车位的车出来
{
car = StackPop(s); //出栈
car.position = car.position - 1;//修改车位号
StackPush(&p, car); //将车辆放入临时栈
}
car = StackPop(s); //将位于pos车位的车辆出栈
time(&seconds);
gm_date = gmtime(&seconds); //获取当前时间
car.outtime=*gm_date;//离开时间
car.length=mktime(&car.outtime)-mktime(&car.intime); //停车场中停放时间
car.expense=(car.length/3600+1)*PRICE; //费用
PrintRate(&car); //输出车出站时的情况---进入时间，出站时间，原来位置，花的费用等
while (!StackIsEmpty(&p)) //将临时栈中的车重新进入车位
{
car = StackPop(&p); //从临时栈中取出一辆车
StackPush(s, car); //将车进入车位
}
while(!StackIsFull(s) && !ChainQueueIsEmpty(q)) //如果车位未满, 且过道上还有车
{
car = ChainQueueOut(q); //将最先停在过道中的车辆进入车位
time(&seconds);
gm_date = gmtime(&seconds); //获取当前时间
car.intime = *gm_date;//保存进入车位的时间
StackPush(s, car); //将车辆进入车位
}
}
else //车位号输入错误
{
printf("车位号输入错误，或该车位没有车辆!\n");
}
}
}
int main()
{
SeqStack Park; //停车场栈
CarChainQueue Aisle; //过道链表
StackInit(&Park);
ChainQueueInit(&Aisle);
char choice;
do{
printf("\n\n");
separator(10,' ',0);
printf("停车场管理\n");
separator(30,'_',1);
printf("1.车辆进入\n");
printf("2.车辆离开\n");
printf("3.查看停车场情况\n");
printf("0.退出系统\n");
separator(56,'_',1);
printf("提示：本停车场有%d个车位，车位停满后的车辆将停放在过道上。\n",MAXNUM);
printf("本停车场时计费，收费标准:%.2f元/小时,过道上不收费。\n\n",PRICE);
printf("\n选择操作(0~3):");
fflush(stdin);
choice=getchar();
switch (choice)
{
case '1': //车辆进入
InPark(&Park,&Aisle);
break;
case '2': //车辆离开
OutPark(&Park,&Aisle);
break;
case '3':
ShowAll(&Park,&Aisle);
break;
}
}while(choice!='0');
return 0;
}

C. 课程设计数据不一样画出的图差别在哪

论文常被用来进行科学研究和描述科研成果的文章。它既是探讨问题进行科学研究的一种手段，又是描述科研成果进行学术交流的一种工具。
论文格式封面论文常指用来进行科学研究和描述科研成果的文章。它既是探讨问题进行科学研究的一种手段，又是描述科研成果进行学术交流的一种工具。它包括学年论文、毕业论文、学位论文、科技论文、成果论文等，总称为论文[1]。论文格式就是指进行论文写作时的样式要求，以及写作标准。直观的说，论文格式就是论文达到可公之于众的标准样式和内容要求。
结构
论文一般由题名、作者、摘要、关键词、正文、参考文献和附录等部分组成，其中部分组成(例如附录)可有可无。论文各组成的排序为：题名、作者、摘要、关键词、英文题名、英文摘要、英文关键词、正文、参考文献、附录和致谢[2]。
题目
1.题名规范
题名应简明、具体、确切，能概括论文的特定内容，有助于选定关键词，符合编制题录、索引和检索的有关原则。
2.命题方式
简明扼要，提纲挈领。
3.英文题名方法
①英文题名以短语为主要形式，尤以名词短语最常见，即题名基本上由一个或几个名词加上其前置和(或)后置定语构成;短语型题名要确定好中心词，再进行前后修饰。各个词的顺序很重要，词序不当，会导致表达不准。
②一般不要用陈述句，因为题名主要起标示作用，而陈述句容易使题名具有判断式的语义，且不够精炼和醒目。少数情况(评述性、综述性和驳斥性)下可以用疑问句做题名，因为疑问句有探讨性语气，易引起读者兴趣。
③同一篇论文的英文题名与中文题名内容上应一致，但不等于说词语要一一对应。在许多情况下，个别非实质性的词可以省略或变动。
④国外科技期刊一般对题名字数有所限制，有的规定题名不超过2行，每行不超过42个印刷符号和空格;有的要求题名不超过14个词。这些规定可供我们参考。
⑤在论文的英文题名中。凡可用可不用的冠词均不用。

D. 大数据能做什么简单的课程设计

大数据（big data），指无法在一定时间范围内用常规软件工具进行捕捉、管理和处理的数据集合，是需要新处理模式才能具有更强的决策力、洞察发现力和流程优化能力的海量、高增长率和多样化的信息资产。大数据的5V特点（IBM提出）：Volume（大量）、Velocity（高速）、Variety（多样）、Value（低价值密度）、Veracity（真实性）,平台有hadoop

E. 数据结构课程设计的需求分析怎么写

一 需求分析：
在该部分中根据设计题目的要求，充分地分析和理解问题，叙述系统的功能要求，明确问题要求做什么？以及限制条件是什么？
1．1问题描述
1．2基本要求
(1) 输入的形式和输入值的范围；
(2) 输出的形式；
(3) 程序所能达到的功能；

二 概要设计
说明本程序中用到的所有抽象数据类型的定义。主程序的流程以及各程序模块之间的层次(调用)关系。
1、 数据结构
2、 程序模块
3、各模块之间的调用关系以及算法设计
三 详细设计
实现概要设计中定义的所有数据类型,对每个操作写出伪码算法;对主程序和其他模块也都需要写出伪码算法(伪码算法达到的详细程度建议为:按照伪码算法可以在计算机键盘直接输入高级程序设计语言程序);写出出函数和过程的调用关系.
四 测试与分析
测试数据，输出测试的结果，这里的测试数据应该完整和严格。并对结果进行分析。
五 总结
总结可以包括 : 课程设计过程的收获、遇到问题、遇到问题解决问题过程的思考、程序调试能力的思考、对数据结构这门课程的思考、在课程设计过程中对《数据结构》课程的认识等内容。

F. 机械设计课程设计

设计目的：
通过本课程设计将学过的基础理论知识进行综合应用，培养结构设计，计算能力，熟悉一般的机械装置设计过程。
(二)
传动方案的分析
机器一般是由原动机、传动装置和工作装置组成。传动装置是用来传递原动机的运动和动力、变换其运动形式以满足工作装置的需要，是机器的重要组成部分。传动装置是否合理将直接影响机器的工作性能、重量和成本。合理的传动方案除满足工作装置的功能外，还要求结构简单、制造方便、成本低廉、传动效率高和使用维护方便。
本设计中原动机为电动机，工作机为皮带输送机。传动方案采用了两级传动，第一级传动为带传动，第二级传动为单级直齿圆柱齿轮减速器。
带传动承载能力较低，在传递相同转矩时，结构尺寸较其他形式大，但有过载保护的优点，还可缓和冲击和振动，故布置在传动的高速级，以降低传递的转矩，减小带传动的结构尺寸。
齿轮传动的传动效率高，适用的功率和速度范围广，使用寿命较长，是现代机器中应用最为广泛的机构之一。本设计采用的是单级直齿轮传动。
减速器的箱体采用水平剖分式结构，用HT200灰铸铁铸造而成。
二、传动系统的参数设计
原始数据：运输带的工作拉力F=0.2 KN；带速V=2.0m/s；滚筒直径D=400mm（滚筒效率为0.96）。
工作条件：预定使用寿命8年，工作为二班工作制，载荷轻。
工作环境：室内灰尘较大，环境最高温度35°。
动力来源：电力，三相交流380/220伏。
1
、电动机选择
（1）、电动机类型的选择： Y系列三相异步电动机
（2）、电动机功率选择：
①传动装置的总效率：
=0.98×0.99 ×0.96×0.99×0.96
②工作机所需的输入功率：
因为 F=0.2 KN=0.2 KN= 1908N
=FV/1000η
=1908×2/1000×0.96
=3.975KW
③电动机的输出功率：
=3.975/0.87=4.488KW
使电动机的额定功率P ＝（1～1.3）P ，由查表得电动机的额定功率P ＝ 5.5KW 。
⑶、确定电动机转速：
计算滚筒工作转速：
=（60×v）/（2π×D/2）
=（60×2）/（2π×0.2）
=96r/min
由推荐的传动比合理范围，取圆柱齿轮传动一级减速器传动比范围I’ =3~6。取V带传动比I’ =2~4，则总传动比理时范围为I’ =6~24。故电动机转速的可选范围为n’ =（6~24）×96=576~2304r/min
⑷、确定电动机型号
根据以上计算在这个范围内电动机的同步转速有1000r/min和1500r/min，综合考虑电动机和传动装置的情况，同时也要降低电动机的重量和成本，最终可确定同步转速为1500r/min ，根据所需的额定功率及同步转速确定电动机的型号为Y132S-4 ，满载转速 1440r/min 。
其主要性能：额定功率：5.5KW，满载转速1440r/min，额定转矩2.2，质量68kg。
2
、计算总传动比及分配各级的传动比
（1）、总传动比：i =1440/96=15
（2）、分配各级传动比：
根据指导书，取齿轮i =5（单级减速器i=3~6合理）
=15/5=3
3
、运动参数及动力参数计算
⑴、计算各轴转速（r/min）
=960r/min
=1440/3=480(r/min)
=480/5=96(r/min)
⑵计算各轴的功率（KW）
电动机的额定功率Pm=5.5KW
所以
P =5.5×0.98×0.99=4.354KW
=4.354×0.99×0.96 =4.138KW
=4.138×0.99×0.99=4.056KW
⑶计算各轴扭矩（N?mm）
TI=9550×PI/nI=9550×4.354/480=86.63N?m
=9550×4.138/96 =411.645N?m
=9550×4.056/96 =403.486N?m
三、传动零件的设计计算
（一）齿轮传动的设计计算
（1）选择齿轮材料及精度等级
考虑减速器传递功率不大，所以齿轮采用软齿面。小齿轮选用40Cr调质，齿面硬度为240~260HBS。大齿轮选用45#钢，调质，齿面硬度220HBS；根据指导书选7级精度。齿面精糙度R ≤1.6~3.2μm
（2）确定有关参数和系数如下：
传动比i
取小齿轮齿数Z =20。则大齿轮齿数：
=5×20=100
，所以取Z
实际传动比
i =101/20=5.05
传动比误差：（i -i）/I=（5.05-5）/5=1%<2.5% 可用
齿数比：
u=i
取模数：m=3 ；齿顶高系数h =1；径向间隙系数c =0.25；压力角 =20°；
则
h *m=3，h ）m=3.75
h=（2 h ）m=6.75，c= c
分度圆直径：d =×20mm=60mm
d =3×101mm=303mm
由指导书取
φ
齿宽：
b=φ =0.9×60mm=54mm
=60mm ，
b
齿顶圆直径：d ）=66，
d
齿根圆直径：d ）=52.5，
d ）=295.5
基圆直径：
d cos =56.38，
d cos =284.73
(3)计算齿轮传动的中心矩a：
a=m/2(Z )=3/2(20+101)=181.5mm 液压绞车≈182mm
（二）轴的设计计算
1
、输入轴的设计计算
⑴、按扭矩初算轴径
选用45#调质，硬度217~255HBS
根据指导书并查表，取c=110
所以 d≥110 (4.354/480) 1/3mm=22.941mm
d=22.941×(1+5%)mm=24.08mm
∴选d=25mm
⑵、轴的结构设计
①轴上零件的定位，固定和装配
单级减速器中可将齿轮安排在箱体中央，相对两轴承对称分布，齿轮左面由轴肩定位，右面用套筒轴向固定，联接以平键作过渡配合固定，两轴承分别以轴肩和大筒定位，则采用过渡配合固定
②确定轴各段直径和长度
Ⅰ段：d =25mm
， L =（1.5～3）d ，所以长度取L
∵h=2c
c=1.5mm
+2h=25+2×2×1.5=31mm
考虑齿轮端面和箱体内壁，轴承端面和箱体内壁应有一定距离。取套筒长为20mm，通过密封盖轴段长应根据密封盖的宽度，并考虑联轴器和箱体外壁应有一定矩离而定，为此，取该段长为55mm，安装齿轮段长度应比轮毂宽度小2mm,故II段长：
L =（2+20+55）=77mm
III段直径：
初选用30207型角接触球轴承，其内径d为35mm,外径D为72mm，宽度T为18.25mm.
=d=35mm，L =T=18.25mm，取L
Ⅳ段直径：
由手册得：c=1.5
h=2c=2×1.5=3mm
此段左面的滚动轴承的定位轴肩考虑，应便于轴承的拆卸，应按标准查取由手册得安装尺寸h=3.该段直径应取：d =（35+3×2）=41mm
因此将Ⅳ段设计成阶梯形，左段直径为41mm
+2h=35+2×3=41mm
长度与右面的套筒相同，即L
Ⅴ段直径：d =50mm. ，长度L =60mm
取L
由上述轴各段长度可算得轴支承跨距L=80mm
Ⅵ段直径：d =41mm， L
Ⅶ段直径：d =35mm， L ＜L3，取L
2
、输出轴的设计计算
⑴、按扭矩初算轴径
选用45#调质钢，硬度（217~255HBS）
根据课本P235页式（10-2），表（10-2）取c=110
=110× (2.168/76.4) =38.57mm
考虑有键槽，将直径增大5%，则
d=38.57×(1+5%)mm=40.4985mm
∴取d=42mm
⑵、轴的结构设计
①轴的零件定位，固定和装配
单级减速器中，可以将齿轮安排在箱体中央，相对两轴承对称分布，齿轮左面用轴肩定位，右面用套筒轴向定位，周向定位采用键和过渡配合，两轴承分别以轴承肩和套筒定位，周向定位则用过渡配合或过盈配合，轴呈阶状，左轴承从左面装入，齿轮套筒，右轴承和皮带轮依次从右面装入。
②确定轴的各段直径和长度
初选30211型角接球轴承，其内径d为55mm，外径D=100mm，宽度T为22.755mm。考虑齿轮端面和箱体内壁，轴承端面与箱体内壁应有一定矩离，则取套筒长为20mm，则该段长42.755mm，安装齿轮段长度为轮毂宽度为2mm。
则
d =42mm
L
= 50mm
L
= 55mm
L
= 60mm
L
= 68mm
L
=55mm
L
四、滚动轴承的选择
1
、计算输入轴承
选用30207型角接触球轴承，其内径d为35mm,外径D为72mm，宽度T为18.25mm.
2
、计算输出轴承
选30211型角接球轴承，其内径d为55mm，外径D=100mm，宽度T为22.755mm
五、键联接的选择
1
、输出轴与带轮联接采用平键联接
键的类型及其尺寸选择：
带轮传动要求带轮与轴的对中性好，故选择C型平键联接。
根据轴径d =42mm ，L =65mm
查手册得，选用C型平键，得： 卷扬机
装配图中22号零件选用GB1096-79系列的键12×56
则查得：键宽b=12，键高h=8，因轴长L ＝65，故取键长L=56
2
、输出轴与齿轮联接用平键联接
=60mm,L
查手册得，选用C型平键，得：
装配图中 赫格隆36号零件选用GB1096-79系列的键18×45
则查得：键宽b=18，键高h=11，因轴长L ＝53，故取键长L=45
3
、输入轴与带轮联接采用平键联接
=25mm
L
查手册
选A型平键，得：
装配图中29号零件选用GB1096-79系列的键8×50
则查得：键宽b=8，键高h=7，因轴长L ＝62，故取键长L=50
4
、输出轴与齿轮联接用平键联接
=50mm
L
查手册
选A型平键，得：
装配图中26号零件选用GB1096-79系列的键14×49
则查得：键宽b=14，键高h=9，因轴长L ＝60，故取键长L=49
六、箱体、箱盖主要尺寸计算
箱体采用水平剖分式结构，采用HT200灰铸铁铸造而成。箱体主要尺寸计算如下：
七、轴承端盖
主要尺寸计算
轴承端盖：HT150 d3=8
n=6 b=10
八、减速器的
减速器的附件的设计
1
、挡圈 ：GB886-86
查得：内径d=55，外径D=65，挡圈厚H=5，右肩轴直径D1≥58
2
、油标 ：M12：d =6，h=28，a=10,b=6，c=4，D=20，D
3
、角螺塞
M18
×
1.5 ：JB/ZQ4450-86
九、
设计参考资料目录
希望对你能有所帮助。

G. C语言课程设计:文件数据的处理

给的分太少拉！不过我还是帮你写好了，你觉得好就给哥哥我多顶几下！

首先 两个文件：data1.txt和data2.txt 要先在当前代码目录建好，里面写相应数据进去。然后运行程序即可。

详细代码如下：（VC++ 6.0下编译通过）

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAX_BUF 1024
#define MAX_NUM 100
#define FILE1 "data1.txt"
#define FILE2 "data2.txt"
#define FILE3 "jiao.txt"
#define FILE4 "bing.txt"
#define YES 1
#define NO 0
void GetDataFromFile(int *data, char *FileName, int *DataNum)
{
int i = 0;
FILE *fp = NULL;
char buf[MAX_BUF] = {0};
char *sep = " ";
char *token = NULL;
fp = fopen(FileName, "r");
if (fp == NULL)
{
printf("Cann't open the file!\n");
exit(1);
}
while (!feof(fp))
{
fgets(buf, MAX_BUF, fp);
}
fclose(fp);
token = strtok(buf, sep);
while (token != NULL)
{
data[i] = atoi(token);
token = strtok(NULL, sep);
i++;
}
*DataNum = i;
}
int IsXInArray(int *data, int DataNum, int x)
{
int i;
for (i = 0; i < DataNum; i++)
{
if ( *(data+i) == x )
return YES;
}
return NO;
}
void Intersection(int *data1, int DataNum1,
int *data2, int DataNum2,
int *result, int *ResultNum)
{
int i, j, k = 0;
for (i = 0; i < DataNum1; i++)
{
for (j = 0; j < DataNum2; j++)
{
if ( *(data1+i) == *(data2+j)
&& IsXInArray(result, k, *(data1+i) ) == NO)
{
*(result+k) = *(data1+i);
k++;
}
}
}
*ResultNum = k;
}
void Union(int *data1, int DataNum1,
int *data2, int DataNum2,
int *result, int *ResultNum)
{
int i, j, k = 0;
for (i = 0; i < DataNum1; i++)
{
if (IsXInArray(result, k, *(data1+i) ) == NO)
{
*(result+k) = *(data1+i);
k++;
}
}
for (j = 0; j < DataNum2; j++)
{
if (IsXInArray(result, k, *(data2+j) ) == NO)
{
*(result+k) = *(data2+j);
k++;
}
}
*ResultNum = k;
}
void BubbleSort(int *data, int num)
{
int i,j;
int tmp = 0;
for (i = num-1; i >= 0; i--)
{
for (j = 0; j < i; j++)
{
if ( *(data+j) > *(data+j+1) )
{
tmp = *(data+j);
*(data+j) = *(data+j+1);
*(data+j+1) = tmp;
}
}
}
}
void WriteToFile(int *data, int DataNum, char *FileName)
{
int i;
FILE *fp = NULL;
fp = fopen(FileName, "w");
if (fp == NULL)
{
printf("Cann't open the file!\n");
exit(1);
}
for (i = 0; i < DataNum; i++)
{
fprintf(fp, "%d ", *(data+i));
}
fclose(fp);
}
int main(void)
{
int i = 0;
int DataNum1 = 0, DataNum2 = 0;
int IntersResultNum = 0, UnionResultNum = 0;
int data1[MAX_NUM] = {0};
int data2[MAX_NUM] = {0};
int IntersectionResult[MAX_NUM] = {0};
int UnionResult[MAX_NUM*2] = {0};

GetDataFromFile(data1, FILE1, &DataNum1);
GetDataFromFile(data2, FILE2, &DataNum2);

Intersection(data1, DataNum1, data2, DataNum2, IntersectionResult, &IntersResultNum);
BubbleSort(IntersectionResult, IntersResultNum);
WriteToFile(IntersectionResult, IntersResultNum, FILE3);

Union(data1, DataNum1, data2, DataNum2, UnionResult, &UnionResultNum);
BubbleSort(UnionResult, UnionResultNum);
WriteToFile(UnionResult, UnionResultNum, FILE4);

printf("\n所有操作执行完毕!\n");
return 0;
}

H. 数据库（含课程设计）

超市管理数据库
你的人要求不少啊
来，帮你吧。

I. 急求，数据分析的课程设计说明书

我还可以给!

J. 数据结构课程设计

#include <stdio.h>
#include <malloc.h>
#include <windows.h>
#include <time.h>
#define MAXSIZE 100

typedef struct Ttime{
int t_hour;
int t_min;
int t_sec;
}Ttime;

typedef struct Mcar{
int number;
Ttime t[2];
}Mcar;

typedef struct{
Mcar elements[MAXSIZE];
int top;
}CarStop;

typedef struct node{
Mcar date;
struct node *next;
}LinkQueue;

typedef struct{
LinkQueue *front;
LinkQueue *rear;
}Queue;

void InitQueue(Queue *Q){
Q -> front = (LinkQueue *) malloc(sizeof(LinkQueue));
Q -> front -> next = NULL;
Q -> rear = Q -> front;
}

int IsEmptyH(Queue Q){
if(Q.front == Q.rear)
return 1;
else
return 0;
}

void EeQueue(Queue *Q, Mcar x){
Q -> rear -> next = (LinkQueue *)malloc(sizeof(LinkQueue));
Q -> rear = Q -> rear -> next;
Q -> rear -> date = x;
Q -> rear -> next = NULL;
}

Mcar DeQueue(Queue *Q){
LinkQueue *p;
Mcar y;
if(!(*Q)){
p = Q -> front -> next;
Q -> front -> next = p -> next;
if(p -> next == NULL)
Q -> rear = Q -> front;
y = p -> date;
free(p);
return y;
}
}

int IsEmpty(CarStop S){
if(S.top == 0)
return 1;
else
return 0;
}

int IsFull(CarStop S){
if(S.top == MAXSIZE)
return 1;
else
return 0;
}

int Init(CarStop *S){
S -> top = 0;
}

void PutIn(CarStop *S, Mcar D){
if(!IsFull(*S)){
S -> elements[S -> top] = D;
S -> top++;
}
else
printf("IS FULL");
}

Mcar Pop(CarStop *S){
if(!IsEmpty(*S)){
S -> top--;
return S -> elements[S -> top];
}
else
printf("IS NULL");
}

Mcar TopNum(CarStop S){
if(!IsEmpty(S)){
return S.elements[S.top - 1];
}
}

int serachOneCar(CarStop S, Mcar num){
int i = 0;
if(!IsEmpty(S)){
while(i <= S.top){
if(num.number == S.elements[i].number)
return 1;
i++;
}
}
else
return 0;
}

void getInOneCar(CarStop *CarStack, Queue *Q, Mcar car){

time_t secnow;
struct tm * tmptr;
time(&secnow);
tmptr = localtime(&secnow);

car.t[0].t_hour= tmptr -> tm_hour;
car.t[0].t_min = tmptr -> tm_min;
car.t[0].t_sec = tmptr -> tm_sec;

printf("please put in you car number:\n");
scanf("%d", &car.number);
if(!IsFull(*CarStack))
PutIn(CarStack, car);
else{
printf("car stop is full, please stay in bian\n");
EeQueue(Q, car);
}
printf("you car's intime is :[%d]:[%d]:[%d]\n\n\n", car.t[0].t_hour, car.t[0].t_min, car.t[0].t_sec);
}

void getOutOneCar(CarStop *CarStack, CarStop *CarStackL, Queue *Q, Mcar car){
Mcar lin;

time_t secnow;
struct tm * tmptr;
time(&secnow);
tmptr = localtime(&secnow);

car.t[1].t_hour= tmptr -> tm_hour;
car.t[1].t_min = tmptr -> tm_min;
car.t[1].t_sec = tmptr -> tm_sec;

printf("please put in you car number:\n");
scanf("%d", &car.number);
if(IsEmpty(*CarStack) || !serachOneCar(*CarStack, car))
printf("soory, there is no the car\n");
else{
while(1){
lin = Pop(CarStack);
if(lin.number == car.number)
break;
else
PutIn(CarStackL, lin);
}
while(!IsEmpty(*CarStackL)){
PutIn(CarStack, Pop(CarStackL));
}
if(!IsEmptyH(*Q))
PutIn(CarStack, DeQueue(Q));
printf("\n\nyou car's intime is :[%d]:[%d]:[%d]\n", lin.t[0].t_hour, lin.t[0].t_min, lin.t[0].t_sec);
printf("you car's out time is :[%d]:[%d]:[%d]\n", car.t[1].t_hour, car.t[1].t_min, car.t[1].t_sec);

int alltime = (car.t[1].t_hour - lin.t[0].t_hour) * 3600 + (car.t[1].t_min - lin.t[0].t_min) * 60 + (car.t[1].t_sec - lin.t[0].t_sec);
printf("you car's all time is second:[%d]\n", alltime);
}
}

int main(){
CarStop CarStack, CarStackL;
Queue Q;
LinkQueue *pp;
InitQueue(&Q);
Init(&CarStack);
Init(&CarStackL);
Mcar car;
//String caozuo;
int caozuo, i, j;
while(1){
printf("\t**************the car stop menu*************\n");
printf("\t\t***** 1. get in a car\n\n");
printf("\t\t***** 2. get out a car\n\n");
printf("\t\t***** 0. out the car stop\n\n");
printf("\t\t*****put in the else you can see all the car in the carstop\n\n");
printf("\t*****************************************\n");
printf("please put in you caozuo: \n");
scanf("%d", &caozuo);
switch(caozuo){
case 1: getInOneCar(&CarStack, &Q, car);
break;
case 2: getOutOneCar(&CarStack, &CarStackL, &Q, car);
break;
case 0: return 0; break;
default : break;
}
if(!IsEmpty(CarStack)){
i = 0;
printf("the all car is:\n");
while(i < CarStack.top){
printf("the [%d] is %d\n",i + 1, CarStack.elements[i].number);
i++;
}
}
else
printf("the car stop IS NULL\n");
printf("****************************\n");
if(!IsEmptyH(Q)){
j = 1;
pp=Q.front;
printf("the bian's car is:\n");
while(pp!=Q.rear){
printf("the [%d] wait car is %d\n", j, pp -> next -> date.number);
pp = pp -> next;
j++;
}
}
else
printf("the bian is NULL\n");
printf("****************************\n");
system("pause");
system("cls");
}
}

C语言编译通过