cs3460_ch1 Data Structures 美国高校《数据结构》(Data Structure)ppt课件,共9章,英文版

Series - 2
• The top three examples are arithmetic series
• Proofs are typically by induction, which we will see in a minute
• The series for HN is a harmonic series; the eo Euler’s constant 0.57721..
• Then show p1 * p2 * p3 * … * pk + 1 is a prime and it is clearly larger than pk
Recursion
• Some mathematical functions are naturally recursive
– factorial: n! =
• Two steps –
– Prove a base case, for example, if you want to prove a theorem for any integer value n >= 1, you would first prove it for n = 1
– Assuming the theorem is true for values 1..k for some arbitrary k, prove it is true for k + 1
Proof by Induction - 2
• We first prove the base case with n = 1, which results in 1 = 1 (1 + 1) (2 * 1 + 1) / 6
• To prove the general case, we let n = k and prove the formula for k+1 using algebraic manipulation
• This course is perhaps the most important step in becoming a professional systems analyst. You will learn data structures and the analysis of algorithms using C++.
• Recursive functions have a base case that is solved directly and a general case that makes progress towards a solution
A First Recursive Function
• The mathematical function /* 1*/ int
int Bad( const int N ) {
if( N == 0 ) return 0;
else return Bad( N / 3 + 1 ) + N - 1;
}
• What values work correctly?
• What values never terminate?
• Where does the function get stuck?
• Email: blk@
• If you cannot find me at school and need to contact me, feel free to contact me at my home: 288 Chase Hill Drive, Boone, 828-263-9862
• Recursion can be used to reverse actions since it is based on a stack of activation records
of k • It only takes one counter-example to show the
relation is false
• Proof by counter-example is not too common, but it is easy to apply when applicable
Proof by Contradiction
• Proof by contradiction is a very common way to prove theorems, it is based on the logical relation p q iff q p
• If we assume what we want to prove is false and then show this leads to a contradiction, then what we wanted to prove must be true
• The bottom two formulas are algebraic manipulation
Modular Arithmetic
• a b (mod n) if n divides a – b • Example: 5 12 54 (mod 7) • If a b (mod n) then a + d b + d (mod n) • Example: 12 54 (mod 7) so 22 64 (mod 7) • If a b (mod n) then a * d b * d (mod n) • Example: 12 54 (mod 7) so 36 162 (mod 7) • Modular arithmetic is a very important part of
A Nonterminating Recursive Function
• There are several reasons for a recursive function not to terminate successfully
– the function does not make progress towards the base case
return 2 * F( X - 1 ) + X * X; }
F(2)? F(3)? F(4)?
• It is important that the
• Lines 4 and 5 are the base case
• Lines 6 and 7 are the general case
general case make progress towards a solution AND eventually reach the base case
– the function makes progress but “misses” the base case
• Hand trace the execution of Bad(0), Bad(1), Bad(2) and Bad(3)
/* 1*/ /* 2*/ /* 3*/ /* 4*/ /* 5*/ /* 6*/ /* 7*/ /* 8*/
• Follow along as we show this proof as a group
Proof by Counter-example
• For this theorem, Fk are the Fibonacci numbers • For Fk <= k2 to be true, it must be true for all values
• This process is very similar to writing a recursive algorithm, which you will learn to do well in this course
• Assume Fk+1 = Fk + Fk-1 (the Fibonacci sequence), we want to show the bound Fk+1 < (5/3) k+1
1 if n = 0
n * (n-1)! if n > 0
– fibonacci: f(n) = 1 if n = 0 or 1 f(n-1) + f(n-2) if n > 1
• Modern programming languages allow the
programmer to write recursive functions directly
Series - 1
• These are called geometric series; each term changes by multiplying by a constant value
• The middle formula is the most general
• The bottom formula is important for converging series; try the value of a = ½, we have 1 + ½ + ¼ + 1/8 + 1/16 + ….. <= 2 The limit of the infinite series is the value of 2
/* 2*/ F( const int X )
is:
/* 3*/ {
F(x) = 0 if x = 0 2 * F(x-1) + x2
/* 4*/ /* 5*/ /* 6*/
if( X == 0 ) return 0;
else
if x > 0
/* 7*/
/* 8*/
• What are the values of F(1)?
number theory and will be studied more in an advanced analysis of algorithms class when you study data encryption and decryption