第三个1000行

/*
Author:MrBread
Introduction:Aim to improve my programming ability and record my codes.
Start date:Feb 13th,2017
*/
#include<stdio.h>
#include<math.h>
#include<time.h>
#include<string.h>
#include<stdlib.h>
#include<conio.h>
#include<dos.h>
#include<dir.h>
//include<bios.h>   Turbo C使用

//使用ceil(i)函数可以获得不小于i的最小整数
//函数原型：double ceil(double num)

/*
//显示程序运行时间
void main()
{
    time_t start,end;
    start=time(NULL);
    _sleep(10000);
    end=time(NULL);
    printf("runtime is:%f(s)\n",difftime(end,start));
}
*/

/*有问题 出现Storage size of ‘d’ isn't known,可能原因是因为date和time结构体定义出现问题
//显示当前日期及时间
void main()
{
    struct date d;
    struct time t;
    getdate(&d);
    gettime(&t);
    printf("The current day is:%d--%d--%d\n",d.da_year,d.da_mon,d.da_day);
    printf("The current time is:%d:%d:%d\n",t.ti_hour,t.ti_min,t.ti_sec);
}
*/
/*
//设置dos系统日期 Turbo C 下使用
void main()
{
    struct date setd,now;
    struct date,origind;
    getdate(&origind);
    printf("original date is :%d--%d--%d\n",origind.da_year,origind.da_mon,origind.da_day);
    setd.da_year=2008;
    setd.da_mon=10;
    setd.da_day=23;
    setdate(&setd);
    getdate(&now);
    printf(" date after setting is :%d--%d--%d\n",now.da_year,now.da_mon,now.da_day);
    getch();
}

*/

/*
//读取并设置BIOS的时钟
void main()
{
    long origin,new;
    origin=biostime(0,0);
    printf("The current time is %ld\n",origin);
    new=biostime(1,500);      //设置BIOS时钟
    printf("The new time is %ld\n",new);
}
//long biostime(int cmd,long mewtime)该函数的作用是读取或设置BIOS时钟，如果cmd为0，biostime（）函数
//返回该时钟的当前值；如果cmd为1，biostime()函数把时钟设置为newtime的值，其原型在bios.h中
//BIOS的时钟以每秒约18.2次的脉冲速率运行。它的值在午夜12点时为0，随时间不断增长，直到
//午夜又被设置为0，或者被人为地设置成某个值
*/
/*

//任意大写字母变小写
void main()
{
    char str[50];
    printf("Please input string:\n");
    gets(str);
    strlwr(str);
    puts(str);
    printf("\n");
}
*/
/*
//字符串复制到指定空间
void main()
{
    char str1[30],str2[30],*p1,*p2;
    printf("please input string1:\n");
    gets(str1);
    printf("please input string2:\n");
    gets(str2);
    p1=strdup(str1);
    p2=strdup(str2);
    printf("string1:%s\nstring2:%s",p1,p2);
    printf("\n");
}
//char* strdup(char *str)该函数的作用有两个：第一，按字符串str的长度在内存中分配出空间；第二，将str的内容复制到该空间中。该函数返回指向该存放区域的指针
*/
/*
//查找位置信息
//从键盘中输入str1和str2，查找str1字符串中第一个不属于str2字符串中字符的位置，并将该位置输出；
//再从键盘中输入str3和str4，查找在str3中是否包含str4，无论包含与否都给出提示信息
void main()
{
    char str1[30],str2[30],str3[30],str4[30];
    char *p;
    int pos;
    printf("please input string1:");
    gets(str1);
    printf("please input string2:");
    gets(str2);
    pos=strspn(str1,str2);    //调用函数找出不同的位置
    //char* strspn(char *str1,char *str2)该函数的作用是his在str1中寻找第一个不属于str2字符串
    //中字符的位置。该函数返回str1中第一个与str2人一个字符不相匹配的字符下标。
    printf("The position you want to find is:%d\n",pos);
    printf("please input string3:");
    gets(str3);
    printf("please input string4:");
    gets(str4);
    p=strstr(str3,str4);//查看str3中是否包含str4
    if(p)
    {
        printf("str3 include str4\n");
    }
    else
    {
        printf("can not find str4 in str3!\n");
    }

}
*/
/*
//复制当前目录
//将当前的工作目录复制到数组cdir中并在屏幕上输出
void main()
{
    char cdir[MAXDIR];
    strcpy(cdir,"c:\\");
    cdir[0]='A'+getdisk();
    if(getcurdir(0,cdir+3))   //将当前目录复制到cdir+3开始的数组中
    {
        printf("error\n");
        exit(1);
    }
    printf("The current directory is: %s\n",cdir);
}
//int getdisk(void)函数作用是返回当前驱动器名的代码。驱动器A为0,驱动器B为1,依次类推
//int getcurdir(int driver,char *dir)函数的作用是把driver所指定的当前工作目录复制到由dir所指向的字符串中
//若driver为0，则指的是默认驱动器，驱动器A用1，驱动器B用2，依此类推
*/
/*
//产生唯一文件
//编程实现在当前目录中产生一个唯一的文件
void main()
{
    char *filename="mingriXXXXXX",*p;   //为filename赋值
    p=mktemp(filename);//该函数的作用是产生一个唯一的文件名，并且把它复制到由filename所指向的字符串中。当调用
    //mktemp()函数时，由filename所指向的字符串必须包含以空为结束符的6个X，该函数把这个字符串转换为唯一的文件名，但未建立文件。
    //如果成功，mktemp()函数返回指向filename的指针，否则返回空。
    printf("%s\n",p);
}
//在codeblocks下运行出错没有显示结果
*/


