第一个1000行

/*
Author:MrBread
Introduction:Aim to improve my programming ability and record my codes.
Start date:Feb 5th,2017
*/
#include<stdio.h>
#include<math.h>
#include<time.h>
#include<string.h>
    /*
    2017-02-04
    //第一个c语言程序
    printf("Hello,World!\n");
    return 0;
    */


/*  2017-02-04
    //求n！
    int n,i=2;
    double factorial=1;//防止溢出，尽可能使能表示尽可能大的值,要赋初值1
    printf("请输入1到50之间的整数:\n");
    scanf("%d",&n);   //切不可忘记取地址符&
    if(n==1)
    {
        printf("The factorial is %d",1);
        return 0;
    }
    while(i<=n)
    {
        factorial*=i;  //数据类型自动转换，从低精度自动转换成高精度
        i++;
    }
    printf("The factorial is :%d!=%.0lf",n,factorial);
    return 0;
    */


/*2017-02-04
    //输入三个数然后按从小到大输出
    int a,b,c,temp;//temp是在交换的中间值
    printf("请输入三个任意的整数：\n");
    scanf("%d%d%d",&a,&b,&c);  //scanf("%d,%d,%d\n",&a,&b,&c)在输入数据时要用逗号分隔
    if(a>b)
    {
        temp=a;
        a=b;
        b=temp;
    }
    if(a>c)
    {
        temp=a;
        a=c;
        c=temp;
    }
    if(b>c)
    {
        temp=b;
        b=c;
        c=temp;
    }
    printf("从小到大的顺序输出：%d,%d,%d\n",a,b,c);
    return 0;
    */


/*
    //猴子吃桃
    //问题描述：猴子每天吃苹果的一半加一个，第十天只剩下了一个苹果。求第一天的苹果总数
    int days=10,remain=1;//days代表天数，remain代表第days天剩下的苹果
    int result=remain;
    while(days>=1)
    {
        printf("第%d天剩下的苹果：%d 个\n",days,result);
        result=(result+1)*2;
        days--;
    }
    return 0;
    */

/*
    //阳阳买苹果
    //问题描述：阳阳每天买苹果，每个苹果0.8元，第一天买了两个苹果，之后每一天是前一天的一倍，直到总的苹果个数为不超过100的最大值
    //此时计算平均每天花多少钱买苹果
    int apple_sum=0;
    int everyday=2;   //第一天买的苹果个数
    int day=0;
    while(apple_sum<=100)
    {
        day++;
        apple_sum=apple_sum+everyday;
        everyday*=2;
    }
    float average=apple_sum*0.8/day;
    printf("平均每天花在苹果上的钱为：%f",average);
    return 0;
*/

/*
    //任意次方后的最后三位
    //编程求一个整数任意次方的最后三位数，即求x^y的最后三位数，x和y的值由键盘输入。
    int x,y;
    long long result=1;    //sizeof(long long)=8;
    printf("请输出两个整数x和y:\n");
    scanf("%d%d",&x,&y);
    while(y--)
    {
        result=x*result;
    }
    printf("%d%d%d\n",result%1000/100,result%100/10,result%10);
    return 0;
    //考虑到溢出问题，这里有一种方法可以避免这类问题;
    //for(i=1;i<=y;i++)
    //   z=z*x%1000;
    //if(z>100)
    //   printf("%d",z);
    //else
    //  printf("0%d",z);
*/

/*
    //计算某日是该年的第几天
    int year,month,day,i;
    int run[12]={    //闰年各月份天数
        31,29,31,30,31,30,31,31,30,31,30,31
    };
    int ping[12]={   //平年各月份天数
        31,28,31,30,31,30,31,31,30,31,30,31
    };
    int result=0;   //result代表该年的第几天
    printf("按照年月日的顺序输入，以逗号隔开：\n");
    scanf("%d,%d,%d",&year,&month,&day);
    int flag;//设置为闰年标志，若为闰年则flag=1;
    if(year%4==0&&year%100!=0||year%400==0) //闰年判断条件，从左往右判断
    //若能被4整除而不能被100整除或者能被40整除
        flag=1;
    else
        flag=0;
    if(flag)//若是闰年
    {
        for(i=0;i<month-1;i++)
            result=result+run[i];
    }
    else
    {
        for(i=0;i<month-1;i++)
            result=result+ping[i];
    }
    result=result+day;
    printf("该日期为该年的第 %d 天\n",result);
    return 0;

    //思考：可以直接按照平年先计算天数，再判断月份是否大于3然后闰年只需要多加上一天即可
*/

