求一个比较有意思的编程算法

根据题意可以将解题过程分为三步：

1)计算从1990年1月1日开始至指定日期共有多少天；

2)由于“打鱼”和“晒网”的周期为5天，所以将计算出的天数用5去除；

3)根据余数判断他是在“打鱼”还是在“晒网”；

若 余数为1，2，3，则他是在“打鱼”

否则 是在“晒网”

在这三步中，关键是第一步。求从1990年1月1日至指定日期有多少天，要判断经历年份中是否有闰年，二月为29天，平年为28天。闰年的方法可以用伪语句

描述如下：

如果 ((年能被4除尽 且 不能被100除尽)或 能被400除尽)

则 该年是闰年；

否则不是闰年。

C语言中判断能否整除可以使用求余运算(即求模)

*程序与程序注释

#include<stdio.h>

int days(struct date day)

struct date{

int year

int month

int day

}

void main()

{

struct date today,term

int yearday,year,day

printf("Enter year/month/day:")

scanf("%d%d%d",&today.year,&today.month,&today.day) /*输入日期*/

term.month=12 /*设置变量的初始值：月*/

term.day=31/*设置变量的初始值：日*/

for(yearday=0,year=1990year<today.yearyear++)

{

term.year=year

yearday+=days(term)/*计算从1990年至指定年的前一年共有多少天*/

}

yearday+=days(today) /*加上指定年中到指定日期的天数*/

day=yearday%5 /*求余数*/

if(day>0&&day<4) printf("he was fishing at that day.\n") /*打印结果*/

else printf("He was sleeping at that day.\n")

}

int days(struct date day)

{

static int day_tab[2][13]=

{{0,31,28,31,30,31,30,31,31,30,31,30,31,}, /*平均每月的天数*/

{0,31,29,31,30,31,30,31,31,30,31,30,31,},

}

int i,lp

lp=day.year%4==0&&day.year%100!=0||day.year%400==0

/*判定year为闰年还是平年，lp=0为平年，非0为闰年*/

for(i=1i<day.monthi++)/*计算本年中自1月1日起的天数*/

day.day+=day_tab[lp][i]

return day.day

}

*运行结果

Enter year/month/day:1991 10 25

He was fishing at day.

Enter year/month/day:1992 10 25

He was sleeping at day.

Enter year/month/day:1993 10 25

He was sleeping at day

冒泡排序（bubble sort） — O(n^2）

鸡尾酒排序(Cocktail sort，双向的冒泡排序) — O(n^2）

插入排序（insertion sort）— O(n^2)

桶排序（bucket sort）— O(n)需要 O(k) 额外空间

计数排序(counting sort) — O(n+k)需要 O(n+k) 额外空间

合并排序（merge sort）— O(nlog n)需要 O(n) 额外空间

原地合并排序— O(n^2)

二叉排序树排序 （Binary tree sort） — O(nlog n)期望时间； O(n^2)最坏时间； 需要 O(n) 额外空间

鸽巢排序(Pigeonhole sort) — O(n+k)需要 O(k) 额外空间

基数排序（radix sort）— O(n·k)需要 O(n) 额外空间

Gnome 排序— O(n^2)

图书馆排序— O(nlog n) with high probability，需要 （1+ε)n额外空间

不稳定的

选择排序（selection sort）— O(n^2)

希尔排序（shell sort）— O(nlog n) 如果使用最佳的现在版本

组合排序— O(nlog n)

堆排序（heapsort）— O(nlog n)

平滑排序— O(nlog n)

快速排序（quicksort）— O(nlog n) 期望时间，O(n^2) 最坏情况； 对于大的、乱数列表一般相信是最快的已知排序

Introsort— O(nlog n)

Patience sorting— O(nlog n+ k) 最坏情况时间，需要 额外的 O(n+ k) 空间，也需要找到最长的递增子串行（longest increasing subsequence）

不实用的

Bogo排序— O(n× n!) 期望时间，无穷的最坏情况。

Stupid sort— O(n^3)递归版本需要 O(n^2) 额外存储器

珠排序（Bead sort） — O(n) or O（√n)，但需要特别的硬件

Pancake sorting— O(n)，但需要特别的硬件

stooge sort——O（n^2.7）很漂亮但是很耗时