//不同亮度显示
//调用highvideo(),lowvideo(),normvideo()函数使字符以不同亮度显示
//原型在conio.h中


//字母检测
//从键盘中任意输入一个字母或数字或其他字符，编程实现当输入字母时提示"输入的是字母"，否则提示
//”输入的不是字母“
//isalpha()函数检测输入的是否是字母，原型在ctype.h中

/*
//建立目录
void main()
{
    if(!mkdir("temp"))        //调用函数以temp为路径名建立一个目录
        //int mkdir(char *path)函数的作用是由path所指向的路径名建立一个目录，该函数如果
        //成功，则返回0，否则返回-1
        printf("directory temp is created\n");
    else
    {
        printf("unable to create new directory\n");
        exit(1);
    }
}
*/
/*
//删除目录
void main()
{
    char *name[10];
    printf("please input directory name；\n");
    scanf("%s",name);
    printf("Press any key,and the directory will be removed\n");
    getch();
    if(!rmdir(name))   //删除时目录必须是空的，必须不是当前工作目录，也不能是根目录
        printf("Directory is removed.\n");
    else
        printf("can not remove");
}
*/


//qsort()函数实现升序和降序排列
/*
//设置组合键
//编程实现检测Ctrl+Break的当前状态，并设置Ctrl+Break状态显示在屏幕上

void main()
{
    printf("\nThe status of Ctrl+Break %s",(getcbrk())?"On":"Off");  //检测当前Ctrl+Break状态
    printf("press any key to see the status of Ctrl+Break:");
    getch();
    setcbrk(1);
    printf("\nThe status of Ctrl+Break %s",(getcbrk())?"On":"Off");
    printf("press any key to see the status of Ctrl+Break:");
    getch();
    setcbrk(0);
    printf("\nThe status of Ctrl+Break %s",(getcbrk())?"On":"Off");
}
//int getcbrk(void)函数作用是检测Ctrl+Break是关闭还是打开，当关闭时函数返回0,当打开时函数返回1
//int setcbrk(int cbrkvalue)函数作用是设置Ctrl+Break的检测状态为On或Off.若cbrkvalue=0，则检测状态为off
//若cbrkvalue=1,则检测状态设置为On。
*/

/*
//获取当前日期和时间
void main()
{
    time_t now;
    time(&now);
    printf("\nNow is: %s",ctime(&now));
}
*/