/*
     //2017-02-05
    //婚礼上的谎言
    //问题描述：3对情侣参加婚礼，3个新郎为A，B，C，3个新娘为X，Y，Z，有人想知道究竟谁与谁
    //结婚，于是就问新人中的三位，得到如下结果：A说他将和X结婚；X说她的未婚夫是C；C说他将
    //和Z结婚。这人事后知道他们在开玩笑，说的全是假话。那么，究竟谁与谁结婚呢？
    //暴力解法
    int a,b,c;
    for(a=1;a<=3;a++)
        for(b=1;b<=3;b++)
            for(c=1;c<=3;c++)
                if(a!=1&&c!=1&&c!=3&&a!=b&&a!=c&&b!=c)
                {
                    printf("%c 将嫁给 A\n",'X'+a-1);
                    printf("%c 将嫁给 B\n",'X'+b-1);
                    printf("%c 将嫁给 C\n",'X'+c-1);
                }
    return 0;
*/
/*    2017-02-06

    //百元买百鸡
    //问题描述：鸡翁一，值钱5，鸡母一，值钱三，鸡雏三，值钱一，百元买百鸡求各类鸡的个数？
    int a,b,c;//a代表鸡翁，b代表鸡母，c代表鸡雏
    for(a=0;a<20;a++)
        for(b=0;b<34;b++)
        {
            c=100-a-b;
            //if(c%3==0) 再判断钱数是否等于100，这样后面就不用强制类型转换
            if(a*5+b*3+(float)c/3==100)    //精度的问题，c/3不一定为整数，需要将其强制转化为float型
               printf("鸡翁，鸡母，鸡雏的个数分别为：%d,%d,%d\n",a,b,c);
        }
    return 0;
*/

/*
    //打鱼晒网问题
    //如果一个渔夫从2011年1月一日开始每三天打一次渔，两天晒一次网，编程实现当输入2011年以后的任意一天
    //输出该渔夫是在打渔还是晒网。
    int year,month,day,i;
    int result=0;
    int ping[12]={
        31,28,31,30,31,30,31,31,30,31,30,31
    };
    printf("请输入年月日，以逗号隔开(2011年之后的任意一天)：\n");
    scanf("%d,%d,%d",&year,&month,&day);
    for(i=0;i<year-2011;i++)
    {
        if((i+2011)%4==0&&(i+2011)%100!=0||(i+2011)%400==0) //闰年判断条件，从左往右判断
            result=result+366;
        else
            result=result+365;
    }
    for(i=0;i<month-1;i++)
        result=result+ping[i];
    result=result+day;
    if((year%4==0&&year%100!=0||year%400==0)&&month>2)
        result=result+1;  //若是闰年且月份大于2月则记上一天
    //判断打渔还是晒网：以5为周期，取余判断余数
    printf("天数=%d\n",result);
    if(result%5>0&&result%5<=3)  //注意此处的判断条件
        printf("%d-%d-%d这一天在打渔\n",year,month,day);
    else
        printf("%d-%d-%d这一天在晒网\n",year,month,day);
    return 0;
*/

/*
    //判断三角形的类型
    //根据输入的三角形的三条边判断三角形的类型，并输出它的面积和体积。
    float a,b,c;
    float s,area;
    printf("请输入三条边长,以逗号隔开：\n");
    scanf("%f,%f,%f",&a,&b,&c);
    //判断三角形成立条件
    if(a+b>c&&a+c>b&&b+c>a)
    {
        s=(a+b+c)/2;
        area=(float)sqrt(s*(s-a)*(s-b)*(s-c));  //需要添加头文件math.h
        printf("构成的三角形的面积是：%f\n",area);
        if(a==b&&a==c)
        {
            printf("构成的三角形为等边三角形\n");
        }
        else if(a==b||a==c||b==c)
             {
                printf("构成的三角形为等腰三角形\n");
             }
             else if((a*a+b*b==c*c)||(a*a+c*c==b*b)||(b*b+c*c==a*a))
                     printf("构成的三角形为直角三角形\n");
                  else
                     printf("构成的三角形为普通三角形\n");
    }
    else
        printf("输入的三条边不能构成三角形\n");
    return 0;
*/

