FRbsbsvvsvsvbshgsgsvzvsvvsvsvsvsvsvvev.ppt

1
C++ Plus Data Structures
Nell Dale
Chapter 7
Programming with Recursion
Modified from the slides by Sylvia Sorkin, Community College of Baltimore County - Essex
Campus

2
Recursive Function Call
 A recursive call is a function call in
which the called function is the same as
the one making the call.
 In other words, recursion occurs when a
function calls itself!
 We must avoid making an infinite
sequence of function calls (infinite
recursion).

3
Finding a Recursive Solution
 Each successive recursive call should bring
you closer to a situation in which the answer is
known.
 A case for which the answer is known (and
can be expressed without recursion) is called
a base case.
 Each recursive algorithm must have at least
one base case, as well as the general
(recursive) case

4
Three-Question Method of verifying
recursive functions
 Base-Case Question: Is there a nonrecursive way
out of the function?
 Smaller-Caller Question: Does each recursive
function call involve a smaller case of the original
problem leading to the base case?
 General-Case Question: Assuming each
recursive call works correctly, does the whole
function work correctly?

5
Writing Recursive Functions
 Get an exact definition of the problem to be
solved.
 Determine the size of the problem on this call to
the function.
 Identify and solve the base case(s).
 Identify and solve the general case(s) in terms of a
smaller case of the same problem – a recursive
call.

6
“Why use recursion?”
Those examples could have been written
without recursion, using iteration instead.
The iterative solution uses a loop, and the
recursive solution uses an if statement.
However, for certain problems the recursive
solution is the most natural solution. This often
occurs when pointer variables are used.

7
Recursive Linked List
Processing

8
struct NodeType
{
int info ;
NodeType* next ;
}
class SortedType {
public :
. . . // member function prototypes
private :
NodeType* listData ;
} ;
struct ListType

9
RevPrint(listData);
A B C D E
FIRST, print out this section of list, backwards
THEN, print
this element
listData

10
Base Case and General Case
A base case may be a solution in terms of a “smaller” list.
Certainly for a list with 0 elements, there is no more
processing to do.
Our general case needs to bring us closer to the base case
situation. That is, the number of list elements to be
processed decreases by 1 with each recursive call. By
printing one element in the general case, and also
processing the smaller remaining list, we will eventually
reach the situation where 0 list elements are left to be
processed.
In the general case, we will print the elements of the smaller
remaining list in reverse order, and then print the current
pointed to element.

11
Using recursion with a linked list
void RevPrint ( NodeType* listPtr )
// Pre: listPtr points to an element of a list.
// Post: all elements of list pointed to by listPtr have been printed
// out in reverse order.
{
if ( listPtr != NULL ) // general case
{
RevPrint ( listPtr-> next ) ; // process the rest
cout << listPtr->info << endl ; // then print this element
}
// Base case : if the list is empty, do nothing
} 11

12
How Recursion Works
 Static storage allocation associates
variable names with memory locations at
compile time.
 Dynamic storage allocation associates
variable names with memory locations at
execution time.

13
When a function is called...
 A transfer of control occurs from the calling
block to the code of the function. It is necessary
that there is a return to the correct place in the
calling block after the function code is executed.
This correct place is called the return address.
 When any function is called, the run-time stack
is used. On this stack is placed an activation
record (stack frame) for the function call.

14
Stack Activation Frames
 The activation record stores the return address for
this function call, and also the parameters, local
variables, and the function’s return value, if non-
void.
 The activation record for a particular function call is
popped off the run-time stack when the final closing
brace in the function code is reached, or when a
return statement is reached in the function code.
 At this time the function’s return value, if non-void,
is brought back to the calling block return address
for use there.

15
Debugging Recursive Routines
 Using the Three-Question Method.
 Using a branching statement (if/switch).
 Put debug output statement during testing.
 …

16
Removing Recursion
When the language doesn’t support
recursion, or recursive solution is
too costly (space or time), or …
 Iteration
 Stacking

17
Use a recursive solution when:
 The depth of recursive calls is relatively
“shallow” compared to the size of the problem.
 The recursive version does about the same
amount of work as the nonrecursive version.
 The recursive version is shorter and simpler than
the nonrecursive solution.
SHALLOW DEPTH EFFICIENCY CLARITY

18
Nell Dale
Chapter 8
Binary Search Trees
Campus

19
for an element in a sorted list stored
sequentially
 in an array: O(Log2N)
 in a linked list: ? (midpoint = ?)
Binary search

20
 Introduce some basic tree vocabulary
 Develop algorithms
 Implement operations needed to use a