/*
//获取当地日期和时间
void main()
{
    struct tm *tmpointer;
    time_t secs;
    time(&secs);
    tmpointer=localtime(&secs);
    //输出本地时间
    printf("Now:%d-%d-%d %d:%d:%d\n",tmpointer->tm_mon,tmpointer->tm_mday,
tmpointer->tm_year+1900,tmpointer->tm_hour,tmpointer->tm_min,tmpointer->tm_sec);

}
*/


/*
//获取格林尼治平时
void main()
{
    struct tm *gmtp;
    time_t secs;
    time(&secs);
    gmtp=gmtime(&secs);
    printf("Greenwich time:%d-%d-%d %d:%d:%d\n",gmtp->tm_mon,
gmtp->tm_mday,gmtp->tm_year+1900,gmtp->tm_hour,gmtp->tm_min,gmtp->tm_sec);
}
*/

//设置系统日期
/*
void main()
{
    char *str;
    struct date setdt;
    getdate(&setdt);  //获取当前系统日期
    printf("\nSystem date %02d-%02d-%04d",setdt.da_mon,setdt.da_day,setdt.da_year);
    printf("\n\nPlease set year:");
    gets(str);
    setdt.da_year=atol(str);
    printf("\nPlease set month:");
    gets(str);
    setdt.da_mon=atol(str);
    printf("\nPlease set day:");
    gets(str);
    setdt.da_day=atol(str);
    setdate(&setdt);
    getdate(&setdt);  //获取当前系统日期
    printf("\nSystem date %02d-%02d-%04d",setdt.da_mon,setdt.da_day,setdt.da_year);
}
*/


//获取BIOS常规内存常量
//计算机的地址空间为1MB，其中低端640KB用作RAM,供DOS及应用程序使用。低端的640KB成为常规内存，
//int biosmemory()函数作用是返回常规内存大小，以KB为单位


/*
//读/写BIOS计时器 Turbo c #include<bios.h>
void main()
{
    long ticks;
    char *str;
    ticks=biostime(0,ticks);       //获取BIOS计时器数值
    printf("\nTicks since midnight %ld\n",ticks);
    getch();
    printf("\nPlease input the numbers of ticks \n");
    gets(str);
    ticks=biostime(1,atol(str));     //将字符串转换为整数并设置BIOS计时器数值
    printf("\nTicks since midnight %ld\n",ticks);  //输出BIOS计时器数值
}
//int biostime(int cmd,long newtime);函数作用是计时器控制，cmd为功能号，其值为0时
//函数返回计时器的当前值；为1时，将计时器设为新值newtime
*/