/*
    //直接插入排序
    //插入排序是把一个记录插入到已排序的有序序列中，使整个序列在插入该记录之后仍然有序
    //插入排序中较简单的一种方法就是直接插入排序，其插入位置的确定方法是将待插入的记录
    //与有序区的各记录自右向左依次比较其关键字的值的大小，本实例要求使用直接插入排序法将数字
    //由小到大进行排序
    int a[50];
    int i,j,k,temp;
    printf("请输入十个整数，以空格隔开：\n");
    for(i=0;i<10;i++)
        scanf("%d",&a[i]);
    //进行排序
    printf("原始顺序：\n");
    for(i=0;i<10;i++)
        printf("%5d",a[i]);
    printf("\n");
    //开始排序 先就第一个元素是有序的，从第二个元素开始进行比较
    int count=1;  //count计算交换的次数
    for(i=1;i<10;i++)  //进行九轮遍历
    {
        //每一次遍历之后序列都是有序的
        for(j=0;j<i;j++)
        {
            if(a[j]>a[i])  //一碰到比自己大的数即进行交换
            {
                temp=a[j];
                a[j]=a[i];
                a[i]=temp;
            }
            printf("第%d次交换结果：\n",count);
            for(k=0;k<10;k++)
                printf("%5d",a[k]);
            printf("\n");
            count++;
        }
        printf("第%d轮遍历的结果为：\n",i);
        for(j=0;j<10;j++)
            printf("%5d",a[j]);
        printf("\n\n\n");
    }
    */
    /*
//直接插入排序
    //插入排序是把一个记录插入到已排序的有序序列中，使整个序列在插入该记录之后仍然有序
    //插入排序中较简单的一种方法就是直接插入排序，其插入位置的确定方法是将待插入的记录
    //与有序区的各记录自右向左依次比较其关键字的值的大小，本实例要求使用直接插入排序法将数字
    //由小到大进行排序
void insort(int s[],int n)    //自定义函数insort
{
    int i,j,k,count=1;//count计算交换的次数
    for(i=2;i<=n;i++)//数组下标从2开始，s[0]做监视哨，s[1]一个数据无可比性
    {
        s[0]=s[i];   //给监视哨赋值
        j=i-1;       //确定要比较元素的最右边的位置
        while(s[0]<s[j])
        {
            s[j+1]=s[j];  //数据右移
            j--;          //移向左边的一个未比较的数
        //测试结果
        //    printf("第%d次中间结果：\n",count);
        //    for(k=0;k<=10;k++)
        //        printf("%5d",s[k]);
        //    printf("\n");
        //    count++;

        }
        s[j+1]=s[0];     //在确定的位置插入s[i]
        printf("第%d次遍历：\n",i-1);
        for(k=1;k<=10;k++)
            printf("%5d",s[k]);
        printf("\n");
    }
}
void main()
{
    int a[11],i;      //定义数组及变量为基本类型
    printf("请输入10个数据：\n");
    for(i=1;i<=10;i++)
        scanf("%d",&a[i]);
    printf("原始顺序：\n");
    for(i=1;i<11;i++)
        printf("%5d",a[i]);
    printf("\n");
    insort(a,10);
    printf("\n插入数据后排序：\n");
    for(i=1;i<11;i++)
        printf("%5d",a[i]);
    printf("\n");
}
*/

