chapter 12 recursion, complexity, and searching and sorting fundamentals of java

Chapter 12Recursion, Complexity, and

Searching and Sorting

Fundamentals of Java

Fundamentals of Java 2

Objectives

Design and implement a recursive method to solve a problem.

Understand the similarities and differences between recursive and iterative solutions of a problem.

Check and test a recursive method for correctness.


Objectives (cont.)

Understand how a computer executes a recursive method.

Perform a simple complexity analysis of an algorithm using big-O notation.

Recognize some typical orders of complexity. Understand the behavior of a complex sort

algorithm, such as the quicksort.


Vocabulary

Activation record Big-O notation Binary search algorithm Call stack Complexity analysis


Vocabulary (cont.)

Infinite recursion Iterative process Merge sort Quicksort Recursive method


Vocabulary (cont.)

Recursive step Stack Stack overflow error Stopping state Tail-recursive


Recursion

Recursive functions are defined in terms of themselves.– sum(n) = n + sum(n-1) if n > 1– Example:

Other functions that could be defined recursively include factorial and Fibonacci sequence.


Recursion (cont.)

A method is recursive if it calls itself. Factorial example:

Fibonacci sequence example:


Recursion (cont.)

Tracing a recursive method can help to understand it:


Recursion (cont.)

Guidelines for implementing recursive methods:– Must have a well-defined stopping state– The recursive step must lead to the stopping

state.The step in which the method calls itself

– If either condition is not met, it will result in infinite recursion.

Creates a stack overflow error and program crashes


Recursion (cont.)

Run-time support for recursive methods:– A call stack (large storage area) is created at

program startup.– When a method is called, an activation record

is added to the top of the call stack.Contains space for the method parameters, the

method’s local variables, and the return value

– When a method returns, its activation record is removed from the top of the stack.


Recursion (cont.)

Figure 12-1: Activation records on the call stack during recursive calls to factorial


Recursion (cont.)

Figure 12-2: Activation records on the call stack during returns from recursive calls to factorial


Recursion (cont.)

Recursion can always be used in place of iteration, and vice-versa.– Executing a method call and the corresponding

return statement usually takes longer than incrementing and testing a loop control variable.

– Method calls tie up memory that is not freed until the methods complete their tasks.

– However, recursion can be much more elegant than iteration.


Recursion (cont.)

Tail-recursive algorithms perform no work after the recursive call.– Some compilers can optimize the compiled code

so that no extra stack memory is required.


Complexity Analysis

What is the effect on the method of increasing the quantity of data processed?– Does execution time increase exponentially or

linearly with amount of data being processed? Example:


Complexity Analysis (cont.)

If array’s size is n, the execution time is determined as follows:

Execution time can be expressed using Big-O notation.– Previous example is O(n)

Execution time is on the order of n.Linear time



Another O(n) method:



An O(n2) method:



Table 12-1: Names of some common big-O values



O(1) is best complexity. Exponential complexity is generally bad.

Table 12-2: How big-O values vary depending on n



Recursive Fibonacci sequence algorithm is exponential.– O(rn), where r ≈ 1.62

Figure 12-7: Calls needed to compute the sixth Fibonacci number recursively



Table 12-3: Calls needed to compute the nth Fibonacci number recursively



Three cases of complexity are typically analyzed for an algorithm:– Best case: When does an algorithm do the

least work, and with what complexity?– Worst case: When does an algorithm do the

most work, and with what complexity?– Average case: When does an algorithm do a

typical amount of work, and with what complexity?



Examples:– A summation of array values has a best, worst,

and typical complexity of O(n).Always visits every array element

– A linear search: Best case of O(1) – element found on first

iterationWorst case of O(n) – element found on last

iterationAverage case of O(n/2)



Bubble sort complexity:– Best case is O(n) – when array already sorted– Worst case is O(n2) – array sorted in reverse

order– Average case is closer to O(n2).


Binary Search

Figure 12-9: List for the binary search algorithm with all numbers visible

Figure 12-8: Binary search algorithm (searching for 320)


Binary Search (cont.)

Table 12-4: Maximum number of steps needed to binary search lists of various sizes



Iterative and recursive binary searches are O(log n).



Figure 12-10: Steps in an iterative binary search for the number 320


Quicksort

Sorting algorithms, such as insertion sort and bubble sort, are O(n2).

Quick Sort is O(n log n).– Break array into two parts and then move larger

values to one end and smaller values to other end.

– Recursively repeat procedure on each array half.


Quicksort (cont.)

Figure 12-11: An unsorted array

Phase 1:


Quicksort (cont.)

Phase 1 (cont.):


Quicksort (cont.)

Phase 1 (cont.):

Phase 2 and beyond: Recursively perform phase 1 on each half of the array.


Quicksort (cont.)

Complexity analysis:– Amount of work in phase 1 is O(n).– Amount of work in phase 2 and beyond is O(n).

– In the typical case, there will be log2 n phases.

– Overall complexity will be O(n log2 n).


Quicksort (cont.)

Implementation:


Merge Sort

Recursive, divide-and-conquer approach– Compute middle position of an array and

recursively sort left and right subarrays.– Merge sorted subarrays into single sorted array.

Three methods required:– mergeSort: Public method called by clients– mergeSortHelper: Hides extra parameter

required by recursive calls– merge: Implements merging process


Merge Sort (cont.)


Merge Sort (cont.)

Figure 12-22: Subarrays generated during calls of mergeSort


Merge Sort (cont.)

Figure 12-23: Merging the subarrays generated during a merge sort


Merge Sort (cont.)

Complexity analysis:– Execution time dominated by the two for loops

in the merge method– Each loops (high + low + 1) times

For each recursive stage, O(high + low) or O(n)

– Number of stages is O(log n), so overall complexity is O(n log n).


Design, Testing, and Debugging Hints

When designing a recursive method, ensure:– A well-defined stopping state– A recursive step that changes the size of the

data so the stopping state will eventually be reached

Recursive methods can be easier to write correctly than equivalent iterative methods.

More efficient code is often more complex.


Summary

A recursive method is a method that calls itself to solve a problem.

Recursive solutions have one or more base cases or termination conditions that return a simple value or void.

Recursive solutions have one or more recursive steps that receive a smaller instance of the problem as a parameter.


Summary (cont.)

Some recursive methods combine the results of earlier calls to produce a complete solution.

Run-time behavior of an algorithm can be expressed in terms of big-O notation.

Big-O notation shows approximately how the work of the algorithm grows as a function of its problem size.


Summary (cont.)

There are different orders of complexity such as constant, linear, quadratic, and exponential.

Through complexity analysis and clever design, the complexity of an algorithm can be reduced to increase efficiency.

Quicksort uses recursion and can perform much more efficiently than selection sort, bubble sort, or insertion sort.

chapter 12 recursion, complexity, and searching and sorting fundamentals of java

Documents

recursive calls

recursive methods

java objectivesdesign

method calls

method parameters

tailrecursive algorithms

extra stack memory

factorial example