/*
//获取CMOS密码
//CMOS是计算机主板上的一块可读写的RAM芯片，主要用来保存当前系统的硬件配置，为了防止他人随意更改硬件设置
//需要为CMOS设置密码。当计算机使用者将密码遗忘时，为了保全当前的硬件配置信息就不能金习惯
//清空CMOS的操作，而需要使用应用程序获取CMOS的密码。本实例介绍获取AWARD公司BIOS 的CMOS密码的办法
void main()
{
    int n;
    char comspass;
    char temp=0;
    int result;
    printf("\nThis program only is tested at win98 and award bios!!\n");
    printf("The password of the cmos is:");
    outportb(0x70,0x1d);        //在0x70地址写入字节0x1d
    comspass=importb(0x71);
    for(n=6;n>=0;n-=2)
    {
        temp=comspass;     //记录0x71地址的字节内容
        temp>>=n;
        temp=temp&0x03;   //与0x0x与运算
        printf("%d",temp);  //以四进制形式输出0x1d地址处的数据
    }

    outport(0x70,0x1c);
    result=importb(0x71);
    for(n=6;n>=0;n-=2)
    {
        temp=comspass;     //记录0x71地址的字节内容
        temp>>=n;
        temp=temp&0x03;   //与0x0x与运算
        printf("%d",temp);  //以四进制形式输出0x1c地址处的数据
    }
}
//AWARD公司BIOS的CMOS密码存放在CMOS芯片0x1c,0x1d处的两个字节中，将这两个字节的数据
//读取出来并用四进制表示，就是密码。读取0x1c,0x1d处的两个字节数据需要”字节写入指定的输出端口“
//”从指定的输入端口读取字节“两个步骤



//获取Ctrl+Break消息
//在一般状态下，DOS程序运行时按Ctrl+Break组合键后可以终止撑血进行。当运行中的程序收到Ctrl+break
//消息后可以执行相应的操作



//鼠标中断
//鼠标的作用是为了使计算机的操作更加简单快捷，代替键盘繁琐的指令。在DOS程序的开发过程中，如果要求应用程序可以使用鼠标进行
//相关的操作，那么久需要设置鼠标中断。本实例通过设置鼠标中断，实现或隐藏鼠标的功能
void main()
{
    union REGS regs;    //定义寄存器型共同体
    int mousedr;
    system("cls");
    printf("Initializing Mouse.....\n\n");
    regs.x.ax=0;     //设置ax的值为0
    int86(0x33,&regs,&regs);
    mousedr=regs.x.ax;
    if(mousedr==0)
    {
        printf("initialize mouse error!");
        exit(1);
    }
    printf("Finished initializing!\n\n");
    printf("Showing Mouse...");
    regs.x.ax=1;
    int86(0x33,&regs,&regs);
    printf("you can use the mouse....\n\n");
    printf("Press any key to hide the mouse.\n");
    getch();
    regs.x.ax=2;
    int86(0x33,&regs,&regs);
    printf("\nThe mouse is hided.\n");
    getc();
}
*/

/*
//访问系统temp中的文件
void main()
{
    char *pathname,filename[30],ch;
    FILE *fp;
    pathname=getenv("TEMP");   //获取临时文件夹路径
    //该函数的作用是返回一个指向环境信息的指针，该信息与由name所指向的在DOS环境
    //信息表中有关的字符串有关。如果用一个与任何环境数据都不匹配的参数调用getenv();
    //则返回的是空指针。
    printf("\nCurrent path is：%s\n",pathname);
    printf("press any key to open one file!\n");
    getch();
    strcat(pathname,"\\new.txt");
    strcpy(filename,pathname);
    if((fp=fopen(filename,"r"))!=NULL)
    {
        printf("\nThe name of the file is");
        printf("\n%s",filename);
        printf("\nThe content of the file is\n");
        ch=fgetc(fp);
        while(ch!=EOF)
        {
            printf("%c",ch);
            ch=fgetc(fp);
        }
        fclose(fp);
    }
    else
        printf("can not open!\n");
}
*/


/*
//控制扬声器声音
void main()
{
    unsigned fre=50;
    int times;
    for(times=0;times<1000;times++)
    {
        fre=(fre+times)&40000;   //生成声音频率
        sound(fre);
        delay(1000);
    }
    nosound();
}
*/


//获取Caps Lock键状态
/*
void main()
{
    int value=0;
    printf("\nThe current status of the Caps Lock key is:\n");
    value=peekb(0x0040,0x0017);    //获取段地址为0x0040，偏移地址为0x0017的字节集单元信息
    if(value&64)  //当获取的字节单元的值
    {
        printf("\n\nThe Caps Lock ky is: on");
    }
    else
    {
        printf("\n\nThe Caps Lock ky is: off");
    }

}
*/



//获取环境变量
//环境变量是包含计算机名称、驱动器、路径之类的字符串。环境变量控制着多种程序的行为
/*
void main()
{
    char *path,*ptr;
    int i=0;
    puts("This program is to get the information of environ:\n");
    while(environ[i])
        printf(">>%s\n",environ[i++]);
}
*/