/*
   //希尔排序法
   //希尔排序法又称缩小增量法，属于插入类排序，是将整个无序子序列分别进行插入排序的方法
   //先取一个整数d1<n,把所有序号相隔d1的数组元素放一组，组内进行直接插入排序；然后取d2<d1
   //重复上述分组和排序操作；直至di=1.即所有记录放进一个组中排序为止
   void shsort(int s[],int n)   //自定义函数shsort
   {
       int i,j,k,d;
       d=n/2;         //确定固定增量值
       while(d>=1)
       {
           for(i=d+1;i<=n;i++) //数组下标从d+1开始进行直接插入排序
           {
               s[0]=s[i];   //设置监视哨
               j=i-d;      //确定要进行比较的最右边的元素
               while((j>0)&&(s[0]<s[j]))
               {
                   s[j+d]=s[j];   //数据右移
                   j=j-d;        //向左移动固定增量的位置
               }
               s[j+d]=s[0];    //在确定的位置插入s[i]
               //测试
               printf("输出中间结果：\n");
               for(k=1;k<=10;k++)
                   printf("%5d",s[k]);
               printf("\n");
           }
           d=d/2;
       }
    }
   void main()
   {
       int a[11],i;
       printf("请输入10个整数：\n");
       for(i=1;i<=10;i++)
          scanf("%d",&a[i]);  //从键盘中输入十个数据
       shsort(a,10);
       printf("排序后的顺序是:\n");
       for(i=1;i<=10;i++)
          printf("%5d",a[i]);
       printf("\n");
   }
*/
/*
//冒泡排序就是从第一个数开始，依次与之后的数进行比较，将最大的数移到最后，就像一个气泡一样一点一点往上浮
void main()
{
    int i,j,k,temp,a[11];
    printf("请输入十个数：\n");
    for(i=1;i<11;i++)
        scanf("%d",&a[i]);
    for(i=1;i<11;i++)      //变量i代表比较的趟数
        for(j=1;j<11-i;j++) //变量j代表每趟两两比较的次数
        {
            if(a[j]>a[j+1])     //如果前一个数比后一个数大则交换
            {
                temp=a[j];
                a[j]=a[j+1];
                a[j+1]=temp;
            }
            printf("测试中间结果:\n");
            for(k=1;k<11;k++)
                printf("%5d",a[k]);
            printf("\n");
        }
     printf("排序后的顺序是：\n");
     for(i=1;i<=10;i++)
        printf("%5d",a[i]);
     printf("\n");
}
*/

/*
   //快速排序
   //快速排序法是冒泡排序法的一种改进，主要的算法思想是在待排序的n个数据中取一个数据作为基准值
   //将所有记录分为三组，使第一组各数据值均小于或等于基准值，第二组做基准值的数据
    //第三组各数据值均大于或等于基准值，这便实现了第一趟分割，然后再对第一组和第三组分别重复上述
    //方法，依次类推，直到每组中只有一个记录为止
void qusort(int s[],int start,int end)
{
    int i,j;
    i=start;       //将每组首个元素赋给i
    j=end;         //将每组末尾元素赋给j
    s[0]=s[start];  //设置基准值
    while(i<j)
    {
        while(i<j&&s[0]<s[j])
            j--;              //位置左移
        if(i<j)
        {
            s[i]=s[j];    //将小于或等于基准值的s[j]放到s[i]的位置上
            i++;          //位置右移
        }
        while(i<j&&s[i]<=s[0])
            i++;        //位置右移
        if(i<j)
        {
            s[j]=s[i];     //将大于或等于基准值的s[i]放到s[j]位置
            j--;           //位置左移
        }
    }
    s[i]=s[0];     //将基准放入指定位置
    if(start<i)
        qusort(s,start,j-1);    //将分割出的部分递归调用qusort函数
    if(i<end)
        qusort(s,j+1,end);
}

void main()
{
    int a[11],i;
    printf("请输入10个数：\n");
    for(i=1;i<=10;i++)
        scanf("%d",&a[i]);
    qusort(a,1,10);   //调用函数进行排序
    printf("排序后的顺序是：\n");
    for(i=1;i<=10;i++)
        printf("%5d",a[i]);
    printf("\n");
}
*/


//选择排序法
/*选择排序的基本算法是从待排序的区间中经过选择和交换后选出最小的数值存放到a[1]中
在从剩余的未排序区间中经过选择和交换后选出最小的数值存放到a[2]中，依此类推*/
/*
void main()
{
    int i,j,t,a[11];
    printf("请输入十个整数:\n");
    for(i=1;i<11;i++)
        scanf("%d",&a[i]);
    for(i=1;i<=9;i++)       //该循环是确定位置的，该位置是存放每次从待排序数列中经选择和交换后所选出的最小数
        for(j=i+1;j<=10;j++)   //实现将确定位置上的数和后面待排序区间的数进行比较的
           if(a[i]>a[j])    //如果前一个数比后一个数大，则交换
           {
               t=a[i];
               a[i]=a[j];
               a[j]=t;
           }
    printf("排序后的顺序是：\n");
    for(i=1;i<=10;i++)
        printf("%5d",a[i]);
    printf("\n");
}
*/


