You are on page 1of 30

Answers to Selected Exercises

Chapter 1
Many of the questions in this chapter's exercise are "thought questions." The answers
given here are typical or suggested responses, but are not the only possible answers.
1.Software engineering is a disciplined approach to the creation and maintenance
of computer programs throughout their whole life cycle.
4.Some software tools used in developing computer programs are text editors,
compilers, assemblers, operating systems, and debugging programs.
7.Goal 4 says, "Quality software is completed on time and within budget."
(a)When a student does not complete a programming assignment on time, it
usually hurts his or her grade. Also, some concepts that were to be learned in
preparation for the next programming assignment may not be mastered in time
to be put into practice.
(b)When a team developing a highly competitive new software product does
not complete its work on time, the company must continue to pay salaries, ofce
rent, etc., increasing the "development cost" of the product. The product may go
on the market late, after competing products have been released, hurting its sales.
This may have an efect on the team members' professional evaluations (like a
student's grade).
10.An object is an individual while a class is a description of a group of objects with
similar properties and behaviors. Labrador dogs is an example of a class and
Maggie is an example of an object.
14.An expert understanding of your programming language saves you time and
debugging because (a) you can avoid syntax errors, (b) you can more quickly
identify and correct those syntax errors that occur, and (c) you can avoid errors
caused by a misunderstanding of the way the language works.
17.The body of the While loop is not in brackets.
The comments include the call to Increment.
The parameter to Increment is not a reference parameter.
20.Unit testing is the testing of a single unit of the program (for instance, a function).
Integration testing is the testing of groups of already tested units to make sure that
they interact correctly and that the whole program works according to its
specifcation.
23.(a)The functional domain consists of the whole numbers from 0 to 100.
(b)It is possible to carry out exhaustive data coverage for this program.
(c)Devise a test plan for this program.
Input: All values from 1 to 100.
Expected Output: For input 0-59 F
For input 60-69 D
For input 70-79 C
For input 80-89 B
For input 90-100 A
26.Life-cycle verifcation refers to the idea that program verifcation activities can be
performed throughout the program's life cycle, not just by testing the program
after it is coded.
29. (a) num and denom are both just integer values. Each can be either negative or
positive. In a fraction the numerator carries the sign. The denominator should
always be positive.
(b) IsNotProper needs to be changed to use the absolute value of the
numerator. Function Initialize (or any constructor) should check to be sure the
denominator is strictly positive and throw an exception if this is not the case.
(c)The following tests need to be added to the test plan.
Operation to Be Tested and Description of
Action
Input
Values
Expected Output
Initialize -3,4 Numerator: -3
Denominator: 4
IsNotProper Fraction is proper
Initialize -13,4 Numerator: -13
Denominator: 4
IsNotProper Fraction is improper
ConvertToProper Whole number is 3
Numerator is -1
Denominator is 4
Chapter 2
2.Data encapsulation is the separation of the physical representation of data from
the applications that use the data at a logical (abstract) level. When data
abstraction is protected through encapsulation, the data user can deal with the
data abstraction but cannot access its implementation, which is encapsulated. The
data user accesses data that is encapsulated through a set of operations specifed
to create, access, and change the data. Data encapsulation is accomplished
through a programming language feature.
5.array, struct, union, and classes
8.The syntax of the component selector is the array name followed by the index of
the desired item:
array-name[index-expression]
11.(a)
typedef WeatherType WeatherListType[12];
WeatherListType yearlyWeather;
(b)yearlyWeather[6].actualRain = 1.05;
(c)238
14.Member-length-ofset table for StudentRecord.
Field Length Ofset
frstName 10 0
lastName 10 10
id 1 20
gpa 2 21
currentHours 1 23
totalHours 1 24
17.(a)A square two-dimensional array
(b)struct or class
(c)struct or class containing two data members: the number of quotations and
an array of strings that holds them
(d)a one-dimensional integer array
(e)a two-dimensional integer array
(f)a three-dimensional integer array
(g)an array of structs or classes
(h)a one-dimensional integer array
20.The members of a class are private unless specifed as public. Client code cannot
access private members.
23.Classes can relate to one another through inheritance, containment
(composition), and not at all.
28.(a)
SquareMatrix ADT Specifcation
Structure: An NxN square integer matrix.
Operations :
MakeEmpty(int n)
Function: Initializes the size of the matrix to n and sets the values
to zero.
Precondition: n is less than or equal to 10.
Postconditions: Matrix contains all zero values.
StoreValue(int i, int j, int value)
Function: Stores value into the i,jth position in the matrix.
Preconditions Matrix has been initialized; i and j are between 0 and the
size minus 1.
Postconditions: value has been stored into the i,jth position of the
matrix.
Add(SquareMatrixType one, SquareMatrixType two, SquareMatrixType
result)
Function: Adds matrix one and matrix two and stores the result in
result.
Precondition: one and two have been initialized and are the same
size.
Postcondition: result = one + two.
Subtract(SquareMatrixType one, SquareMatrixType two,
SquareMatrixType result)
Function: Subtracts two from one and stores the result in result.
Precondition: one and two have been initialized and are the same
size.
Postcondition: result = one - two.
Print(SquareMatrixType one)
Function: Prints the matrix on the screen.
Precondition: Matrix has been initialized.
Postcondition: The values in the matrix have been printed by row on
the screen.
Copy(SquareMatrixType one, SquareMatrixType two)
Function: Copies two into one.
Precondition: two has been initialized.
Postcondition: one = two.
(b)
The following declaration contains only additional pre/post conditions required
by the implementation.
class SquareMatrixType
{
public:
void MakeEmpty(int n);
// Pre: n is less than or equal to 50.
// Post: n has been stored into size.
void StoreValue(int i, int j, int value);
// Pre: i and j are less than or equal to size.
void Add(SquareMatrixType two, SquareMatrixType
result);
// Post: result = self + two.
void Subtract(SquareMatrixType two, SquareMatrixType
result);
// Post: result = self - two.
void Print();
// Post: The values in self have been printed by row on
the screen.
void Copy(SquareMatrixType two);
// Post: self = two
private:
int size; // Dimension of the matrix.
int matrix[10][10];
};
(c)
void SquareMatrixType::MakeEmpty(int n)
{
size = n;
for (int row = 0; row < size; row++)
for (int col = 0; col < size; col++)
matrix[row][col] = 0;
}