binary search tree
Goals of this chapter

21
A binary tree is a structure in which:
Each node can have at most two children,
and in which a unique path exists from the
root to every other node.
The two children of a node are called the left
child and the right child, if they exist.
Binary Tree

22
Implementing a Binary Tree
with Pointers and Dynamic Data
Q
V
T
K S
A
E
L

23
Each node contains two pointers
template< class ItemType >
struct TreeNode {
ItemType info; // Data member
TreeNode<ItemType>* left; // Pointer to left child
TreeNode<ItemType>* right; // Pointer to right child
};
.left .info .right
NULL ‘A’ 6000

// BINARY SEARCH TREE SPECIFICATION
class TreeType {
public:
TreeType ( ); // constructor
~TreeType ( ); // destructor
bool IsEmpty ( ) const;
bool IsFull ( ) const;
int NumberOfNodes ( ) const;
void InsertItem ( ItemType item );
void DeleteItem (ItemType item );
void RetrieveItem ( ItemType& item, bool& found );
void PrintTree (ofstream& outFile) const;
. . .
private:
TreeNode<ItemType>* root;
}; 24

25
TreeType<char> CharBST;
‘J’
‘E’
‘A’
‘S’
‘H’
TreeType
~TreeType
IsEmpty
InsertItem
Private data:
root
RetrieveItem
PrintTree
.
.
.

26
A Binary Tree
Q
V
T
K S
A
E
L
Search for ‘S’?

27
A special kind of binary tree in which:
1. Each node contains a distinct data value,
2. The key values in the tree can be compared using
“greater than” and “less than”, and
3. The key value of each node in the tree is
less than every key value in its right subtree, and
greater than every key value in its left subtree.
A Binary Search Tree (BST) is . . .

28
Is ‘F’ in the binary search tree?
‘J’
‘E’
‘A’ ‘H’
‘T’
‘M’
‘K’
‘V’
‘P’ ‘Z’
‘D’
‘Q’
‘L’
‘B’
‘S’

29
Is ‘F’ in the binary search tree?
‘J’
‘E’
‘A’ ‘H’
‘T’
‘M’
‘K’
‘V’
‘P’ ‘Z’
‘D’
‘Q’
‘L’
‘B’
‘S’

// BINARY SEARCH TREE SPECIFICATION
class TreeType {
public:
TreeType ( ) ; // constructor
~TreeType ( ) ; // destructor
bool IsEmpty ( ) const ;
bool IsFull ( ) const ;
int NumberOfNodes ( ) const ;
void InsertItem ( ItemType item ) ;
void DeleteItem (ItemType item ) ;
void RetrieveItem ( ItemType& item , bool& found ) ;
void PrintTree (ofstream& outFile) const ;
. . .
private:
TreeNode<ItemType>* root ;
}; 30

// SPECIFICATION (continued)
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
// RECURSIVE PARTNERS OF MEMBER FUNCTIONS
void PrintHelper ( TreeNode<ItemType>* ptr,
ofstream& outFile ) ;
void InsertHelper ( TreeNode<ItemType>*& ptr,
ItemType item ) ;
void RetrieveHelper ( TreeNode<ItemType>* ptr,
ItemType& item, bool& found ) ;
void DestroyHelper ( TreeNode<ItemType>* ptr ) ;
31

void TreeType<ItemType> :: RetrieveItem ( ItemType& item,
bool& found )
{
RetrieveHelper ( root, item, found ) ;
}
void RetrieveHelper ( TreeNode<ItemType>* ptr, ItemType& item,
bool& found)
{ if ( ptr == NULL )
found = false ;
else if ( item < ptr->info ) // GO LEFT
RetrieveHelper( ptr->left , item, found ) ;
else if ( item > ptr->info ) // GO RIGHT
RetrieveHelper( ptr->right , item, found ) ;
else
{ item = ptr->info ;
found = true ;
}
}
32

void TreeType<ItemType> :: InsertItem ( ItemType item )
{
InsertHelper ( root, item ) ;
}
void InsertHelper ( TreeNode<ItemType>*& ptr, ItemType item )
{ if ( ptr == NULL )
{ // INSERT item HERE AS LEAF
ptr = new TreeNode<ItemType> ;
ptr->right = NULL ;
ptr->left = NULL ;
ptr->info = item ;
}
else if ( item < ptr->info ) // GO LEFT
InsertHelper( ptr->left , item ) ;
else if ( item > ptr->info ) // GO RIGHT
InsertHelper( ptr->right , item ) ;
} 33