//归并排序
/*要点：归并是将两个或多个有序记录序列合并成一个有序数列。归并方法有多种，一次对两个有序
记录序列进行归并，称为二路归并排序，也有三路归并排序及多路归并排序。本实例是二路归并排序。基本方法是：
1、将n个记录看成是n个长度为1的有序子表
2、将两两相邻的有序子表进行归并
3、重复执行步骤2，知道归并成一个长度为n的有序子表
*/
/*
void merge(int r[],int s[],int x1,int x2,int x3)  //实现一次归并排序
{
    int i,j,k;
    i=x1;  //第一部分的开始位置
    j=x2+1; //第二部分的开始位置
    k=x1;
    while((i<=x2)&&(j<=x3)) //当i和j都在两个要合并的部分中时
        //筛选两部分中较小的元素放到数组s中
       if(r[i]<=r[j])
       {
           s[k]=r[i];
           i++;
           k++;
       }
       else
       {
           s[k]=r[j];
           j++;
           k++;
       }
    while(i<=x2)    //将x1~x2范围内未比较的数顺次加到数组r中
       s[k++]=r[i++];
    while(j<=x3)    //将x2+1~x3范围内未比较的数顺次加到数组r中
       s[k++]=r[j++];

}

void merge_sort(int r[],int s[],int m,int n)
{
    int p;
    int t[20];
    if(m==n)
        s[m]=r[m];
    else
    {
        p=(m+n)/2;
        merge_sort(r,t,m,p);
        //递归调用merge_sort()函数将r[m]~r[p]归并成有序的t[m]~t[p]
        merge_sort(r,t,p+1,n);
        //递归调用merge_sort()函数将r[p+1]~r[n]归并成有序的t[p+1]~t[n]
        merge(t,s,m,p,n);   //调用函数将前两部分归并到s[m]~s[n]
    }
}

void main()
{
    int a[11];
    int i;
    printf("请输入10个数：\n");
    for(i=1;i<=10;i++)
        scanf("%d",&a[i]);
    merge_sort(a,a,1,10);
    printf("排序后的顺序是：\n");
    for(i=1;i<=10;i++)
        printf("%5d",a[i]);
    printf("\n");
}
*/
/*
    //二分查找
    //二分查找就是折半查找，其基本思想就是；首先选取表中间位置的记录，将其关键字与给定关键字key
    //进行比较，若相等，则查找成功；若key的值比关键字值大，则要找的元素一定在右子表中，则继续对右子表进行折半查找；
    //若key的值比关键字值小，则要找的元素一定在左子表中，继续对左子表进行查找。如此类推，直到查找成功或查找失败
    //(查找范围为0)

void binary_search(int key,int a[],int n)
{
    int low,high,mid,count=0,count1=0;
    low=0;
    high=n-1;
    while(low<high)     //当查找范围不为0时执行循环体语句
    {
        count++;   //count记录查找次数
        mid=(low+high)/2;   //求中间位置
        if(key<a[mid])   //key小于中间值时
           high=mid-1;    //确定左子表范围
        else if(key>a[mid])    //key大于中间值时
                low=mid+1;      //确定右子表范围
             else if(key==a[mid])   //当key等于中间值时，证明查找成功
                  {
                     printf("查找成功！\n查找 %d 次！a[%d]=%d\n",count,mid,key);
                     //输出查找次数及所查找元素在数组中的位置
                     count1++;    //记录查找成功的次数
                     break;
                  }
       //缺点：这里写的只能查找成功一次而对于出现多次并不能查找出来
    }

    if(count1==0)    //判断是否查找失败
        printf("查找失败！\n");
}

void main()
{
    int i,key,a[100],n;
    printf("请输入数组的长度：\n");
    scanf("%d",&n);
    printf("请输入数组元素：\n");
    for(i=0;i<n;i++)
        scanf("%d",&a[i]);
    printf("请输入你想查找的元素：\n");
    scanf("%d",&key);
    binary_search(key,a,n);  //调用函数
    printf("\n");
}

//需要改进
*/

