1、Data Structures and Algorithm 习题答案Preface ii 1 Data Structures and Algorithms 1 2 Mathematical Preliminaries 5 3 Algorithm Analysis 17 4 Lists, Stacks, and Queues 23 5 Binary Trees 32 6 General Trees 40 7 Internal Sorting 46 8 File Processing and External Sorting 54 9Searching 58 10 Indexing 64 11 G
2、raphs 69 12 Lists and Arrays Revisited 76 13 Advanced Tree Structures 82 i ii Contents 14 Analysis Techniques 88 15 Limits to Computation 94 Preface Contained herein are the solutions to all exercises from the textbook A Practical Introduction to Data Structures and Algorithm Analysis, 2nd edition.
3、For most of the problems requiring an algorithm I have given actual code. In a few cases I have presented pseudocode. Please be aware that the code presented in this manual has not actually been compiled and tested. While I believe the algorithms to be essentially correct, there may be errors in syn
4、tax as well as semantics. Most importantly, these solutions provide a guide to the instructor as to the intended answer, rather than usable programs. 1 Data Structures and Algorithms Instructors note: Unlike the other chapters, many of the questions in this chapter are not really suitable for graded
5、 work. The questions are mainly intended to get students thinking about data structures issues. 1.1 This question does not have a specific right answer, provided the student keeps to the spirit of the question. Students may have trouble with the concept of “operations.” 1.2 This exercise asks the st
6、udent to expand on their concept of an integer representation. A good answer is described by Project 4.5, where a singly-linked list is suggested. The most straightforward implementation stores each digit in its own list node, with digits stored in reverse order. Addition and multiplication are impl
7、emented by what amounts to grade-school arithmetic. For addition, simply march down in parallel through the two lists representing the operands, at each digit appending to a new list the appropriate partial sum and bringing forward a carry bit as necessary. For multiplication, combine the addition f
8、unction with a new function that multiplies a single digit by an integer. Exponentiation can be done either by repeated multiplication (not really practical) or by the traditional (log n)-time algorithm based on the binary representation of the exponent. Discovering this faster algorithm will be bey
9、ond the reach of most students, so should not be required. 1.3 A sample ADT for character strings might look as follows (with the normal interpretation of the function names assumed). Chap. 1 Data Structures and Algorithms / Concatenate two strings String strcat(String s1, String s2); / Return the l
10、ength of a string int length(String s1); / Extract a substring, starting at start, / and of length length String extract(String s1, int start, int length); / Get the first character char first(String s1); / Compare two strings: the normal C+ strcmp function. Some / convention should be indicated for
11、 how to interpret the / return value. In C+, this is 1 for s1s2. int strcmp(String s1, String s2) / Copy a string int strcpy(String source, String destination) 1.4 The answer to this question is provided by the ADT for lists given in Chapter 4. 1.5 Ones compliment stores the binary representation of
12、 positive numbers, and stores the binary representation of a negative number with the bits inverted. Twos compliment is the same, except that a negative number has its bits inverted and then one is added (for reasons of efficiency in hardware implementation). This representation is the physical impl
13、ementation of an ADT defined by the normal arithmetic operations, declarations, and other support given by the programming language for integers. 1.6 An ADT for two-dimensional arrays might look as follows. Matrix add(Matrix M1, Matrix M2); Matrix multiply(Matrix M1, Matrix M2); Matrix transpose(Mat
14、rix M1); void setvalue(Matrix M1, int row, int col, int val); int getvalue(Matrix M1, int row, int col); List getrow(Matrix M1, int row); One implementation for the sparse matrix is described in Section 12.3 Another implementation is a hash table whose search key is a concatenation of the matrix coo
15、rdinates. 1.7 Every problem certainly does not have an algorithm. As discussed in Chapter 15, there are a number of reasons why this might be the case. Some problems dont have a sufficiently clear definition. Some problems, such as the halting problem, are non-computable. For some problems, such as
16、one typically studied by artificial intelligence researchers, we simply dont know a solution. 1.8 We must assume that by “algorithm” we mean something composed of steps are of a nature that they can be performed by a computer. If so, than any algorithm can be expressed in C+. In particular, if an al
17、gorithm can be expressed in any other computer programming language, then it can be expressed in C+, since all (sufficiently general) computer programming languages compute the same set of functions. 1.9 The primitive operations are (1) adding new words to the dictionary and (2) searching the dictio
18、nary for a given word. Typically, dictionary access involves some sort of pre-processing of the word to arrive at the “root” of the word. A twenty page document (single spaced) is likely to contain about 20,000 words. A user may be willing to wait a few seconds between individual “hits” of mis-spell
19、ed words, or perhaps up to a minute for the whole document to be processed. This means that a check for an individual word can take about 10-20 ms. Users will typically insert individual words into the dictionary interactively, so this process can take a couple of seconds. Thus, search must be much
20、more efficient than insertion. 1.10 The user should be able to find a city based on a variety of attributes (name, location, perhaps characteristics such as population size). The user should also be able to insert and delete cities. These are the fundamental operations of any database system: search
21、, insertion and deletion. A reasonable database has a time constraint that will satisfy the patience of a typical user. For an insert, delete, or exact match query, a few seconds is satisfactory. If the database is meant to support range queries and mass deletions, the entire operation may be allowe
22、d to take longer, perhaps on the order of a minute. However, the time spent to process individual cities within the range must be appropriately reduced. In practice, the data representation will need to be such that it accommodates efficient processing to meet these time constraints. In particular,
23、it may be necessary to support operations that process range queries efficiently by processing all cities in the range as a batch, rather than as a series of operations on individual cities. 1.11 Students at this level are likely already familiar with binary search. Thus, they should typically respo
24、nd with sequential search and binary search. Binary search should be described as better since it typically needs to make fewer comparisons (and thus is likely to be much faster). 1.12 The answer to this question is discussed in Chapter 8. Typical measures of cost will be number of comparisons and n
25、umber of swaps. Tests should include running timings on sorted, reverse sorted, and random lists of various sizes. Chap. 1 Data Structures and Algorithms 1.13 The first part is easy with the hint, but the second part is rather difficult to do without a stack. a) bool checkstring(string S) int count
26、= 0; for (int i=0; i 0. It is symmetric since xy = yx. It is transitive since any two members of the given class satisfy the relationship. 5 Chap. 2 Mathematical Preliminaries (d) This is not an equivalance relation since it is not symmetric. For example, a =1and b =2. (e) This is an eqivalance rela
27、tion that divides the rationals based on their fractional values. It is reflexive since for all a, a.a =0. It is symmetric since if a.b =x then b.a =.x. It is transitive since any two rationals with the same fractional value will yeild an integer. (f) This is not an equivalance relation since it is
28、not transitive. For example, 4. 2=2and 2. 0=2,but 4. 0=4. 2.3 A relation is a partial ordering if it is antisymmetric and transitive. (a) Not a partial ordering because it is not transitive. (b) Is a partial ordering bacause it is antisymmetric (if a is an ancestor of b, then b cannot be an ancestor
29、 of a) and transitive (since the ancestor of an ancestor is an ancestor). (c) Is a partial ordering bacause it is antisymmetric (if a is older than b, then b cannot be older than a) and transitive (since if a is older than b and b is older than c, a is older than c). (d) Not a partial ordering, sinc
30、e it is not antisymmetric for any pair of sisters. (e) Not a partial ordering because it is not antisymmetric. (f) This is a partial ordering. It is antisymmetric (no violations exist) and transitive (no violations exist). 2.4 A total ordering can be viewed as a permuation of the elements. Since the
31、re are n!permuations of n elements, there must be n!total orderings. 2.5 This proposed ADT is inspired by the list ADT of Chapter 4. void clear(); void insert(int); void remove(int); void sizeof(); bool isEmpty(); bool isInSet(int); 2.6 This proposed ADT is inspired by the list ADT of Chapter 4. Not
32、e that while it is similiar to the operations proposed for Question 2.5, the behaviour is somewhat different. void clear(); void insert(int); void remove(int); void sizeof(); 7 bool isEmpty(); / Return the number of elements with a given valueint countInBag(int); 2.7 The list class ADT from Chapter
33、4 is a sequence. 2.8 long ifact(int n) / make n = 0) for (int i=1; i= n; i+) fact = fact * i; return fact; 2.9 void rpermute(int *array, int n) swap(array, n-1, Random(n); rpermute(array, n-1); 2.10 (a) Most people will find the recursive form natural and easy to understand. The iterative version re
34、quires careful examination to understand what it does, or to have confidence that it works as claimed. (b) Fibr is so much slower than Fibi because Fibr re-computes the bulk of the series twice to get the two values to add. What is much worse, the recursive calls to compute the subexpressions also r
35、e-compute the bulk of the series, and do so recursively. The result is an exponential explosion. In contrast, Fibicomputes each value in the series exactly once, and so its running time is proportional to n. 2.11 / Array curri indicates current position of ring i. void GenTOH(int n, POLE goal, POLE
36、t1, POLE t2, POLE* curr) if (currn = goal) / Get top n-1 rings set up GenTOH(n-1, goal, t1, t2, curr); else if (currn = t1) swap(t1, t2); / Get names right / Now, ring n is on pole t2. Put others on t1. GenTOH(n-1, t1, goal, t2, curr); move(t2, goal); GenTOH(n-1, goal, t1, t2, curr); / Move n-1 back
37、 2.12 At each step of the way, the reduction toward the base case is only half as far as the previous time. In theory, this series approaches, but never reaches, 0, so it will go on forever. In practice, the value should become computationally indistinguishable from zero, and terminate. However, thi
38、s is terrible programming practice. Chap. 2 Mathematical Preliminaries 2.13 void allpermute(int array, int n, int currpos) if (currpos = (n-1) printout(array); return; for (int i=currpos; in; i+) swap(array, currpos, i); allpermute(array, n, currpos+1); swap(array, currpos, i); / Put back for next p
39、ass 2.14 In the following, function bitposition(n, i) returns the value (0 or 1) at the ith bit position of integer value n. The idea is the print out the elements at the indicated bit positions within the set. If we do this for values in the range 0 to 2n . 1, we will get the entire powerset. void
40、powerset(int n) for (int i=0; iipow(2, n); i+) for (int j=0; jn; j+) if (bitposition(n, j) = 1) cout j “ “; cout endl; 2.15 Proof: Assume that there is a largest prime number. Call it Pn,the nth largest prime number, and label all of the primes in order P1 =2, P2 =3, and so on. Now, consider the num
41、ber C formed by multiplying all of the n prime numbers together. The value C +1is not divisible by any of the n prime numbers. C +1is a prime number larger than Pn, a contradiction. Thus, we conclude that there is no largest prime number. . 2.16 Note: This problem is harder than most sophomore level
42、 students can handle. Proof: The proof is by contradiction. Assume that 2is rational. By definition, there exist integers p and q such that p2=, q where p and q have no common factors (that is, the fraction p/q is in lowest terms). By squaring both sides and doing some simple algebraic manipulation,
43、 we get 2p2= 2q222q = p Since p2 must be even, p must be even. Thus, 9 222q =4(p)222 q =2(p)2This implies that q2 is also even. Thus, p and q are both even, which contra dicts the requirement that p and q have no common factors. Thus, 2must be irrational. . 2.17 The leftmost summation sums the integ
44、ers from 1 to n. The second summation merely reverses this order, summing the numbers from n . 1+1=n down to n . n +1=1. The third summation has a variable substitution of i.1for i, with a corresponding substitution in the summation bounds. Thus, it is also the summation of n . 0=n to n . (n . 1)=1.
45、 2.18 Proof: (a) Base case. For n =1, 12 = 2(1)3 +3(1)2 +1/6=1. Thus, the formula is correct for the base case. (b) Induction Hypothesis. n.1 2(n . 1)3 +3(n . 1)2 +(n . 1)i2 = .6 i=1 (c) Induction Step. nn.1 i2 i2 +n 2= i=1 i=1 2(n . 1)3 +3(n . 1)2 +(n . 1) 2= +n6 2n3 . 6n2 +6n . 2+3n2 . 6n +3+n . 1
46、 2= +n6 2n3 +3n2 +n = .6 Thus, the theorem is proved by mathematical induction. . 2.19 Proof: (a) Base case. For n =1, 1/2=1. 1/2=1/2. Thus, the formula is correct for the base case. (b) Induction Hypothesis. n.1 11=1. .2in.12i=1 Chap. 2 Mathematical Preliminaries (c) Induction Step. nn.11 11 =+i in
47、222i=1 i=1 11=1. + n.1 n221=1. . n2Thus, the theorem is proved by mathematical induction. . 2.20 Proof: (a) Base case. For n =0, 20 =21 . 1=1. Thus, the formula is correct for the base case. (b) Induction Hypothesis. n.1 2i =2n . 1. i=0 (c) Induction Step. nn.1 2i =2i +2n i=0 i=0 n=2n . 1+2n+1 . 1=2
48、. Thus, the theorem is proved by mathematical induction. . 2.21 The closed form solution is 3n+1.3, which I deduced by noting that 3F (n).2 n+1 . 3F (n)=2F (n)=3. Now, to verify that this is correct, use mathematical induction as follows. For the base case, F (1)=3=32.3 .2 n.1The induction hypothesi
49、s is that =(3n . 3)/2.i=1 So, nn.1 3i =3i +3n i=1 i=1 3n . 3 n= +32 n+1 . 33= .2 Thus, the theorem is proved by mathematical induction. 11 n2.22 Theorem 2.1 (2i)=n2 +n.i=1(a) Proof: We know from Example 2.3 that the sum of the first n odd numbers is n2.The ith even number is simply one greater than the ith odd number. Since we are adding nsuch numbers, the sum must be n greater, or n2 +n. . (b) Proof: Base case: n=1yields 2=12 +1, which is true. Induction Hypothesis: n.1 2i=(n. 1)2 +(n. 1). i=1 Induct