/*
//贪吃蛇游戏
#include<graphics.h>
#define LEFT 0x4b00
#define RIGHT 0x4d00
#define DOWN 0x5000
#define UP 0x4800
#define ESC 0x011b
#define N 100    //贪吃蛇的最大长度
int i,key;
int speed;
void GameOver();   //结束游戏
void Play();    //玩游戏过程
void dwall();      //画墙
void wall(int x,int y);    //画组成墙的砖
int speed();   //选择贪吃蛇的速度
//定义结构体，FOOD是表示食物基本信息的结构体，Snake是定义贪吃蛇基本信息的结构体
struct FOOD
{
    int x;      //食物的横坐标
    int y;    //食物的纵坐标
    int flag;    //标志是否要出现事物
}food;

struct Snake
{
    int x[N];
    int y[N];
    int node;    //蛇的节数
    int dir;     //蛇移动方向
    int life;   //标志是死是活
}snake;

//自定义函数wall()，用来画组成墙的砖
void wall(int x,int y)
{
    int sizx=9;
    int sizy=9;
    setcolor(15);     //白色画砖的上边和左边
    line(x,y,x+sizx,y);
    line(x,y+1,x+sizx-1,y+1);
    line(x,y,x,y+sizy);
    line(x+1,y,x+1,y+sizy-1);
    setcolor(4);     //红色画砖的右边和下边
    line(x+1,y+sizy,x+sizx,y+sizy);
    line(x+2,y+sizy-1,x+sizx,y+sizy-1);
    line(x+sizx-1,y+2,x+sizex-1,y+sizy-1);
    line(x+size,y+1,x+sizx,y+sizy);
    setfillstyle(1,12);        //用淡红色填充砖的中间部分
    bar(x+2,y+2,x+sizx-2,y+sizy-2);
}

//自定义函数dwall()，用来画墙
void dwall()
{
    int i;
    for(j=50;j<=600;j+=10)
    {
        wall(j,40);    //画上面墙
        wall(j,451);   //画下面墙
    }
    for(j=40;j<=450;j+=10)
    {
        wall(50,j);    //画左面墙
        wall(601,j);   //画右面墙
    }
}

//自定义函数speed()，用来选择贪吃蛇的速度
int speed()
{
    int m;
    gotoxy(20,10);
    printf("level 1\n");
    gotoxy(20,12);
    printf("level 2\n");
    gotoxy(20,14);
    printf("level 3\n\t\tplease choose:");
    scanf("%d",&m);
    switch(m)
    {
        case 1:
            return 60000;
        case 2:
            return 40000;
        case 3:
            return 20000;
        default:
            cleardevice();
            speed();

    }
}

//自定义函数play(),用来实现贪吃蛇游戏的具体过程
void play()
{
    srand((unsigned long)time(0));
    food.flag=1;     //1表示需出现新事物，0表示食物已存在
    snake.life=0;   //标志贪吃蛇或者
    snake.dir=1;   //方向向右
    snake.x[0]=300;
    snake.y[0]=240;
    snake.x[1]=290;    //定义蛇头初始位置
    snake.y[1]=240;
    snake.node=2;    //贪吃蛇节数为2节
    do
    {
        while(!kbhit())   //在没有按键的情况下，蛇自己移动身体
        {
            if(food.flag==1)   //需要出现新食物
            do
            {
                food.x=rand()%520+60;
                food.y=rand()%370+60;
                food.flag=0;  //标志已有食物
            }
            while(food.x%10!=0||food.y%10!=0);

            if(food.flag==0)   //画出食物
            {
                setcolor(GREEN);
                setlinestyle(3,0,3);
                rectangle(food.x,food.y,food.x+10,food.y+10);
            }
            for(i=snake.node-1;i>0;i--)   //实现蛇向前移动
            {
                snake.x[i]=snake[i-1];
                snake.y[i]=snake[i-1];
            }
            switch(snake.dir)
            {
                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]<60||snake.x[0]>590||snake.y[0]<50||snake.y[0]>440)   //判断蛇是否撞到墙壁
            {
                GameOver();
                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.node++;   //蛇的身体长一节
                food.flag=1;   //需要出现新的食物
            }
            setcolor(4);     //画蛇
            for(i=0;i<snake.node;i++)
            {
                setlinestyle(0,0,1);
                rectangle(snake.x[i],snake.y[i],snake.x[i]+10,snake.y[i]+10);
            }
            delay(speed);
            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);
        }
        if(snake.life==1)     //如果蛇死就跳出循环
        {
            break;
        }
        key=bioskey(0);    //接收按键
        if(key==UP&&snake.dir!=4)   //判断是否向相反的方向移动
        {
            snake.dir=3;
        }
        else
        {
            if(key=DWON &&snake.dir!=3)   //判断是否向相反的方向移动
            {
                snake.dir=4;
            }
            else
                {
                    if(key==RIGHT &&snake.dir!=2)    //判断是否向相反的方向移动
                    {
                        snake.dir=1;
                    }
                    else
                        {
                            if(key==LEFT && snake.dir!=1)
                            {
                                snake.dir=2;
                            }
                        }
                }
        }
    }
    while(key!=ESC);  //按ESC键退出游戏
}

//自定义函数GameOver(),用来提示游戏结束
void GameOver()
{
    cleardevice();
    setcolor(RED);
    settextstyle(0,0,4);
    outtextxy(50,200,"GAME OVER,BYE BYE!");
    _sleep(10000);
}

void main()
{
    int gdriver=DETECT,gmode;
    initgraph(&gdriver,&gmode,"");
    speed=speed();
    cleardevice();
    dwall();
    play();
    getch();
    closegraph();
}
*/
/*在编写贪吃蛇游戏时要注意以下几点：
（1）如何实现蛇在吃到食物后食物消失。这里用到的方法是采用背景色在出现食物的地方重画食物，这样食物就不见了。
（2）如何实现蛇的移动且在移动的过程中不留下痕迹。实现蛇的移动也是贪吃蛇游戏最核心的技术，主要方法是将蛇头后面的每一节
逐次移到前一节的位置，然后按蛇的运行方向不同对蛇头的位置做出相应的调整。这里以向右运行为例，当蛇向右运行时蛇头的横坐标
加10纵坐标不变，蛇每向前运行一步，相应地将其尾部一节用背景色重画，即去掉其尾部
（3）当蛇向上运行时，从键盘中输入向下键，此时蛇的运行防线不变，其他几个方向依次类推，本实例采用了if...else语句来实现该功能
（4）食物出现的位置采用随机产生，但这种随机产生也是有一定限制条件，即食物出现位置的横坐标必须能被10整除，只有这样
才能保证蛇能够吃到食物。
*/