/*
    //分块查找
    //分块查找也称为索引顺序查找。要求将待查的元素均匀地分成块，块间按大小排序，块内不排序
    //所以要建立一个块的最大(或最小)关键字表，称为索引表。
    //本实例将给出的15个数按关键字大小分成了3块，这15个数的排列是一个有序序列，也可以给出无序序列，
    //但必须满足分在第一块中的任意数都小于第二块中的所有数，第二块中的所有数都小于第三块中的所有数。
    //当要查找关键字为key的元素时，先用顺序查找在已建好的索引表中查出key所在的块中，再在对应的块中顺序查找key,
    //若key存在，则输出其相应的位置，否则输出提示信息。

    struct index    //定义块的结构
    {
        int key;   //块的关键字
        int start;  //块的起始值
        int end;    //块的结束值
    }index_table[4];     //定义结构体数组

    int block_search(int key,int a[])   //自定义实现分块查找
    {
        int i,j;
        i=1;
        while(i<=3&&key>index_table[i].key)    //确定在哪个块中
            i++;
        if(i>3)                 //大于分得的块数，则返回0
            return 0;
        j=index_table[i].start;  //j等于块范围的起始值
        while(j<=index_table[i].end&&a[j]!=key)   //在确定的块中顺序查找
            j++;
        if(j>index_table[i].end)   //如果大于块范围的结束值，则说明没有要查找的数,j置0
            j=0;
        return j;
    }

void main()
{
    int i,j=0,k,key,a[16];
    printf("请输入15个数：\n");
    for(i=1;i<16;i++)
        scanf("%d",&a[i]);
    for(i=1;i<=3;i++)
    {
        index_table[i].start=j+1;   //确定每个块范围的起始值
        j=j+1;
        index_table[i].end=j+4;     //确定每个块范围的结束值
        j=j+4;
        index_table[i].key=a[j];    //确定每个块范围中元素的最大值
    }
    printf("请输入你想查找的元素：\n");
    scanf("%d",&key);
    k=block_search(key,a);
    if(k!=0)
    {
        printf("查找成功，其位置是：%d\n",k);  //如果找到读数，则输出其位置
    }
    else
        printf("查找失效！\n");   //若未找到，则输出提示信息
}
*/
/*
    //哈希查找
    //要求如下：已知哈希表长度为11，哈希表函数为H(key)=key%11,随机产生待散列的小于50的8个元素
    //同时采用线性探测再散列的方法处理冲突。任意输入要查找的数据，无论是否找到均给出提示信息。
    #define max 11
    #define N 8
    int hashtable[max];

    int func(int value)    //用于返回哈希函数的值
    {
        return value % max;       //哈希函数
    }

    int search(int key)   //实现哈希查找
    {
        int pos,t;
        pos=func(key);    //哈希函数确定位置
        t=pos;       //t存放确定出的位置
        while(hashtable[t]!=key&&hashtable[t]!=-1)  //如果该位置不等于要查找的关键字且不为空
        {
            t=(t+1)%max;    //利用线性探测求出下一个位置
            if(pos==t)
                //如果经多次探测又回到原来用哈希函数求出的位置，则说明要查找的数不存在
                return -1;
        }
        if(hashtable[t]==-1)   //如果探测的位置是-1，则说明要查找的数不存在
            return NULL;
        else
            return t;
    }

    void creathash(int key)   //自定义函数创建哈希表
    {
        int pos,t;
        pos=func(key);   //哈希函数确定元素的位置
        t=pos;
        while(hashtable[t]!=-1)   //如果该位置有元素存在，则进行线性探测再散列
        {
            t=(t+1)%max;
            if(pos==t)   //如果冲突处理后确定的位置与原位置相同，则说明哈希表已满
            {
                printf("哈希表已满\n");
                return ;
            }
        }
        hashtable[t]=key;      //将元素放入确定的位置
    }

    void main()
    {
        int flag[50];
        int i,j,t;
        for(i=0;i<max;i++)
            hashtable[i]=-1;    //在哈希表中，初始位置全置-1
        for(i=0;i<50;i++)
            flag[i]=0;   //50以内所有数未产生时，均标志为0
        srand((unsigned long)time(0));//利用系统时间做种子产生随机数
        i=0;
        while(i!=N)
        {
            t=rand()%50;    //产生一个50以内的随机数赋给t
            if(flag[t]==0)   //查看是否产生过t
            {
                creathash(t);  //调用函数创建哈希表
                printf("%2d:",t);   //输出该元素
                for(j=0;j<max;j++)
                    printf("(%2d)",hashtable[j]);   //输出哈希表的内容
                printf("\n");
                flag[t]=1;   //将产生的这个数标志为1
                i++;
            }
        }
        printf("请输入你想查找的元素：");
        scanf("%d",&t);
        if(t>0&&t<50)
        {
            i=search(t);     //调用search()函数进行哈希查找
            if(i!=-1)
                printf("查找成功！其位置是：%d\n",i);   //若查找到该元素则输出其位置
            else
                printf("查找失败！");
        }
        else
            printf("输入有误！\n");
    }
*/
/*哈希函数的构造方法常用的有5种，分别是数字分析法、平方取中法、分段叠加、伪随机法和余数法，其中余数比较常用。因为本实例中已给出哈希函数所有
不用构造，直接按照题中给的哈希函数来运算即可。
虽然通过构造好的哈希函数可以减少冲突，但冲突是不可能完全避免的，所以就相应的产生了避免哈希冲突的常用的4种方法
分别是开放定址法（包括线性探测再散列和二次探测再散列）、链地址法、再哈希法和建立公共溢出区。
开放定址法中的线性再散列比较常用，该方法的特点是在冲突发生时，顺序查看表中的下一单元，直到找出一个空单元或查遍全表。
*/