34
Traverse a list:
-- forward
-- backward
Traverse a tree:
-- there are many ways!
PrintTree()

35
Inorder Traversal: A E H J M T Y
‘J’
‘E’
‘A’ ‘H’
‘T’
‘M’ ‘Y’
tree
Print left subtree first Print right subtree last
Print second

36
Preorder Traversal: J E A H T M Y
‘J’
‘E’
‘A’ ‘H’
‘T’
‘M’ ‘Y’
tree
Print left subtree second Print right subtree last
Print first

37
‘J’
‘E’
‘A’ ‘H’
‘T’
‘M’ ‘Y’
tree
Print left subtree first Print right subtree second
Print last
Postorder Traversal: A H E M Y T J

38
 Is the depth of recursion relatively shallow?
Yes.
 Is the recursive solution shorter or clearer than the
nonrecursive version?
Yes.
 Is the recursive version much less efficient than the
nonrecursive version?
No.
Recursion or Iteration?
Assume: the tree is well balanced.

39
Use a recursive solution when (Chpt. 7):
 The depth of recursive calls is relatively
“shallow” compared to the size of the problem.
 The recursive version does about the same
amount of work as the nonrecursive version.
 The recursive version is shorter and simpler than
the nonrecursive solution.
SHALLOW DEPTH EFFICIENCY CLARITY

40
BST:
 Quick random-access with the flexibility of a linked
structure
 Can be implemented elegantly and concisely using
recursion
 Takes up more memory space than a singly linked
list
 Algorithms are more complicated
Binary Search Trees (BSTs)
vs. Linear Lists

41
Nell Dale
Chapter 9
Trees Plus
Campus

42
A special kind of binary tree in which:
1. Each leaf node contains a single operand,
2. Each nonleaf node contains a single binary
operator, and
3. The left and right subtrees of an operator
node represent subexpressions that must be
evaluated before applying the operator at
the root of the subtree.
A Binary Expression Tree is . . .

43
Levels Indicate Precedence
When a binary expression tree is used to
represent an expression, the levels of the
nodes in the tree indicate their relative
precedence of evaluation.
Operations at higher levels of the tree are
evaluated later than those below them.
The operation at the root is always the
last operation performed.

44
A Binary Expression Tree
‘*’
‘+’
‘4’
‘3’
‘2’
Infix: ( ( 4 + 2 ) * 3 )
Prefix: * + 4 2 3
Postfix: 4 2 + 3 * has operators in order used

45
Inorder Traversal: (A + H) / (M - Y)
‘/’
‘+’
‘A’ ‘H’
‘-’
‘M’ ‘Y’
tree
Print left subtree first Print right subtree last
Print second

46
Preorder Traversal: / + A H - M Y
‘/’
‘+’
‘A’ ‘H’
‘-’
‘M’ ‘Y’
tree
Print left subtree second Print right subtree last
Print first

47
‘/’
‘+’
‘A’ ‘H’
‘-’
‘M’ ‘Y’
tree
Print left subtree first Print right subtree second
Print last
Postorder Traversal: A H + M Y - /

48
Function Eval()
• Definition: Evaluates the expression represented
by the binary tree.
• Size: The number of nodes in the tree.
• Base Case: If the content of the node is an operand,
Func_value = the value of the operand.
• General Case: If the content of the node is an
operator BinOperator,
Func_value = Eval(left subtree)
BinOperator
Eval(right subtree)

49
Writing Recursive Functions (Chpt 7)
 Get an exact definition of the problem to be
solved.
 Determine the size of the problem on this call to
the function.
 Identify and solve the base case(s).
 Identify and solve the general case(s) in terms of a
smaller case of the same problem – a recursive
call.

50
Eval(TreeNode * tree)
Algorithm:
IF Info(tree) is an operand
Return Info(tree)
ELSE
SWITCH(Info(tree))
case + :Return Eval(Left(tree)) + Eval(Right(tree))
case - : Return Eval(Left(tree)) - Eval(Right(tree))
case * : Return Eval(Left(tree)) * Eval(Right(tree))
case / : Return Eval(Left(tree)) / Eval(Right(tree))

int Eval ( TreeNode* ptr )
// Pre: ptr is a pointer to a binary expression tree.
// Post: Function value = the value of the expression represented
// by the binary tree pointed to by ptr.
{ switch ( ptr->info.whichType )
{
case OPERAND : return ptr->info.operand ;
case OPERATOR :
switch ( tree->info.operation )
{
case ‘+’ : return ( Eval ( ptr->left ) + Eval ( ptr->right ) ) ;
case ‘-’ : return ( Eval ( ptr->left ) - Eval ( ptr->right ) ) ;
case ‘*’ : return ( Eval ( ptr->left ) * Eval ( ptr->right ) ) ;
case ‘/’ : return ( Eval ( ptr->left ) / Eval ( ptr->right ) ) ;
}
}
}
51

