代码意识流——花朵数问题(八)
本文前一部分的链接
http://www.cnblogs.com/KBTiller/archive/2011/06/07/2074344.html
21.记录结果
由于无法保证输出的结果有序，所以只能把计算结果存储起来,待全部计算完毕再输出。
事先也无法知道花朵数的个数，所以链表是比较适宜的存储方式。这种方案同时很容易保证保证有序存储。
可以考虑用返回值的办法返回这个链表的head，也可以在main()中定义这个head，向qiongju()和xunhuan()传递&head。但是不难发现这两种方案参数总是要经历一系列无谓的传递，由于嵌套深度较深，求出结果的位置距离main()很远，所以不考虑这样的方案。代之以外部变量方案。
首先在xunhuan()中写出函数调用语句及函数原型
jilu( & he ); // void jilu( DASHU * ); //<=>记录结果
把// void jilu( DASHU * ); 移动到"2_穷举.h"中，此后"2_穷举.c"变为
/*2_穷举.c*/
#include "2_穷举.h"
#include "0_问题.h"
typedef unsigned int SHUZI_GESHU[JINZHI];
//SHUZI_GESHU[d]存储数字d的个数
typedef DASHU SHUJUBIAO[JINZHI-1][WEISHU + 1];
//0*(JINZHI-1)^N 1*(JINZHI-1)^N ……WEISHU*(JINZHI-1)^N
//0*(JINZHI-2)^N 1*(JINZHI-2)^N ……WEISHU*(JINZHI-1)^N
//……
//0*(1)^N 1*(1)^N ……WEISHU*(1)^N
static void xunhuan(const int , const int , DASHU (*)[WEISHU + 1] ) ;
static void jianli_sjb ( SHUJUBIAO * * ); //建立数据表
static SF wenhe( SHUZI_GESHU * const , const DASHU * const);
static SF wenhe( SHUZI_GESHU * const p_sz_gs ,
const DASHU * const p_he )
{
int sz_gs_he[JINZHI] = { 0 }; //和中各数字的个数
if( chaoguo_W(p_he) == SHI // 超过W位 || 不足W位
|| buzu_W (p_he) == SHI ){
return FOU ;
}
qiu_sz_gs( &sz_gs_he , p_he ); // 求和中各数字的个数
if ( memcmp ( sz_gs_he , *p_sz_gs , sizeof sz_gs_he )==0 ){
return SHI ;
}
return FOU ;
}
//建立数据表
static void jianli_sjb ( SHUJUBIAO * * p_p_sjb )
{
if( (* p_p_sjb = malloc(sizeof(SHUJUBIAO)) ) == NULL ){ //#include <stdlib.h>
exit(!EXIT_SUCCESS);
}
{
int i , j ;
for( i = 0 ; i < JINZHI - 1 ; i ++){
ds_fuzhi( *( * * p_p_sjb + i ) + 0 , 0 );//第一列为0
ds_fuzhi( *( * * p_p_sjb + i ) + 1 , 1 );//第二列先赋值为1
for( j = 0 ; j < N ; j ++ ){ //求N次幂
ds_chengyi( *( * * p_p_sjb + i ) + 1 , JINZHI - 1 - i );
}
for( j = 2 ; j <= WEISHU ; j ++ ){
(*( * * p_p_sjb + i ))[j] = (*( * * p_p_sjb + i ))[j-1] ;
ds_jiaru ( *( * * p_p_sjb + i ) + j , *( * * p_p_sjb + i ) + 1 ) ;
}
}
}
}
extern void qiongju( void )
{
SHUJUBIAO *p_sjb = NULL ;
jianli_sjb ( & p_sjb ); //建立数据表
xunhuan( WEISHU , JINZHI-1 , *p_sjb ) ;
free ( p_sjb );
}
static void xunhuan( const int gssx /*个数上限*/,
const int sz /*关于哪个数字*/,
DASHU (*p_hang)[WEISHU + 1] /*指向一行数据*/)
{
static DASHU he = { { 0 } } ;//static DASHU he ; // =0 待完成
DASHU he_ = he ; //记录累加前的值
static SHUZI_GESHU sz_gs ;
if( sz > 0 ){
int i;
for( i = 0 ; i <= gssx ; i++ ){
sz_gs[sz] = i ; //记录数字的个数
ds_jiaru ( &he , *p_hang + i ) ;
xunhuan( gssx - i , sz - 1 , p_hang + 1 );
he = he_ ; //恢复原来的值
}
}
else{
sz_gs[sz] = gssx ; //记录数字的个数
if( wenhe ( & sz_gs , &he ) == SHI ){ //验算两者是否"吻合"
jilu( & he ); //<=>记录结果
}
}
}
考虑在另一个模块完成这个函数，为此在工程中添加"4_结果.h"。
在"2_穷举.h" 中 // void jilu( DASHU * ); 之前加上 #include "4_结果.h",并把 // void jilu( DASHU * ); 复制到 "4_结果.h" 中，此后"2_穷举.h"变为
/*2_穷举.h*/
#ifndef QIONGJU_H
#define QIONGJU_H
/**************************类型定义**************************/
#include "3_大数.h"
#include "常用.h"
/**************************函数原型**************************/
extern void qiongju( void );
#include <stdlib.h> //malloc()
#include <string.h> //memcmp()
#include "4_结果.h" //void jilu(DASHU * );
#endif // QIONGJU_H
在 "4_结果.h" 中将 void jilu(DASHU * ); 改写为
extern void jilu(DASHU * );
并在其前面添加 #include "3_大数.h" 预处理命令。此时"4_结果.h"的内容为
/*4_结果.h*/
#ifndef JIEGUO_H
#define JIEGUO_H
/**************************类型定义**************************/
#include "3_大数.h"
/**************************函数原型**************************/
extern void jilu( DASHU * );
#endif // JIEGUO_H
在工程中添加"4_结果.c"，在"4_结果.c"定义extern void jilu( DASHU * );
/*4_结果.c*/
#include "4_结果.h"
extern void jilu( DASHU *p_ds )
{
}
由于链表很容易实现把数据依照顺序排列，所以采用链表存储已经求出的花朵数。首先定义节点的数据类型
/*4_结果.h*/
#ifndef JIEGUO_H
#define JIEGUO_H
/**************************类型定义**************************/
#include "3_大数.h"
typedef struct jd {
DASHU hds; //花朵数
struct jd *xiayige; //下一个
}
JIEDIAN;
/**************************函数原型**************************/
extern void jilu( DASHU * );
#endif // JIEGUO_H
定义“头”的位置：由于main()中有函数需要使用，且用函数返回值的办法传回过于繁琐也很不自然，所以这里使用外部变量。但将其作用范围限制在仅仅模块内能使用（static）。下面是加入了一个节点的代码及测试代码
/*4_结果.c*/
#include "4_结果.h"
static JIEDIAN *tou = NULL ;//头 //在4_结果.h中加入 #include <stdlib.h>
extern void jilu( DASHU *p_ds )
{
JIEDIAN **p_t = &tou ;
JIEDIAN *p_jd = NULL ;
if((p_jd=malloc( sizeof (JIEDIAN ) ))==NULL ){ // 添加节点
printf("无法存储");
exit(1);
}
else{
p_jd->hds = *p_ds ; //写入节点
}
while ( *p_t != NULL
/* || (*p_t)->hds 小于 *p_ds */ ) {
p_t = &(*p_t)->xyg ;
}
//加入到链表中
p_jd -> xyg = * p_t ;
* p_t = p_jd ;
#ifdef CESHI
ds_shuchu( &tou->hds );
system("PAUSE");
exit(2);
#endif
}
测试输出153，测试通过。
其中还有一个判断一大数是否小于另一大数的函数尚未完成，依照下面次序完成：
在本地写函数调用—>在本地写函数原型—>将函数原型移动到"4_结果.h"
此时"4_结果.c"为
/*4_结果.c*/
#include "4_结果.h"
static JIEDIAN *tou = NULL ;//头 //在4_结果.h中加入 #include <stdlib.h>
extern void jilu( DASHU *p_ds )
{
JIEDIAN **p_t = &tou ;
JIEDIAN *p_jd = NULL ;
if((p_jd = malloc( sizeof (JIEDIAN ) ))==NULL ){ // 添加节点
printf("无法存储");
exit(1);
}
else{
p_jd->hds = *p_ds ; //写入节点
}
while ( *p_t != NULL
|| ( xiaoyu(&(*p_t)->hds , p_ds ) == SHI ) // #include "常用.h"
/* || (*p_t)->hds 小于 *p_ds */ ) {
p_t = &(*p_t)->xyg ;
}
//加入到链表中
p_jd -> xyg = * p_t ;
* p_t = p_jd ;
#ifdef CESHI
ds_shuchu( &tou->hds );
system("PAUSE");
//exit(2);
#endif
}
->在"4_结果.h"中加上
#include "3_大数.h"
之后将函数原型移动到"3_大数.h"
/*4_结果.h*/
#ifndef JIEGUO_H
#define JIEGUO_H
/**************************类型定义**************************/
#include "3_大数.h"
typedef struct jd {
DASHU hds; //花朵数
struct jd *xyg; //下一个
}
JIEDIAN;
#include "常用.h"
/**************************函数原型**************************/
extern void jilu( DASHU * );
#include "3_大数.h" //xiaoyu()
#include <stdlib.h> //malloc(),NULL
#endif // JIEGUO_H
/*3_大数.h*/
#ifndef DASHU_H
#define DASHU_H
#include "0_问题.h" //DASHU用到了WEISHU
/**************************类型定义**************************/
//gw_sz[0]为个位，gw_sz[WEISHU-1]为最高位
//gw_sz[WEISHU-1]的值大于等于JINZHI表示溢出
typedef struct {
int gw_sz[WEISHU] ;
}
DASHU ;
#include "常用.h"
/**************************函数原型**************************/
extern void ds_fuzhi ( DASHU * const , const int ) ;
extern void ds_shuchu( const DASHU * const ) ;
extern void ds_jiaru ( DASHU * const , const DASHU * const ) ;
extern void ds_chengyi( DASHU * const , const int );
extern SF chaoguo_W(const DASHU * const);
extern SF buzu_W(const DASHU * const);
extern void qiu_sz_gs( int (*)[JINZHI] , const DASHU * const ) ;
extern SF xiaoyu ( const DASHU * const, const DASHU * const) ;
#endif // DASHU_H
->在"3_大数.c"中给出函数定义：
extern SF xiaoyu ( const DASHU * const p_ds1, const DASHU * const p_ds2)
{
int *t1 = p_ds1-> gw_sz , * w1 = t1 + WEISHU -1 ;
int *t2 = p_ds2-> gw_sz , * w2 = t2 + WEISHU -1 ;
while( w1 > t1 ){
if( *w1 < * w2){
return SHI ;
}
if( *w1-- > * w2-- ){
return FOU ;
}
}
if(*w1<*w2){
return SHI ;
}
return FOU ;
}
之后在main()中组织测试
#ifdef CESHI //测试
int main( void )
{
#define TEST_xiaoyu
#ifdef TEST_xiaoyu
#include "3_大数.h"
{
DASHU t1,t2 ;
ds_fuzhi(&t1,234);
ds_fuzhi(&t2,567);
printf("%d\n",xiaoyu(&t1,&t2)==SHI);
}
#endif
//……前面进行的其他测试（略）
system("PAUSE");
return 0;
}
#endif //CESHI
测试通过。至此，由qiongju()函数引出的全部函数完成。
22.输出结果
回到main()完成“//输出”部分
shuchu();//extern void shuchu(void);
依照下面次序
在本地写出函数调用—>在本地写函数原型—>将函数原型移动到"1_MAIN.h"
#ifdef QIUJIE //求解
int main( void )
{
//求解:穷举<=>验算<=>记录结果
qiongju();
//输出
shuchu();//extern void shuchu(void);
system("PAUSE");
return 0;
}
#endif //QIUJIE
->在"1_MAIN.h"中加上
#include "4_结果.h"
，之后将函数原型移动到"4_结果.h"
/*1_MAIN.h*/
#ifndef MAIN_H
#define MAIN_H
/**************************类型定义**************************/
/**************************函数原型**************************/
#include <stdlib.h> //system()
#include "2_穷举.h" //qiongju()
#include "4_结果.h"
#endif // MAIN_H
/*4_结果.h*/ #ifndef JIEGUO_H #define JIEGUO_H /**************************类型定义**************************/ #include "3_大数.h" typedef struct jd { DASHU hds; //花朵数 struct jd *xyg; //下一个 } JIEDIAN; #include "常用.h" /**************************函数原型**************************/ extern void jilu( DASHU * ); #include "3_大数.h" #include <stdlib.h> //malloc(),NULL extern void shuchu(void); #endif // JIEGUO_H
->在"4_结果.c"中给出函数定义
extern void shuchu(void)
{
while(tou!=NULL){
JIEDIAN *p_xyg = tou-> xyg ;
ds_shuchu(&tou->hds);
free( tou );
tou = p_xyg ;
}
tou = NULL ;
}
本以为一切都写完了，直接把"0_问题.h"中的
#define CESHI 改成了 #define QIUJIE
兴高采烈地编译运行，结果……发生了可怕的错误。
后经过仔细检查，发现错误出在extern void jilu( DASHU *p_ds )中
while ( *p_t != NULL
|| ( xiaoyu(&(*p_t)->hds , p_ds ) == SHI )
实际上却应为
while ( *p_t != NULL
&& ( xiaoyu(&(*p_t)->hds , p_ds ) == SHI )
教训就是，前面对这个函数测试的不充分。在完成xiaoyu()函数前，测试了加入一个节点的情形，完成xiaoyu()函数之后，本应再测试一次 jilu()函数，但由于完成在即，心存侥幸地偷懒了。
修正这个BUG之后，编译运行，程序的运行结果为
128468643043731391252
449177399146038697307
运行时间约10秒。
