( [" E% x8 Q. h: a+ M2 l6 W 分析: 定义迭代变量为 n ,按照谷角猜想的内容,可以得到两种情况下的迭代关系式:当 n 为偶数时, n=n/2 ;当 n 为奇数时, n=n*3+1 。用 QBASIC 语言把它描述出来就是: 4 p3 O+ s& l. k' X
# ^& p" Z3 G! X+ m2 p0 \8 A/ S
if n 为偶数 then 8 }* ^/ N' d9 n' d$ C0 c! n$ o7 Q- k1 O# u* ]) H/ |
n=n/2 - r9 [+ v+ j7 T- ^8 L 3 L, `: K7 v5 r: F/ P/ V, ]4 u8 a else % E, { Q5 `' \" Y0 _) P
# n6 O' Y, u- q: I n=n*3+1 " K' ~" A" R6 L) j
1 ]$ W3 C- b( p3 X
end if $ n3 [0 d0 O \7 ~* z; h$ ^+ ]# ~) O5 v$ f' t
这就是需要计算机重复执行的迭代过程。这个迭代过程需要重复执行多少次,才能使迭代变量 n 最终变成自然数 1 ,这是我们无法计算出来的。因此,还需进一步确定用来结束迭代过程的条件。仔细分析题目要求,不难看出,对任意给定的一个自然数 n ,只要经过有限次运算后,能够得到自然数 1 ,就已经完成了验证工作。因此,用来结束迭代过程的条件可以定义为: n=1 。参考程序如下: 6 a: N" ^; Z- B% {1 |
: D& ?. a/ n3 Y* U5 g, D+ F q$ f8 V cls ) q7 o) `( ]$ W* g- B* `+ a. [3 j4 A7 P5 F7 j8 f( [6 L% g, }3 m0 ]
input "Please input n=";n * p! f; u4 _" G; t9 V
! V2 M/ k0 h. J5 \6 H/ W! N
do until n=1 1 H! U0 w# d$ u$ S: f# S/ W' [( \
' D. _* s1 w; m' C
if n mod 2=0 then ) l& f/ _5 p6 Z8 H- d* T! D" L) Q j( X% w! B8 o6 D
rem 如果 n 为偶数,则调用迭代公式 n=n/2 ! W2 b( ], w1 [: X# P$ m& ]
) @7 ]8 m5 _5 j1 [7 x9 y n=n/2 3 O% a/ ~/ u: D; n
" D) p3 }9 y! M5 x print "—";n; & [% P% N x" f/ r' d6 |- r) z8 ~9 i0 u, Y2 P P( n6 o
else ; _. o1 f: F& {2 t" x5 g p
& i6 Z% W$ p b: c- y0 `% K0 {+ Y6 t for (totv=0.0,k=0;k 0 k( C1 e# |; n) l( h " k* J) x- ]/ x. e6 K. ^ totv+=a[k].value; 5 h& f2 c5 B& J) V) N1 o) L m: S& x6 r! R% ?
next(0,0.0,totv); , T/ U+ M3 U7 L0 P. y0 K
; R0 F: ?/ o7 T- c4 Z7 ^ i=0; & Z; X" n6 T$ Y. }1 Q T. c7 k" y* g# ?7 r# n+ c While (i>=0) 7 k% L5 N; ^- u- \8 r0 b
8 H5 }3 O' D$ e { f=twv.; 5 n, ^8 ]2 z3 q- i s
1 ?1 b8 D" t. e j$ `$ B
tw=twv.tw; 2 ` l# r0 ?- P$ _) B
5 i9 F* Y/ c7 R) g6 ?4 F
tv=twv.tv; 9 O" _& R8 g: q
( x( V$ ^& t% p+ V; ]6 H2 I* V
switch(f) 5 n0 K& Q( S3 v! H9 a& V' k
1 E, A, @- R6 G$ R { case 1: twv.++; ! e! p6 w& _. e% o
3 Y& `& R" w& A
if (tw+a.weight<=limitW) : g i3 {+ h1 d7 b# o
: V$ Y& l: h, W3 p if (i : l. ?1 }% [. @9 Q$ f, X/ v
+ W# _( l( n- X
{ next(i+1,tw+a.weight,tv); # |" g8 r; K4 z& ^% S! u' s 5 U4 j2 P/ \6 @: d0 F% U i++; # p H8 B, X7 ?- i5 I m' y) T; \' c' q$ ~4 r0 M H7 u7 y2 A
} ( h7 _6 W3 ~# ?- E
8 K- D/ V+ ]4 p0 Y+ U
else 0 L9 F: w( ?1 @8 j" {3 Z$ u( h
" c/ U0 z4 |/ V8 Y6 i" c { maxv=tv; : u7 j& Q; `& _. J7 ^7 L
0 N+ P$ i+ P- W A/ k5 X& @
for (k=0;k ! z4 }& j( s, Y9 ^/ ?; g. U' Z/ D" Z3 S& N* O! ^
cop[k]=twv[k].!=0; 4 W8 X4 L' {/ Z, t. Y4 E ( _% y( c$ J) z" w! P } - G( F- Z6 e' K' G! ]0 T - M! s5 ^9 m1 b, X" T1 M break; 6 u! Z" H6 L, {% r3 w& F
3 N6 V+ b$ ?: L case 0: i--; 0 z, U4 K, N, E: V, y
) C, m' f; `9 @3 X" K7 n break; : |/ J: ~; x% W* E; s* E 6 `& o8 d Z4 H default: twv.=0; - G. F* n4 c* M- {; x
1 s# U/ d. `$ J9 ?3 A if (tv-a.value>maxv) " A) x* b6 Q9 y( o ?. `5 {) ?; x( X0 ~& ^
if (i , g! J' Q. n& U0 v& H- Q7 c 6 x1 y u. Q* a# O9 D { next(i+1,tw,tv-a.value); $ h* g8 k% a) Q, d1 E M+ }/ H
7 W, w1 I, ?. b
i++; 7 i1 y, g( _) t" E# X! d2 |! U+ |# T& D5 [; N. B6 ` A9 H$ @+ v9 s
} 7 C, _. @/ ]. O' s2 T6 y
2 x- f: f T c# L \, H" o
else 2 c7 x9 x' z1 k# B$ `& [/ S
9 Z/ K+ F B/ W h
{ maxv=tv-a.value; 8 }2 M6 |! w, m& ~
; S. E3 _ n8 V4 C- [. T( r: N for (k=0;k 2 \4 d# o( X7 h6 a, Y 3 l+ V9 I) R1 V6 U1 e( G cop[k]=twv[k].!=0; / n4 J6 K$ Z( x+ h% y9 m7 _( r8 f8 U9 y
} # q# W1 n+ q8 t! c
; m( s `! r$ f5 P
break; 1 `$ s. j0 N$ O8 O8 I
; T3 @0 ]: h0 s2 U' a: S
} J1 A1 ~5 _% b% S" E* P
- [. S8 h; ^" Z/ h! A6 Z* |0 J, g } 5 u' k% z) Y: D% k
2 p. h* r: q E: h/ L9 b; o return maxv; ) Z/ e% c$ T7 k( r% Q # F2 p `% L) x( E9 f } 1 o0 j4 a* T" q& g+ B3 B7 x7 c. X. C) G
void main() 2 D9 a/ t+ W! H
6 H: A0 ^* F" x/ j& V# e5 f, h
{ double maxv; 3 c5 h; o6 z6 R$ O/ K4 {; K# w6 E
printf(“输入物品种数\n”); . g( f* o' s: S* N
( o2 z/ u: Z6 d* U/ g scanf((“%d”,&n); # R0 [7 e" I+ R3 A& N; d) M- \1 R0 W6 `1 A c* {+ X; ?/ P
printf(“输入限制重量\n”); ' k. F/ f+ j* ~* }* V4 L% d) D) }/ [' t% d! ~( C6 k1 x, d6 g
scanf(“%1f”,&limitW); / [' {1 ^& A. I0 W: A# K: i; r( f
" J% r& Q+ L0 p! S9 K! E: U& k u printf(“输入各物品的重量和价值\n”); 2 `* M1 o, {) |- X5 I6 }6 _: M r; j- n# C
for (k=0;k - L- i4 X/ P/ O3 F* K; Q 4 P8 o4 ~; p5 u2 f scanf(“%1f%1f”,&a[k].weight,&a[k].value); 3 \% t1 V2 d3 P 7 O' p5 T* |8 O' @ maxv=find(a,n); 2 O2 }+ |2 X3 x7 ?3 C! v3 Y3 |* G5 [
5 L+ e$ t$ Z2 n' U printf(“\n选中的物品为\n”); 3 K$ D: C, A9 J* A0 m3 ` - M2 b( n0 C/ l* T( a. y7 G8 n for (k=0;k 1 X8 S% N! i% D
6 b0 I! s% V& l8 G% Y) p
if (option[k]) printf(“%4d”,k+1); - J! [- s& \" K! q1 Y* Z& P! W
- U; `. |7 |6 v$ f! x7 v printf(“\n总价值为%.2f\n”,maxv); 6 I& M% k/ M0 l5 V( l : S+ l3 k9 k0 F1 ~+ `( p } w. D4 X* x: N9 i6 D3 n9 @. W# Y6 j- D4 r
递归的基本概念和特点 - }. `0 _4 E F, E5 G9 C) e" q: }) R# m0 b! {
程序调用自身的编程技巧称为递归( recursion)。 " r* \( g3 ~+ E
0 r! f6 Y. u2 a; G. A8 A1 E' ]8 ]
一个过程或函数在其定义或说明中又直接或间接调用自身的一种方法,它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解,递归策略只需少量的程序就可描述出解题过程所需要的多次重复计算,大大地减少了程序的代码量。递归的能力在于用有限的语句来定义对象的无限集合。用递归思想写出的程序往往十分简洁易懂。 , o) Q6 F7 z9 x( S+ O
' L/ L( L0 A% w8 q6 a [9 f6 @
一般来说,递归需要有边界条件、递归前进段和递归返回段。当边界条件不满足时,递归前进;当边界条件满足时,递归返回。 ' f B. Z6 W g1 ^: k! E2 D& T9 M0 G1 X3 P9 W. N7 R# Q* }
注意: # i+ U: {; }3 C" A3 e( y* D, Z! Q' `4 Q4 i4 F: M; |( ^
(1) 递归就是在过程或函数里调用自身; 6 U# f+ l2 s" G% M* q l/ l" [* O. o) b" L5 {; D# f7 @
(2) 在使用递增归策略时,必须有一个明确的递归结束条件,称为递归出口。