//指针章
/*
//使用指针实现整数排序
void swap(int *p1,int *p2)  //用于实现数据的交换
{
    int temp;
    temp=*p1;
    *p1=*p2;
    *p2=temp;
}

void exchange(int *pt1,int *pt2,int *pt3)   //用于比较数值大小
{
    //从大到小的顺序排列
    if(*pt1<*pt2)
        swap(pt1,pt2);
    if(*pt1<*pt3)
        swap(pt1,pt3);
    if(*pt2<*pt3)
        swap(pt2,pt3);
}

void main()
{
    int a,b,c,*q1,*q2,*q3;
    printf("please input three key numbers you want to rank:\n");
    scanf("%d,%d,%d",&a,&b,&c);
    q1=&a,q2=&b,q3=&c;
    exchange(q1,q2,q3);
    printf("%d,%d,%d\n",a,b,c);
}
*/


//用指针数组构造字符串数组
/*
void main()
{
    char *Week[]={
        "Monday","Tuesday","Wednesday","Thursday","Friday","Saturday","Sunday"
    };
    int i;
    printf("Please enter a number for week\n");
    scanf("%d",&i);
    printf("The week is:");
    printf("%s\n",Week[i-1]);
}
*/

/*常用数据结构*/
/*
//比较计数
//用比较计数法对结构数组a按字段num进行升序排序，num的值从键盘中输入。
#define N 5
struct order
{
    int num;
    int con;
}a[20];

void main()
{
    int i,j;
    for(i=0;i<N;i++)
    {
        scanf("%d",&a[i].num);
        a[i].con=0;
    }
    for(i=N-1;i>=1;i--)
        for(j=i-1;j>=0;j--)
           if(a[i].num<a[j].num)    //对数组中的每个元素和其他元素进行比较
               a[j].con++;    //记录排序号
           else
               a[i].con++;
    printf("各数的顺序是：\n");
    for(i=0;i<N;i++)
        printf("%3d%3d\n",a[i].num,a[i].con+1);  //将数据及其排序输出
}
*/