/*
    //斐波那契数列
    //求数列的前30个元素，每行5个数
    void main()
    {
        long array[30];
        array[0]=array[1]=1;
        int i;
        int count=0;  //便于换行
        for(i=2;i<30;i++)
            array[i]=array[i-1]+array[i-2];
        printf("输出斐波拉契数列的前三十个元素：\n");
        for(i=0;i<30;i++)
        {
            count++;
            printf("%10d",array[i]);
            if(count==5)
            {
                printf("\n");
                count=0;
            }
        }
    }
*/

/*
     //哥德巴赫猜想
     //验证100以内的正偶数都能分解为两个素数之和，即验证哥德巴赫猜想对100以内（大于2）的正偶数
     //成立
     int ss(int i)
    //判断是否为素数
    {
        int j;
        if(i<=1)    //小于1的数不是素数
            return 0;
        if(i==2)    //2是素数
            return 1;
        for(j=2;j<i;j++)   //对大于2的数进行判断
        {
            if(i%j==0)
                return 0;
            else if(i!=j+1)
                continue;
                 else
                return 1;
        }
    }

    void main()
    {
        int i,j,k,flag1,flag2,n=0;
        for(i=4;i<100;i+=2)
            for(k=2;k<=i/2;k++)
            {
                j=i-k;
                flag1=ss(k);//判断拆分出的数是否是素数
                if(flag1)
                {
                    flag2=ss(j);
                    if(flag2)   //如果拆分出的两个数均是素数则输出
                    {
                        printf("%3d=%3d+%3d,",i,k,j);
                        n++;
                        if(n%5==0)
                            printf("\n");
                    }
                }
            }
            printf("\n");
    }
*/

/*

     //尼科彻斯定理
     //尼科彻斯定理的内容是：任何一个整数的立方都可以写成一串连续奇数的和。编程验证该定理
 void main()
 {
     int test;
     int i,j,k,l,flag=1;
     long long sum;
     long long result=1;
     printf("请输入一个整数：\n");
     scanf("%d",&test);
     int count=3;
     while(count)
     {
         result=test*result;
         count--;
     }
     //result=test*test*test;
     printf("%d\n",result);
     //验证
     i=result/2;
     if(i%2==0)
        i=i+1;   //当i为偶数时i值加一
     while(flag==1&&i>=1)  //当i大于等于1且flag=1时还行循环体语句
     {
         sum=0;
         k=0;
         while(1)
         {
             sum+=(i-2*k);     //奇数累加求和
             k++;
             if(sum==result) //如果sum与m相等，则输出累加过程
             {
                 printf("%d*%d*%d=%d=",test,test,test,result);
                 for(l=0;l<k-1;l++)
                    printf("%d+",i-l*2);
                 printf("%d\n",i-(k-1)*2);  //输出累加求和的最后一个数
                 flag=0;
                 break;
             }
             if(sum>result)
                break;
         }
         i-=2;    //如果i等于下一个奇数，则继续上面的过程
     }
 }
*/

/*
// 求100到200之间的素数
void main()
{
    int i,j,count=0;
    for(i=100;i<=200;i++)
        for(j=2;j<i;j++) //sqrt(i)可以缩短时间
       {
          if(i%j==0)
            break;
          if(i==j+1)
          {
            printf("%5d",i);
            count++;
            if(count==5)
            {
                printf("\n");
                count=0;
            }
          }
       }
}
*/