void SquareMatrixType::StoreValue(int i, int j, int value)
{
matrix[i][i] = value;
}

void SquareMatrixType::Add(SquareMatrixType two, SquareMatrixType
result)
{

for (int row = 0; row < size; row++)
for (int col = 0; col < size; col++)
result.matrix[row][col] = matrix[row][col] +
two.matrix[row][col];
}

void SquareMatrixType::Subtract(SquareMatrixType two,
SquareMatrixType result)
{
for (int row = 0; row < size; row++)
for (int col = 0; col < size; col++)
result.matrix[row][col] = matrix[row][col] -
two.matrix[row][col];
}

void SquareMatrixType::Print()
{
for (int row = 0; row < size; row++)
for (int col = 0; col < size; col++)
cout << matrix[row][col];
}

void SquareMatrixType::Copy(SquareMatrixType two)
{
for (int row = 0; row < size; row++)
for (int col = 0; col < size; col++)
matrix[row][col] = two.matrix[row][col];
}
(d)
This test plan is a black box strategy with data values representing the end cases
and a general case. For matrix operations, the end cases represent the size of the
matrices, not the values stored in them. We assume that integer addition and
subtraction are correct.
Operation to be Tested and Description of Action Input
Values
Expected
Output
MakeEmpty
execute and print
execute and print
execute and print
2
0
50
0 0
0 0
no output
50x50 matrix of
zeros
StoreValue
MakeEmpty(2)
store
store
store
print
1,1,2
1,2,3
2,2,4
2 3
0 4
Add
General Case
Create a second matrix
Add to first one created and print
End Case (size 0)
Add two empty matrices and print
End Case (size 50)
Create a 50x50 matrix of ones
Create a 50x50 matrix of twos
Add and print
1 2
3 4
3 5
3 8
no output
50x50 of threes
Subtract
General Case
Subtract the first from the second and print