/*
//找出最高分
struct student
{
    int num;
    char name[20];
    float score;
};

void main()
{
    int i,m;
    float maxscore;
    struct student stu[5]=
    {
        {101,"李明",89},
        {102,"苑大",95},
        {103,"孙佳",89},
        {104,"王子川",85},
        {105,"刘春月",75}
    };
    m=0;
    maxscore=stu[0].score;
    for(i=1;i<5;i++)
    {
        if(stu[i].score>maxscore)
        {
            maxscore=stu[i].score;
            m=i;
        }
    }
    printf("最高分是：%5.1f\n",maxscore);
    printf("最高分学生的学号：%d\n",stu[m].num);
    printf("最高分学生的姓名：%s\n",stu[m].name);
}
*/


//候选人选票程序
/*
struct candidate
{
    char name[20];
    int count;
}cndt[3]={{"王",0},{"张",0},{"李",0}};

void main()
{
    int i,j;
    char Ctname[20];
    for(i=1;i<=10;i++)
    {
        scanf("%s",&Ctname);  //输入候选人姓名
        for(j=0;j<3;j++)
        {
            if(strcmp(Ctname,cndt[j].name)==0)
                cndt[j].count++;
        }
    }
    for(i=0;i<3;i++)
    {
        printf("%s : %d\n",cndt[i].name,cndt[i].count);
    }
}
*/

/*
//计算开机时间
//编程实现计算开机时间，要求在每次开始计算开机时间都能接着上次记录的结果向下记录
struct time
{
    int hour;
    int minute;
    int second;
}t;

void main()
{
    FILE *fp;
    fp=fopen("Time","r");  //以只读方式打开Time
    fread(&t,sizeof(struct time),1,fp);   //读取文件信息
    while(!kbhit())    //当按键时执行循环体语句
    {
        rewind(fp);     //将文件指针设置到文件起点
        _sleep(1000);   //程序停止1秒钟
        fread(&t,sizeof(struct time),1,fp);
        if(t.second==59)
        {
            t.minute+=1;
            if(t.minute==60)
            {
                t.hour+=1;
                t.minute=0;
            }
            t.second=0;
        }
        else
            t.second+=1;
        printf("%d:%d:%d\n",t.hour,t.minute,t.second);
        fp=fopen("Time","w");
        fwrite(&t,sizeof(struct time),1,fp);
        fclose(fp);
    }
}
//实例中以秒为单位读取系统时间，将读取的时间存到指定磁盘文件中，每次开始计时的时候就从该磁盘文件中
//读取上次记录的时间接着计时，当秒数达到60,则分钟数加1；如果分钟数达到60，则小时数加1
*/


/*
//取出整型数据的高字节数据
union    //定义共同体，共用两个字节单元空间
{
    char ch[2];
    int num;
}word;

void main()
{
    word.num=0x1234;
    printf("十六进制数是: %x\n",word.num);
    printf("高字节位数据是：%x\n",word.ch[1]);
    word.ch[1]="b";
    printf("现在这个数变为：%x\n",word.num);
}
*/