/*
//十进制转换为二进制
void main()
{
    int test;
    int i,j,m;
    printf("请输入一个十进制数（0~32767）：\n");
    scanf("%d",&test);
    int a[16]={0};
    //system("cls");    //清屏
    for(m=0;m<15;m++)    //for循环从0位到1位，最高位为符号位，本题始终为0
    {
        i=test%2;   //取2的余数
        j=test/2;    //取被2整除的结果
        test=j;      //将得到的商赋给变量test
        a[m]=i;
    }
    for(m=15;m>=0;m--)
    {
        printf("%d",a[m]);
        if(m%4==0)
            printf(" ");     //每输出4个元素，输出一个空格
    }
    printf("\n");
}
*/

/*
//n进制转换为十进制
//编程实现任意输入一个数，并输入几进制，即将其转换为十进制数并输出
void main()
{
    long t1;
    int i,n,t,t3;
    char a[100];
    printf("请输入数字：\n");
    gets(a);    //输入n进制数存到数组a中
    strupr(a);  //将a中的小写字母转换成大写字母
    t3=strlen(a);   //求数组a的长度
    t1=0;//为t1赋初值0
    printf("请输入进制n(2或8或16)：\n");
    scanf("%d",&n);
    for(i=0;i<t3;i++)
    {
        if(a[i]-'0'>=n&&a[i]<'A'||a[i]-'A'+10>=n)  //判断输入的数据与进制数是否相符
        {
            printf("输入有误！！\n");   //输出错误
            exit(0);    //退出程序
        }
        if(a[i]>='0'&&a[i]<='9')    //判断是否为数字
            t=a[i]-'0';       //求出该睡赋给t
        else if(n>=11&&(a[i]>='A')&&a[i]<='A'+n-10)   //判断是否为字母
                 t=a[i]-'A'+10;     //求出字母所代表的十进制数
        t1=t1*n+t;      //求出最终转换成的十进制数
    }
    printf("十进制形式是:\n%ld\n",t1);
}
*/


/*
//小球下落问题
//以求从100米高度自由落下，每次落地后反跳回原高度的一半，再落下。求它在第十次落地时，共经过多少米？
//第十次反弹多高

void main()
{
    float high=100,sum=100;
    int i;
    for(i=1;i<=9;i++)
    {
        high=high/2;      //每落地一次叹气高度变为原来的一半
        sum+=high*2;     //累积的高度和加上下一次落地后弹起与下落的高度
    }
    printf("总长度是：%f\n",sum);
    printf("第十次落地后弹起的高度是：%f",high/2);
    printf("\n");
}
*/


//巧分苹果
/*一家农户以果园为生，一天，父亲推出一车苹果，共2520个，准备分给他的6个儿子。父亲按事先写在
一张纸上的数字把这堆苹果分完，每个人分到的苹果个数都不相同。他说：老大，把你分到苹果的1/8
给老二，老二拿到后，连同原来的苹果分1/7给老三，老三拿到后，连同原来的苹果的1/6给老四，以此类推，最后
老六拿到后，连同原来的苹果分1/3给老大，这样，你们每个人分到的聘雇就一样多了。问：
兄弟六人原先各分到多少只苹果？*/
/*void main()
{
    int a[6]={0};
    int i;
    int average=2520/6;
    //首先计算出老六最后在给老大之前有多少苹果
    int temp=average*3/2;
    a[0]=(average-temp/3)*8/7;
    //  测试用printf("a[0]=%d\n",a[0]);
    a[1]=average*7/6-a[0]/8;
   // printf("a[1]=%d\n",a[1]);
    a[2]=average*6/5-average/6;
    a[3]=average*5/4-average/5;
    a[4]=average*4/3-average/4;
    a[5]=average*3/2-average/3;
    for(i=0;i<6;i++)
        printf("a[%d]= %d \n",i,a[i]);
}
*/
/*
void main()
{
    int x[7],y[7],s,i;
    s=2520/6;    //求出平均每个人要分多少个苹果
    for(i=2;i<=6;i++)
        //求老二到老六得到哥哥分来的苹果却未分给弟弟时的苹果数
        y[i]=s*(9-i)/(8-i);
    y[1]=x[1]=(s-y[6]/3)*8/7;
    //老大得到老六分来的苹果数却未分给弟弟时的苹果数
    for(i=2;i<=6;i++)
        x[i]=y[i]-y[i-1]/(10-i);    //求原来每人得到的苹果数
    for(i=1;i<=6;i++)
        printf("x[%d]=%d\n",i,x[i]);
}
*/