52
A Nonlinked Representation of
Binary Trees
Store a binary tree in an array in such a
way that the parent-child relationships
are not lost

53
A full binary tree
A full binary tree is a binary tree in which all
the leaves are on the same level and every
non leaf node has two children.
SHAPE OF A FULL BINARY TREE

54
A complete binary tree
A complete binary tree is a binary tree that is
either full or full through the next-to-last
level, with the leaves on the last level as
far to the left as possible.
SHAPE OF A COMPLETE BINARY TREE

55
What is a Heap?
A heap is a binary tree that satisfies these
special SHAPE and ORDER properties:
 Its shape must be a complete binary tree.
 For each node in the heap, the value
stored in that node is greater than or
equal to the value in each of its children.

56
70
0
60
1
40
3
30
4
12
2
8
5
tree
And use the numbers as array
indexes to store the tree
[ 0 ]
[ 1 ]
[ 2 ]
[ 3 ]
[ 4 ]
[ 5 ]
[ 6 ]
70
60
12
40
30
8
tree.nodes

57
Parent-Child Relationship?
tree.nodes[index]:
left child: tree.nodes[index*2 + 1]
right child: tree.nodes[index*2 + 2]
parent: tree.nodes[(index-1) / 2]
Leaf nodes:
tree.nodes[numElements / 2]
…
tree.nodes[numElements - 1]

// HEAP SPECIFICATION
// Assumes ItemType is either a built-in simple data type
// or a class with overloaded realtional operators.
struct HeapType
{
void ReheapDown ( int root , int bottom ) ;
void ReheapUp ( int root, int bottom ) ;
ItemType* elements ; // ARRAY to be allocated dynamically
int numElements ;
};
58

59
ReheapDown(root, bottom)
IF elements[root] is not a leaf
Set maxChild to index of child with larger value
IF elements[root] < elements[maxChild])
Swap(elements[root], elements[maxChild])
ReheapDown(maxChild, bottom)

60
// IMPLEMENTATION OF RECURSIVE HEAP MEMBER FUNCTIONS
void HeapType<ItemType>::ReheapDown ( int root, int bottom )
// Pre: root is the index of the node that may violate the heap
// order property
// Post: Heap order property is restored between root and bottom
{
int maxChild ;
int rightChild ;
int leftChild ;
leftChild = root * 2 + 1 ;
rightChild = root * 2 + 2 ;
60
ReheapDown()

if ( leftChild <= bottom ) // ReheapDown continued
{
if ( leftChild == bottom )
maxChild = leftChld ;
else
{
if (elements [ leftChild ] <= elements [ rightChild ] )
maxChild = rightChild ;
else
maxChild = leftChild ;
}
if ( elements [ root ] < elements [ maxChild ] )
{
Swap ( elements [ root ] , elements [ maxChild ] ) ;
ReheapDown ( maxChild, bottom ) ;
}
}
}
61

62
Priority Queue
A priority queue is an ADT with the
property that only the highest-priority
element can be accessed at any time.

Priority Queue ADT Specification
Structure:
The Priority Queue is arranged to support
access to the highest priority item
Operations:
 MakeEmpty
 Boolean IsEmpty
 Boolean IsFull
 Enqueue(ItemType newItem)
 Dequeue(ItemType& item)
63

Implementation Level
Algorithm:
Dequeue(): O(log2N)
 Set item to root element from queue
 Move last leaf element into root position
 Decrement numItems
 items.ReheapDown(0, numItems-1)
Enqueue(): O(log2N)
 Increment numItems
 Put newItem in next available position
 items.ReheapUp(0, numItems-1)
64

Comparison of Priority Queue
Implementations
65
Enqueue Dequeue
Heap O(log2N) O(log2N)
Linked List O(N) O(1)
Binary Search Tree
Balanced O(log2N) O(log2N)
Skewed O(N) O(N)
Trade-offs: read Text page 548

FRbsbsvvsvsvbshgsgsvzvsvvsvsvsvsvsvvev.ppt

More Related Content

Similar to FRbsbsvvsvsvbshgsgsvzvsvvsvsvsvsvsvvev.ppt (20)

More from hassannadim591 (6)

Recently uploaded (20)

FRbsbsvvsvsvbshgsgsvzvsvvsvsvsvsvsvvev.ppt