//使用共用体存放学生和老师信息
/*根据输入的职业标识，区分是老师还是学生，然后根据输入的信息，将对应的信息输出。如果是学生则输出班级
如果是老师则输出职位
*/
/*
struct
{
    int num;
    char name[10];
    char tp;
    union
    {
        int inclass;
        char position[10];
    }job;
}person[2];

void main()
{
    int i;
    printf("请输入个人信息：\n");
    for(i=0;i<2;i++)
    {
        printf("第%d个人\n",i+1);
        scanf("%d%s%c",&person[i].num,person[i].name,&person[i].tp);
        if(person[i].tp=='s')
            scanf("%d",&person[i].job.inclass);   //输入工作类型
        else if(person[i].tp=='t')
                  scanf("%s",person[i].job.position);
        else
            printf("输入有误！");
    }
    printf("\n 编号     姓名      类型        班级/职位\n");
    for(i=0;i<2;i++)
    {
        if(person[i].tp=='s')
            printf("%d\t%s\t%c\t%d",person[i].num,person[i].name,person[i].tp,person[i].job.inclass);
        else if(person[i].tp=='t')
            printf("%d\t%s\t%c\t%s",person[i].num,person[i].name,person[i].tp,person[i].job.position);
        printf("\n");
    }
}
*/

/*
//创建单向链表
#include<malloc.h>
struct Node
{
    int data;
    struct Node *next;
};

struct Node *create(int n)
{
    int i;
    struct Node *head,*p1,*p2;
    int a;
    head=NULL;
    printf("输入整数：\n");
    for(i=n;i>0;--i)
    {
        p1=(struct Node*)malloc(sizeof(struct Node));
        scanf("%d",&a);
        p1->data=a;
        if(head==NULL)         //指定头节点
        {
            head=p1;
            p2=p1;
        }
        else
        {
            p2->next=p1;       //指定后继指针
            p2=p1;
        }
    }
    p2->next=NULL;
    return head;
}

void main()
{
    int n;
    struct Node *q;
    printf("输入你想创建的节点的个数：\n");
    scanf("%d",&n);
    q=create(n);
    printf("结果是：\n");
    while(q)
    {
        printf("%d  ",q->data);
        q=q->next;
    };
    printf("\n");
}

//链表是动态分配存储空间的链式存储结构，其包括一个”头指针“变量，头指针中存放一个地址，该地址指向一个元素
*/

/*
//创建双向链表
typedef struct node
{
    char name[20];
    struct node *prior,*next;   //prior直接前驱指针，next直接后继指针
}stud;

stud * creat(int n)
{
    stud *p,*h,*s;
    int i;
    h=(stud*)malloc(sizeof(stud));
    h->name[0]='\0';
    h->prior=NULL;
    h->next=NULL;
    p=h;
    for(i=0;i<n;i++)
    {
        s=(stud *)malloc(sizeof(stud));
        p->next=s;
        printf("输入第%d个学生的姓名：",i+1);
        scanf("%s",s->name);
        s->prior=p;     //指定前驱节点
        s->next=NULL;
        p=s;
    }
    p->next=NULL;
    return h;
}

stud *search(stu *h,char *x)
{
    stud *p;
    char *y;
    p=h->next;
    while(p)
    {
        y=p->name;
        if(strcmp(y,x)==0)  //如果是要删除的节点，则返回地址
            return p;
        else
            p=p->next;
    }
    printf("没有找到数据！\n");
}

void del(stud *p)
{
    p->next->prior=p->prior;
    p->prior->next=p->next;
    free(p);
}

void main()
{
    int number;
    char sname[20];
    stu *head,*sp;
    printf("请输入链表的大小：");
    scanf("%d",&number);   //输入链表节点数
    head=creat(number);
    sp=head->next;
    printf("\n现在这个双链表是：\n");
    while(sp)
    {
        printf("%s",&*(sp->name));
        sp=sp->next;
    }
    printf("\n请输入你想查找的姓名：\n");
    scanf("%s",sname);
    sp=scarch(head,sname);   //查找指定节点
    printf("你想查找的姓名是：%s\n",*&sp->name);
    del(sp);
    sp=head->next;
    printf("现在这个双链表是：\n");
    while(sp)
    {
        printf("%s",&*(sp->name));   //输出当前链表中数据
        sp=sp->next;
    }
    printf("\n");
    puts("\n 按任意键退出....");
}

//单向链表节点的存储结构只有一个指向直接后继的指针域，所以从单链表的某个节点出发只能顺时针查询其他节点。使用双向链表
//可以避免单向链表这种单向性的缺点
*/