End Case (size 0)
Subtract two size 0 matrices and print
End Case (size 50)
Subtract all ones from all twos
-1 -1
3 0
no output
50x50 of ones
Copy
Copy first and print
Copy a size 0 matrix and print
Copy a size 50 matrix of twos and print
2 3
0 4
no output
50x50 of twos
31. If functions GetMonthAsString and Adjust are called frequently, then the frst
version is more efcient because access to the string or number of days would be
O(1). On the other hand, if these functions are called only once, it would be
better to calculate these values and store them. The second alternative would
require two new class variables, one to hold the string and one to hold the
number of days, but the auxiliary arrays would no longer be need.
Chapter 3
1.(a)
Boolean IsThere(ItemType item)
Function: Determines if item is in the list.
Precondition: List has been initialized.
Postcondition:Function value = there exist an item in the list whose key
is the same as item's.
(b)
bool IsThere(ItemType item) const;
(d)O(N) where N is the number of items in the list.
5.(a)
DeleteItem (ItemType item )
Function: Deletes the element whose key matches item's key.
Preconditions: List has been initialized.
Key member of item is initialized.
At most one element in list has a key matching item's key.
Postcondition: If an element in list had a key matching item's key, the item
has been removed; otherwise, the list is unchanged.
(c)
DeleteItem (ItemType item )
Function: Deletes the element whose key matches item's key.
Preconditions: List has been initialized.
Key member of item is initialized.
Postcondition: No element in list has a key matching item's key.
8.(a)True
(b)True
(c)False. A linked list is not a random-access structure.
(d)False. A sequential list may be stored in a statically allocated or a
dynamically allocated structure.
(e)True
(f)False. A queue is not a random-access structure; access is always to the frst
one stored.
10.(a)true
(b)false
(c)false
(d)true
12.(a)listData = ptr1->next;
(b)ptr2 = ptr2->next;
(c)listData = NULL
(d)ptr1->next->info = 60
Answers for the table:
Statements
Memory allocated What is
printed?
int value;
value is assigned to location
200
value = 500;
char* charPtr;
charPtr is at location 202
char string[10] = "Good luck";
string[0] is at location 300
charPtr = string;
cout << &value; // question 19
& means "the address of"
cout << value; // question 20
cout << &charPtr; // question 21
& means "the address of"
cout << charPtr; // question 22
cout << *charPtr; // question 23
cout << string[2]; // question 24
16.None of the changes in Exercises 9 and 10 change the Big-O from that discussed
in the chapter. Each of the delete operations still have order O(N).
Chapter 4
1.(a)
Boolean IsThere(ItemType item)
Function: Determines if item is in the list.
Precondition: List has been initialized.
Postcondition: Function value = there exist an item in the list whose key is the same as
item's.
(b)
bool IsThere(ItemType item) const;
(c)
bool SortedType::IsThere(ItemType item)
{
int midPoint;
int first = 0;
int last = length - 1;
bool moreToSearch = first <= last;
bool found = false;
while (moreToSearch && !found)
{
midPoint = (first + last) / 2;
switch (item.ComparedTo(info[midPoint])
{
case LESS : last = midPoint - 1;
moreToSearch = first <= last;
break;
case GREATER : first = midPoint + 1;
moreToSearch = first <= last;
break;
case EQUAL : found = true;
break;
}
}
return found;
}
(d)O(log
2
N) where N is the number of items in the list.
3.(a)
Boolean IsThere(ItemType item, UnsortedType list)
Function: Determines if item is in the list.
Precondition: list has been initialized.
Postcondition: Function value = there exist an item in the list whose key is the same as
item's.
(b)
bool IsThere(SortedType list, ItemType item)
{
int length;
bool found = false;
int counter = 1;
ItemType listItem;

length = list.LengthIs();
list.ResetList();
while (!found && counter <= length)
{
list.GetNextItem(listItem);
if (listItem.ComparedTo(item) == EQUAL)
found = true;
counter++;
}
return found;
}
or
bool IsThere(SortedType list, ItemType item)
{
bool found;
list.RetrieveItem(item, found);
return found;
}
(c)The client code does not have access to the array containing the data values,
so the binary search algorithm could not be used.
(d)The version that iterates through the items is O(N); the version that uses
RetrieveItem would have the same complexity as RetrieveItem.
(e)The member function has access to the array holding the values, so the
binary search algorithm can be used. Therefore, the complexity if O(log
2
N)
rather O(N).
4.(a)
void MergeLists(SortedType list1, SortedType list2,
SortedType& result);
(b)
void MergeLists(SortedType list1, SortedType list2,
SortedType& result)
{
int length1;
int length2;
int counter1 = 1;
int counter2 = 1;
ItemType item1;
ItemType item2;
length1 = list1.LengthIs();
length2 = list2.LengthIs();
list1.ResetList();
list2.ResetList();
list1.GetNextItem(item1);
list2.GetNextItem(item2);
result.MakeEmpty();
while (counter1 <= length1 && counter2 <= length2)
switch (item1.ComparedTo(item2))
{
case LESS : result.InsertItem(item1);
if (counter1 < length1)
list1.GetNextItem(item1);
counter1++;
break;
case GREATER: result.InsertItem(item2);
if (counter2 < length2)
list2.GetNextItem(item2);
counter2++;
break;
}
for (; counter1 <= length1; counter1++)
{
result.InsertItem(item1);
if (counter1 < length1)
list1.GetNextItem(item1);
}
for (; counter2 <= length2; counter2++)
{
result.InsertItem(item2);
if (counter2 < length2)
list2.GetNextItem(item2);
}
}
(c)Because the lists that are being merged are sorted, the complexity is O(N)
times the complexity of the InsertItem operation.
Chapter 5
1.
(a)Yes
(b)No
(c)Yes
(d)No
(e) Yes
(f)No
(g)No
(h)Yes
3.(a)
3 5 4 (on one line)
5 16 1 0 (each on a separate line)
(b)
0 5 6 5 (each on a separate line)
5 4 0 (on one line)
5.stack.Push(letter);
letter letter
stack.top stack.top
.overFlow .overFlow
.underFlow .underFlow
.items .items
[0
]
[0
]
8.(a)Set secondElement to the second element in the stack, leaving the stack
without its original top two elements.
{
stack.Pop(secondElement);
stack.Pop(secondElement);
}
(b)Set bottom equal to the bottom element in the stack, leaving the stack empty.
{
while (!stack.IsEmpty())
stack.Pop(bottom);
}
(c)Set bottom equal to the bottom element in the stack, leaving the stack
unchanged.
{
StackType tempStack;
ItemType tempItem;
while (!stack.IsEmpty())
{
stack.Pop(tempItem);
tempStack.Push(tempItem);
}
bottom = tempItem;
// restore stack
while (!tempStack.IsEmpty())
{
tempStack.Pop(tempItem);
stack.Push(tempItem);
}
}
(d)Make a copy of the stack, leaving the stack unchanged.
{
StackType tempStack;
ItemType tempItem;
while (!stack.IsEmpty())
{
stack.Pop(tempItem);
tempStack.Push(tempItem);
}
// restore stack
while (!stack.IsEmpty())
{
tempStack.Pop(tempItem);
stack.Push(tempItem);
copy.Push(tempItem)
}
}
12.(a)Draw a diagram of how the stack might look.
smallTop: top for the stack of small values, initialized to -1 and incremented.
largeTop: top for the stack of large values, initialized to 200 and decremented.
[0] [1] [2] [3] .... [197] [198] [199]
(b)
class DStack
{
public:
DStack();
void Push(int item);
void PopLarge(int& item);
void PopSmall(int& item);
private:
int smallTop;
int largeTop;
int items[200];
}
(c)
void Push(int item)
{
if (item <= 1000)
{
small++;
items[small] = item;
}
else
{
large--;
items[large] = item;
}
}
15.
void (StackType& stack, ItemType oldItem, ItemType newItem)
{
StackType tempStack;
ItemType tempItem;
while (!stack.IsEmpty())
{
stack.Pop(tempItem);
if (tempItem.ComparedTo(oldItem) == EQUAL)
tempStack.Push(newItem);
else
tempStack.Push(tempItem);
}
// restore stack
while (!stack.IsEmpty())
{
tempStack.Pop(tempItem);
stack.Push(tempItem);
}
}
17.
Stack ADT Specifcation
Structure:Elements are added to and removed from the top of the stack.
Defnitions (provided by user):
MAX_ITEMS:Maximum number of items that might be on the stack.
ItemType: Data type of the items on the stack.
Operations (provided by the ADT):
MakeEmpty
Function: Sets stack to an empty state.
Precondition: None
Postcondition: Stack is empty.
Boolean IsEmpty
Function: Determines whether the stack is empty.
Precondition: Stack has been initialized.
Postcondition: Function value = (stack is empty)
Boolean IsFull
Function: Determines whether the stack is full.
Precondition: Stack has been initialized.
Postcondition: Function value = (stack is full)
Push(ItemType newItem, Boolean& error)
Function: Adds newItem to the top of the stack.
Precondition: Stack has been initialized.
Postcondition: If stack is not full, newItem is at the top of the stack and error is
false;
otherwise, error is true and the stack is unchanged.
Pop(ItemType& item, Boolean& error)
Function: Removes top item from Stack and returns it in item.
Preconditions: Stack has been initialized and is not empty.
Postcondition: If the stack is not empty, the top element has been removed from
stack, item is a copy of removed item, and error is false;
otherwise, error is true and the stack is
unchanged.
(b)None
(c)None
An alternative implementation would add an error data member to the class.
This error fag would be set if underfow or overfow occurred and the operation
would not be performed. A member function would have to be added to the
class to allow the user to check the error fag.
20.Yes, this sequence is possible.
22.(a)
1 0 4
5 16 0 3
(b)
6 4 6 0
6 5 5
24.queue.Enqueue(letter);
letter letter
queue.front queue.front
.rear .rear
.overFlow .overFlow
.underFlow .underFlow
.items .items
27.queue.Dequeue(letter);
letter letter
queue.front queue.front
.rear .rear
.overFlow .overFlow
.underFlow .underFlow
.items .items
30.(a)Set secondElement to the second element in the queue, leaving the queue
without its original front two elements.
{
queue.Dequeue(secondElement);
queue.Dequeue(secondElement);
}
(b)Set last equal to the rear element in the queue, leaving the queue empty.
{
while (!queue.IsEmpty())
queue.Dequeue(last);
}
(c)Set last equal to the rear element in the queue, leaving the queue
unchanged.
{
QueType tempQ;
ItemType item;
while (!queue.IsEmpty())
{
queue.Dequeue(last);
tempQ.Enqueue(last);
}
while (!tempQ.IsEmpty())
{
tempQ.Dequeue(item);
ueue.Enqueue(item);
}
}
(d)A copy of the queue, leaving the queue unchanged.
{
QueType<ItemType> tempQ;
ItemType item;
while (!queue.IsEmpty())
{
queue.Dequeue(item);
tempQ.Enqueue(item);
}
while (!tempQ.IsEmpty())
{
tempQ.Dequeue(item);
queue.Enqueue(item);
copy.Enqueue(item);
}
}
32.The correct answer for the frst statement is (d); the correct answer for the second
statement is (a).
35.(a)No
(b)Yes
(c)No
(d)No
(e)Yes
(f)Yes
(g)No
(h)Yes
(i)No
37.
int Length(QueType<ItemType> queue)
{
QueType<ItemType> tempQ;
ItemType item;
int length = 0;
while (!queue.IsEmpty())
{
queue.Dequeue(item);
tempQ.Enqueue(item);
}
while (!tempQ.IsEmpty())
{
tempQ.Dequeue(item);
queue.Enqueue(item);
length++;
}
return length;
}
39.The second else-clause is only executed if both queues are not empty, but one had
to be empty for the loop to be exited, so only one can be empty. Therefore,
string1 can only be assigned a value from one queue or the other but not both.
42.No, this sequence is not possible.
44.
#include "StackType.h"
#include <iostream>
bool IsOpen(char symbol);
bool IsClosed(char symbol);
bool Matches(char symbol, char openSymbol);
int main()
{
using namespace std;
char symbol;
StackType stack;
bool balanced = true;
char openSymbol;
try
{
cout << "Enter an expression and press return."
<< endl;
cin.get(symbol);
while (symbol != '\n' && balanced)
{
if (IsOpen(symbol))
stack.Push(symbol);
else if (IsClosed(symbol))
{
if (stack.IsEmpty())
balanced = false;
else
{
openSymbol = stack.Top();
stack.Pop();
balanced = Matches(symbol, openSymbol);
}
}
cin.get(symbol);
}
}
catch (FullStack error)
{
cout << "Push called when the stack is full." <<
endl;
return 1;
}
catch (EmptyStack error)
{
cout << "Top or Pop called when stack is empty."
<< endl;
return 1;
}
if (balanced)
cout << "Expression is well formed." << endl;
else
cout << "Expression is not well formed." << endl;
return 0;
}

bool IsOpen(char symbol)
{
if ((symbol == '(') || (symbol == '{') || (symbol ==
'['))
return true;
else
return false;
}
bool IsClosed(char symbol)
{
if ((symbol == ')') || (symbol == '}') || (symbol ==
']'))
return true;
else
return false;
}
bool Matches(char symbol, char openSymbol)
{
return (((openSymbol == '(') && symbol == ')')
|| ((openSymbol == '{') && symbol == '}')
|| ((openSymbol == '[') && symbol == ']'));
}
Chapter 6
3.Member functions Enqueue and Dequeue would have to be changed.
6.No, the class defnition would not have to be changed. Only the defnition of
NodeType would have to be changed.
9.Write a member function Copy of the Stack ADT, assuming that self is copied
into the stack named in the parameter list.
template <class ItemType>
void StackType<ItemType>::Copy(StackType<ItemType>& anotherStack)
{
NodeType<ItemType>* ptr1;
NodeType<ItemType>* ptr2;

if (topPtr == NULL)
anotherStack.topPtr = NULL;
else
{
anotherStack.topPtr = new NodeType<ItemType>;
anotherStack.topPtr->info = topPtr->info;
ptr1 = topPtr->next;
ptr2 = anotherStack.topPtr;
while (ptr1 != NULL)
{
ptr2->next = new NodeType<ItemType>;
ptr2 = ptr2->next;
ptr2->info = ptr1->info;
ptr1 = ptr1->next;
}
ptr2->next = NULL;
}
}
12.(a)Doubly linked
(b)Circular
(c)List with header and trailer
15.(b)
4 17 25
(c)
free 3
list 1
nodes
.info .next .back
[0]
17 2 1
[1]
4 0 NUL
[2]
25 NUL 0
[3]
[4]
[5]
[6]
[7]
[8]
[9]
(d)
free 0
list 1
nodes
.info .next .back
[0]
17 3
1
[1]
4 2
NUL
[2]
25 NUL
1
[3]
[4]
[5]
[6]
[7]
[8]
[9]
17.Static binding is the determination of which function to call at compile time;
dynamic binding is the determination of which function to call at run tim
Chapter 7
1.(a)The base case is a nonrecursive exit from the recursive routine.
(b)The general (or recursive) case is a path that includes a recursive call to the
routine, to solve a smaller version of the original problem.
(c)The run-time stack is a structure that keeps track of the activation records at
run time, in order to preserve the values of parameters, return addresses,
registers, and so on.
(d)Binding time refers to the point in the compile/execution cycle when variable
names are associated with addresses in memory.
(e)Tail recursion occurs when the recursive call is the last statement executed in
a recursive function.
4.Answering yes to Question 1 provides us with a base case that works correctly.
In answering Question 3, we make an assumption that the function works for
some artibary case. We can then show that applying the function to the next
value results in the correct answer in the general case.
7.(a)The base cases are return -1 and return 1.
(b)The general case is return base*Puzzle(base+1, limit).
10.(a)
int Power(int base, int exponent)
// Returns the base raised to the exponent
{
if (exponent == 0)
return 1; // base case
else
return base * Power(base, exponent-1); // general case
}
(b)
int Factorial(int number)
// Returns the factorial of number (number!)
{
if (num > 0)
return num * Factorial(num - 1); // general case
else
if (num == 0)
return 1; // base case
}
(c)
void Sort(int values[], int fromIndex, int toIndex)
// Sorts values from values[fromIndex] .. values[toIndex].
// The maximum value left in the unsorted portion is put into
its
// proper place on each call.
{
int maxIndex;
if (fromIndex != toIndex)
{ // general case
maxIndex = MaxPosition(values, fromIndex, toIndex);
Swap(values[maxIndex], values[toIndex]);
Sort(values, fromIndex, toIndex - 1);
}
// base case is when fromIndex equals toIndex: do nothing
}
13.(a)
int Fibonacci(int number)
{
if (number <= 1)
return number;
else
return Fibonacci(number - 2) + Fibonacci(number - 1);
}
(b)
int Fibonacci(int number)
{
int current;
int previous;
int temp;
if (number <= 1)
return 1;
else
{
previous = 0;
current = 1;
for (int count = 2; count <= number; count++)
{
temp = previous;
previous = current;
current = temp + previous;
}
return current;
}
}
(c)
#include <iostream>
int Fibonacci(int number);
int main()
{
using namespace std;
int number;
cout << "Input the fibonacci number you wish." << endl;
<< "Input a negative number to quit." << endl;
cin >> number;
while (number >= 0)
{
cout << "number: " << number << endl;
<< "Fibonacci number: " << Fibonacci(number) << endl;
cout << "Input the fibonacci number you wish." << endl;
<< "Input a negative number to quit." << endl;
cin >> number;
}
return 0;
}
// Put the function version you are testing here.
(d)The recursive solution is inefcient because some of the intermediate values
are calculated more than once.
(e)The following version, which uses an auxiliary recursive function, is more
efcient. Note that the recursive parameters are used to keep track of the current
and previous numbers, rather than recalculating them.
int Fibonacci(int number)
{
return Fib(number, 1, 1);
}
int Fib(int number, int previous, int current)
{
if (number == 0)
return previous;
else
return Fib(number - 1, current, current + previous)
}
16.(a)
// corrected version
int NumPaths(int row, int col, int n)
{
if (row == n || col == n)
return 1
else
return NumPaths(row + 1, col, n) + NumPaths(row, col + 1,
n);
}.
(b)The algorithm is inefcient because it calculates some of the intermediate
values of NumPaths more than once.
(c)
const int MAX = 10;
int table[MAX][MAX];
.
.
.
int NumPaths2(int row, int col, int n)
{
if (row == n || col == n)
table[row][col] = 1;
else if (table[row][col] == 0)
table[row][col] = NumPaths2(row+1, col, n) +
NumPaths2(row, col+1, n)
return table[row][col];
}
(d)
// initialize table
for (int i = 0; i < MAX; i++)
for (int j = 0; j < MAX, j++)
table[i][j] = 0;
// solve problem
answer = NumPaths2(l, l, MAX);
(e)The second version is more efcent in terms of execution time, but requires
additional space for an N x N array of integers.
19.Binding time refers to the point in the compile/execute cycle when variable
names are associated with addresses in memory. For recursion to be possible,
parameters must be bound to addresses at run time, not at compile time.
22.(a)False. Recursive solutions are often less efcient in terms of computing time.
(b)True
(c)False. Recursive solutions generally require more space in the run-time
stack.
(d)True. (Don't you want a good grade in this course?)
Chapter 8
2.(c) is the correct answer
5.(a)30 (5 diferent shapes with 6 diferent combinations of values for each)
(b)5 (5 diferent shapes with one legal combinations of values for each)
10.Show what order the nodes in the tree are processed by
(a)BDJKMNPQRTWY
(b)BJDNPMKRWYTQ
(c)QKDBJMPNTRYW
13.(a)The path would go through the nodes containing 56, 69, 59, 62, and 61.
(b)The path would go through the nodes containing 56, 47, 22, 29, and 23,
before determining that 28 is not in the tree.
14.(a)11 22 23 29 30 47 49 56 59 61 62 64 69
(b)11 23 30 29 22 49 47 61 64 62 59 69 56
(c)56 47 22 11 29 23 30 49 69 59 62 61 64
17.(a)False
(b)False
(c)True
(d)False
19.(a)Elements inserted in random order:
Linked list: O(N)
Binary search tree: O(log
2
N)
(b)Elements inserted in order:
Linked list: O(N)
Binary search tree: O(N)
22
template<class ItemType>
void DeleteNode(TreeNode<ItemType>*& tree)
// Deletes the node pointed to by tree.
// Post: The user's data in the node pointed to by tree is no
// longer in the tree. If tree is a leaf node or has one
NULL
// child pointer
// the node pointed to by tree is deleted; otherwise, the
// user's data is replaced by its logical successor and the
// successor's node is deleted.
{
TreeNode<ItemType>* tempPtr;
ItemType data;
tempPtr = tree;
if (tree->left == NULL)
tree = tree->right;
else if (tree->right == NULL)
tree = tree->left;
else
{
tempPtr = PtrToSuccessor(tree);
tree->info = tempPtr->data;
}
delete tempPtr;
}
24.1. The Base-Case Question: Yes. The base case occurs when the node to be deleted
has been found, when item equals tree->info. In this case we call the
DeleteNode function; no further recursive calls are made.
2. The Smaller-Caller Question: Yes. In each of the two general cases, a recursive
call is made to delete the element from a subtree, left or right, of the current tree.
Deleting from a subtree is a smaller version of the problem.
3. The General Case Question: Yes. If item is less than tree->info, then we
know that the node to be deleted is in tree's left subtree. Assuming that the
recursive call successfully deletes from the left subtree, the problem is solved
correctly. Otherwise, if item is greater than tree->info, we know that the
node to be deleted is in tree's right subtree. Again, assuming that the recursive
call successfully deletes from the right subtree, the problem is solved correctly.
27.
template<class ItemType>
void PrintAncestors(TreeNode<NodeType>* tree, ItemType value)
const;
// prototype
template<class ItemType>
void TreeType<ItemType>::Ancestors(ItemType value) const
// Calls recursive function PrintAncestors to print the
ancestors.
{
PrintAncestors(root, value);
}
template<class ItemType>
void PrintAncestors(TreeNode<NodeType>* tree, ItemType value)
const
{
if (tree->info != value)
{
std::cout << tree->info << endl;
if (tree->info < value)
PrintAncestors(tree->right, value);
else
PrintAncestors(tree->left, value);
}
}
30.
int LeafCount(); // prototype
// Post: Function value = number of leaf nodes in the tree.
template<class ItemType>
int Count(TreeNode<ItemType>* tree); // prototype
template<class ItemType>
int TreeType<ItemType>::LeafCount()
// Calls recursive function Count to count the number
// of leaf nodes.
{
return Count(root);
}
template<class ItemType>
int Count(TreeNode<ItemType>* tree)
{
if (tree == NULL)
return 0;
else if (tree->left == NULL) && (tree->right == NULL)
return 1;
else
return Count(tree->left) + Count(tree->right);
}
33.(a)
bool SimilarTrees(TreeType<ItemType> otherTree); //
prototype
// Post: True is returned if self and otherTree are similar;
false
// is returned otherwise.
template<class ItemType>
bool Similar(TreeType<ItemType>* tree1, TreeType<ItemType>*
tree2);
// prototype
// Recursive function to determine if two trees are similar.
(b)
template<class ItemType>
bool TreeType<ItemType>::SimilarTrees(TreeType<ItemType>
otherTree)
{
return Similar(root, otherTree.root);
}
template<class ItemType>
bool Similar(TreeNode<ItemType>* tree1, TreeNode<ItemType>*
tree2);
{
if (tree1 == NULL && tree2 == NULL)
return true;
else if (tree1 == NULL && tree2 != NULL) ||
(tree1 != NULL && tree2 == NULL)
return false;
else
return Similar(tree1->left, tree2->left) &&
Similar(tree2->right, tree2->right);
}
35.
template<class ItemType>
void MakeTree(TreeType<ItemType>& tree, int info[], int length)
// Creates a binary tree from a sorted array.
{
tree.MakeEmpty();
AddElements(tree, info, 0, length-1);
}
template<class ItemType>
void AddElements(TreeType<ItemType>& tree, ItemType info[],
int fromIndex, int toIndex)
{
int midIndex;
if (fromIndex <= toIndex)
{
midIndex = (fromIndex + toIndex) / 2;
tree.InsertItem(info[midIndex]);
AddElements(tree, info, fromIndex, midIndex - 1);
// Complete the left subtree.
AddElements(tree, info, midIndex+1, toIndex);
// Complete the right subtree.
}
}
38.Either the value in node 5 or the value in node 6.
40. Preorder
43. (a)Any negative number can be used as a dummy value.
(b)Assume that the dummy value is -1.0.
tree
.numElements 13
.nodes [0] 26
[1] 14
[2] 38
[3] 1
[4] -1
[5] 33
[6] 50
[7] -1
[8] 7
[9] -1
[10] 35
[11] 44
[12] 60
[13] ?
[14] ?
[15] ?
Chapter 9
2.The relational operator <= should be replaced with >=.
5. (a) The member functions would not change, but the private data members
would change. The only data member would be a pointer to a linked lists.
(b)The code for SortedType::InsertItem (linked implementation) can be
used directly with the relational operator reversed.
(c)The code is identical to StackType::Pop.
(d)Dequeue for a priority queue implemented as a linked list (ordered from
highest to lowest priority) is very simple and efcient; we have direct access to
the largest element. There is less work involved in fxing the structure after the
largest element is removed, because the next-largest element immediately follows
it. Thus the operation is 0(1). In the heap implementation we have immediate
access to the largest element, but we have to perform a reheap operation to fx the
structure, resulting in an O(log
2
N) operation. The linked list implementation is
more efcient, in terms of Big O.
When the priority queue is implemented as a linked list, the efciency of
Enqueue varies according to the position that the new element occupies in the
list. If the new element belongs in the last position, the whole list is searched
before the insert place is found. Thus the operation is O(N). Using heaps, the
insertion operation is O(log
2
N). The linked list implementation might be better if
the elements were inserted in largely sorted order from smallest to largest value.
8.(a)The highest-priority element is the one with the largest time stamp. (This
assumes that the time stamp never reaches INT_MAX.
(b)
Push
Assign the next largest time stamp to the new element
Put new element in the stack (position is unimportant)
Pop
Find the element with the largest time stamp
Assign this element to item (to be returned)
Remove the element
(c)The Push operation has O(1) because it doesn't matter where the item is stored in
the structure. The Pop operation has O(N), because the item with the largest
time stamp must be searched for.
Therefore, Push is the same in both implementations, but Pop is not. If the
priority queue is implemented using a heap with largest value the highest
priority, Pop and Push have O(log2N).
12.
EmployeeGraph
..vertices
.numVertices
.vertexList
[0] Brent
[1] Darlene
[2] Fran
[3] Fred
[4] Jean
[5] John
[6] Lance
[7] Mike
[8] Sander
[9] Susan
.Edges
[0] F F F T F F T F F F
[1] F F F F F F F T F T
[2] F F F F F T T F T F
[3] T F F F F F F F F F
[4] F F F F F F T F F T
[5] F F T F F F F F F T
[6] T F T F T F F F F F
[7] F T F F F F F F F F
[8] F F T F F F F F F T
[9] F T F F T T F F T F
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
14."works with" is the best description of the relationship represented by the edges
between vertices in EmployeeGraph, because it is an undirected graph. The other
relationships listed have an order implicit in them.
17.The correct answer is (b). For example, a dalmatian is an example of a dog.
20.(a)
StateGraph
..vertices
.numVertices 7
.vertexList
[0] Alaska
[1] Californi
a
[2] Hawaii
[3] New York
[4] Oregon
[5] Texas
[6] Vermont
.Edges
[0] F F F F T F F
[1] F F F F F F F
[2] T T F T F T F
[3] F F F F F F F
[4] F F F F F F F
[5] F F T F F F T
[6] T T F T F F F
[0] [1] [2] [3] [4] [5] [6]
(b)
..vertices
.numVertices 7
.vertexList
[0] Alaska -> 4 /
[1] Californi
a
[2] Hawaii -> 1 --
-
-> 3 --
-
-> 5 --
-
-> 0 /
[3] New York
[4] Oregon
[5] Texas -> 2 --
-
-> 6 /
[6] Vermont -> 0 --
-
-> 1 --
-
-> 3 /
23.Deleting a vertex is more complicated than deleting an edge for two reasons.
First, in addition to removing the vertex from the set of vertices, we must also
remove the edges to all its adjacent vertices in the set of edges. Second, we must
dedecide what to do about the now unused vertex number. The best solution is
to keep a list of returned vertex numbers and assign new numbers from there
frst.
25.Implicit set representations represent those items that are present in an instance
of a set explicitly; those items that are not represented are not in the set. Explicit
set representations associate a place (bit or Boolean fag) for each item in the base
type in the instance of each set . The place for an item is true if the item is in the
set and false if the item is not in the set.
Chapter 10
1.
(a)BubbleSort
4 5 7 10 43 14 18 23 19 66
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
(b)SelectionSort
4 5 7 10 18 43 19 23 66 14
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
(c)InsertionSort
7 10 23 43 18 4 19 5 66 14
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
4. (a)bubble sort
(b)selection sort
(c)insertion sort
7.The correct answer is (c).
10.(a)Bubble sort is O(N) if the values are already sorted, and if the algorithm stop
processing when the sorting is complete (like ShortBubble).
(b)None.
(c)QuickSort is O(N
2
) if the values are already sorted and the split algorithm
causes the array to be split into one element and the rest of the array.
13.(a)True
(b)False. HeapSort is better for nearly sorted data than QuickSort.
(c)True
16.The correct answer is (b).
19.The code is identical to the one in the book with the relational operator in the
comparison changed.
22.Declare an array indexed from 0 through 99. Use the slots in the array as
counters for that percentile score; that is, the slot indexed by 0 is the counter for
percentile scores of 0; the slot indexed by 2 is the counter for percintile scores of
2; and so on. To produce the required output, go through the array from 99
down to 0, printing the loop counter as many times as there are values in that
slot.
25.(a)for the best case. O(1)
(b)for the worst case. O(N
2
)
28.
dataValues
14 27 95 12 26 5 33 15 9 99
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
sortedValues
5 9 12 14 15 26 27 33 95 99
[0] [1] [2] [3] [4] [5] [6] [7] [8] [9]
Search
dataValues
sequentially
Search
sortedValues
sequentially
Binary-
Search
sortedValues
8 5 1 4
10 6 3 4
14 1 4 4 1
6 1 3 3
10 10 4 4
10 10 4 4
1 3 3
31.
HashTable
[0] 90 140 620
[1]
[2]
[3] 153 393
[4]
[5] 145 285 395
[6] 66 126 566
[7] 47 87 177
[8] 467 735
34.The correct answer is (a)
37.(a)50
(b)50
(c)50.
40.The correct answer is (c).
43.No. Simply substituting the StackADT for the QueueADT would not work. The
elements would be gathered in the wrong order.