1 Main Index Conten ts 1 Main Index Conten ts Selection Sort (3 slides) Selection Sort Alg . (3 slides) Search Algorithms (6 slides) Illustrating the Binary Illustrating the Binary Search Search -Successful (3 slides) -Unsuccessful (3 slides) Binary Search Alg . (3 slides) Big-O Notation Constant Time Algorithm s Chapter 3 Chapter 3 – – Introduction to Algorithms Introduction to Algorithms Selection Sort Selection Sort Algorithm Algorithm -Integer Version -String Version Template Syntax (4 slides) Recursive Def n of the Power Fnc Stopping Conditions for - Recursive Algorithms Implementing the Recurs ive- Power Function Tower of Hanoi w/ Recur sion (3 slides) Fibonacci Numbers Using - Iteration (2 slides)
49
Embed
Main Index Contents 11 Main Index Contents Selection Sort Selection SortSelection Sort Selection Sort (3 slides) Selection Sort Alg. Selection Sort Alg.Selection.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
1 Main IndexMain Index ContentsContents1 Main IndexMain Index ContentsContents
// if smallIndex and pass are not the // same location, exchange the // smallest item in the sublist
with // arr[pass]
if (smallIndex != pass)
{
temp = arr[pass];
arr[pass] = arr[smallIndex];
arr[smallIndex] = temp;}
}
}
10 Main IndexMain Index ContentsContents
Search AlgorithmsSearch Algorithms
0 1 2 6 7 8
firs t las t
A rray arr
543
Search algorithms start with a target value and employ some strategy to visit the elements looking for a match.– If target is found, the index of the matching
element becomes the return value.
11 Main IndexMain Index ContentsContents11 Main IndexMain Index ContentsContents
6 4 2 9 5 10
ind ex = s eq S earc h(arr, 0 , 8 , 3);
7
Ind ex 0 1 2 3 4 5 6 7
3
target = 38
m atc h at ind ex = 5return ind ex 5
Search Search AlgorithmsAlgorithms
6 4 2 9 5 3 10 7
Ind ex 0 1 2 3 4 5 6 7target = 9
8
no m atc hreturn ind ex 8
ind ex = s eq S earc h(arr, 0 , 8 , 9);
12 Main IndexMain Index ContentsContents12 Main IndexMain Index ContentsContents
int seqSearch(const int arr[], int first, int last, int target)
{
int i = first;// scan indices in the range first <= I < last; // test for a match or index out of range.
while(i != last && arr[i] != target)
i++;
return i;// i is index of match or i = last if no
match
}
13 Main IndexMain Index ContentsContents
Search Algorithms Search Algorithms
Case 1.
A match occurs. The search is complete and mid is the index that locates the target.
if (midValue == target)// found match
return mid;
m idfirs t
target
C as e 1: target = m id valueS earc h is d o ne
las t-1 las t
14 Main IndexMain Index ContentsContents
Search Algorithms Search Algorithms
Case 2.The value of target is less than midvalue and the search must continue in the lower sublist. Reposition the index last to the
end of the sublist (last = mid).
// search the lower sublist
if (target < midvalue)<reposition last to mid><search sublist arr[first]…arr[mid-1]
las t-1firs t
target
C as e 2: target < m id valueS earc h lo w er s ub lis t
m id -1 las t
15 Main IndexMain Index ContentsContents
Search Algorithms Search Algorithms
Case 3.The value of target is greater than midvalue and the search
must continue in the upper sublist . Reposition the index first to the front of the sublist (first = mid+1).
// search upper sublist
if (target > midvalue)
<reposition first to mid+1>
<search sublist arr[mid+1]…arr[last-1]>
C as e 3: target > m id valueS earc h up p er s ub lis t
las t-1new firs t = m id + 1
firs t
target
las t
16 Main IndexMain Index ContentsContents16 Main IndexMain Index ContentsContents
Illustrating the Binary SearchIllustrating the Binary Search- Successful Search- Successful Search
1. Search for target = 23
Step 1: Indices first = 0, last = 9, mid = (0+9)/2 = 4.
Since target = 23 > midvalue = 12, step 2 searches the upper sublist with first = 5 and last = 9.
m id
-7 3 5 8 12 16arr
0 1 2 3 4 5
23 33 55
6 7 8 9
17 Main IndexMain Index ContentsContents17 Main IndexMain Index ContentsContents
Illustrating the Binary SearchIllustrating the Binary Search- Successful Search- Successful Search
Step 2:
Indices first = 5, last = 9, mid = (5+9)/2 = 7.
Since target = 23 < midvalue = 33, step 3 searches the lower sublist with first = 5 and last = 7.
m id
-7 3 5 8 12 16arr
0 1 2 3 4 5
23 33 55
6 7 8 9
18 Main IndexMain Index ContentsContents18 Main IndexMain Index ContentsContents
Illustrating the Binary SearchIllustrating the Binary Search- Successful Search- Successful Search
Step 3: Indices first = 5, last = 7, mid = (5+7)/2 = 6.
Since target = midvalue = 23, a match is found at index mid = 6.
m id
-7 3 5 8 12 16arr0 1 2 3 4 5
23 33 55
6 7 8 9
19 Main IndexMain Index ContentsContents
Illustrating the Binary SearchIllustrating the Binary Search- Unsuccessful Search- Unsuccessful Search
Search for target = 4.
Step 1: Indices first = 0, last = 9, mid = (0+9)/2 = 4.
m id
-7 3 5 8 12 16arr
0 1 2 3 4 5
23 33 55
6 7 8 9
Since target = 4 < midvalue = 12, step 2 searches the lower sublist with first = 0 and last = 4.
20 Main IndexMain Index ContentsContents
Illustrating the Binary SearchIllustrating the Binary Search- Unsuccessful Search- Unsuccessful Search
Step 2: Indices first = 0, last = 4, mid = (0+4)/2 = 2.
Since target = 4 < midvalue = 5, step 3 searches the lower sublist with first = 0 and last 2.
m id
-7 3 5 8 12 16arr0 1 2 3 4 5
23 33 556 7 8
21 Main IndexMain Index ContentsContents
Illustrating the Binary SearchIllustrating the Binary Search- Unsuccessful Search- Unsuccessful Search
Step 3: Indices first = 0, last = 2, mid = (0+2)/2 = 1.
Since target = 4 > midvalue = 3, step 4 should search the upper sublist with first = 2 and last =2. However, since first >= last, the target is not in the list and we return index last = 9.
m id
-7 3 5 8 12 16arr
0 1 2 3 4 5
23 33 55
6 7 8 9
22 Main IndexMain Index ContentsContents22 Main IndexMain Index ContentsContents
Binary Search AlgorithmBinary Search Algorithm
Int binSearch(const int arr[], int first, int last, int
target)
{
int mid; // index of the midpoint
int midvalue;// object that is // assigned arr[mid]
int origLast = last;// save original value of last
23 Main IndexMain Index ContentsContents23 Main IndexMain Index ContentsContents
Binary Search AlgorithmBinary Search Algorithm
while (first < last)// test for nonempty sublist
{
mid = (first+last)/2;
midvalue = arr[mid];
if (target == midvalue)
return mid; // have a match
// determine which sublist to // search
24 Main IndexMain Index ContentsContents24 Main IndexMain Index ContentsContents
Binary Search AlgorithmBinary Search Algorithm
else if (target < midvalue)
last = mid;// search lower sublist. reset
last
elsefirst = mid+1;// search upper sublist. Reset
first
}
return origLast;// target not found
}
25 Main IndexMain Index ContentsContents
Big-O notationBig-O notation
For the selection sort, the number of comparisons is T(n) = n2/2 - n/2.
2
n
2
2n
T(n)
Entire expression is called the "Big-O" measure for the algorithm.
** Big-O notation provides a machine independent means for determining the efficiency of an
26 Main IndexMain Index ContentsContents26 Main IndexMain Index ContentsContents
Constant Time AlgorithmsConstant Time AlgorithmsAn algorithm is O(1) when its running time is independent of the number of data items. The algorithm runs in constant time.
The storing of the element involves a simple assignment statement and thus has efficiency O(1).
fro nt rear
D irec t In se r t a t R ear
27 Main IndexMain Index ContentsContents
Linear Time AlgorithmsLinear Time AlgorithmsAn algorithm is O(n) when its running time is proportional to the size of the list.
When the number of elements doubles, the number of operations doubles.
S equential S e arch fo r the Minim um E lem ent in an A rray
32 46 8 12 3
m in im u m elem en t fou n d in th e list a fter n com p a rison s
n = 51 2 3 4 5
28 Main IndexMain Index ContentsContents28 Main IndexMain Index ContentsContents
Exponential AlgorithmsExponential AlgorithmsAlgorithms with running time O(n2) are
quadratic.– practical only for relatively small values of n.
Whenever n doubles, the running time of the algorithm increases by a factor of 4.
Algorithms with running time O(n3)are cubic.– efficiency is generally poor; doubling the size
of n increases the running time eight-fold.
29 Main IndexMain Index ContentsContents29 Main IndexMain Index ContentsContents
Logarithmic Time AlgorithmsLogarithmic Time AlgorithmsThe logarithm of n, base 2, is commonly used when analyzing computer algorithms.Ex. log2(2) = 1
log2(75) = 6.2288
When compared to the functions n and n2, the function log2 n grows very slowly.
nn 2
lo g 2n
31 Main IndexMain Index ContentsContents31 Main IndexMain Index ContentsContents
Selection Sort AlgorithmSelection Sort AlgorithmInteger VersionInteger Version
void selectionSort(int arr[], int n) { . . .int temp; // int temp used for the exchange
for (pass = 0; pass < n-1; pass++)
{. . .
if (arr[j] < arr[smallIndex]) // compare integer elements . . .
}
}
32 Main IndexMain Index ContentsContents32 Main IndexMain Index ContentsContents
Selection Sort AlgorithmSelection Sort AlgorithmString VersionString Version
void selectionSort(string arr[], int n) { . . .
string temp; // double temp used for the exchange
for (pass = 0; pass < n-1; pass++) {
. . .
if (arr[j] < arr[smallIndex])// compare string element
. . .}
}
33 Main IndexMain Index ContentsContents
Template SyntaxTemplate Syntax template function syntax includes the keyword
template followed by a non-empty list of formal types enclosed in angle brackets.
In the argument list, each type is preceded by the keyword typename, and types are separated by commas.
// argument list with a multiple template // types
template <typename T, typename U, typename V, ...>
34 Main IndexMain Index ContentsContents
Template Syntax ExampleTemplate Syntax Example
template <typename T>
void selectionSort(T arr[], int n)
{
int smallIndex; // index of smallest element in the // sublist
int pass, j;
T temp;
35 Main IndexMain Index ContentsContents
Template Syntax ExampleTemplate Syntax Example
// pass has the range 0 to n-2
for (pass = 0; pass < n-1; pass++)
{
// scan the sublist starting at // index pass
smallIndex = pass;
// j traverses the sublist // a[pass+1] to a[n-1]
for (j = pass+1; j < n; j++)
// update if smaller element found
36 Main IndexMain Index ContentsContents
Template Syntax ExampleTemplate Syntax Example
if (arr[j] < arr[smallIndex])smallIndex = j;
// if smallIndex and pass are not // the same location, exchange the // smallest item in the sublist
with // arr[pass]
if (smallIndex != pass){
temp = arr[pass];arr[pass] =
arr[smallIndex];arr[smallIndex] = temp; }
} }
37 Main IndexMain Index ContentsContents37 Main IndexMain Index ContentsContents
Recursive Definition of the Recursive Definition of the Power FunctionPower Function
A recursive definition distinguishes between the exponent n = 0 (starting point) and n 1 which assumes we already know the value xn-1.
After determining a starting point, each step uses a known power of 2 and doubles it to compute the next result.– Using this process gives us a new definition for the
power function, xn.
We compute all successive powers of x by multiplying the previous value by x.
1,*
0,11 nxx
nx n
n
38 Main IndexMain Index ContentsContents
Stopping Conditions for Stopping Conditions for Recursive AlgorithmsRecursive Algorithms
Use a recursive function to implement a recursive algorithm. – The design of a recursive function consists
of1. One or more stopping conditions that can be directly evaluated for certain arguments.
2. One or more recursive steps in which a current value of the function can be computed by repeated calling of the function with arguments that will eventually arrive at a stopping condition.
39 Main IndexMain Index ContentsContents39 Main IndexMain Index ContentsContents
Implementing the Recursive Implementing the Recursive Power FunctionPower Function
Recursive power():
double power(double x, int n) // n is a non-negative integer
{
if (n == 0)
return 1.0; // stopping condition
else
return x * power(x,n-1);// recursive step
}
40 Main IndexMain Index ContentsContents40 Main IndexMain Index ContentsContents
Solving the Tower of Hanoi Solving the Tower of Hanoi Puzzle using RecursionPuzzle using Recursion
N eed le A
. . . . . . . .
N eed le CN eed le B N eed le C
. . . . . . . .
N eed le BN eed le A
N e e dle A N e e dle B N e e dle C
1
N e e dle B N e e dle CN e e dle A
2
3
N e e dle A N e e dle B N e e dle CN e e dle A N e e dle B N e e dle C
41 Main IndexMain Index ContentsContents41 Main IndexMain Index ContentsContents
Solving the Tower of Hanoi Solving the Tower of Hanoi Puzzle using RecursionPuzzle using Recursion
N eed le A
. . . . . . . .
N eed le CN eed le B N eed le C
. . . . . . . .
N eed le BN eed le A
N e e dle A N e e dle B N e e dle C N e e dle A N e e dle B N e e dle C
4
42 Main IndexMain Index ContentsContents42 Main IndexMain Index ContentsContents
Solving the Tower of Hanoi Solving the Tower of Hanoi Puzzle using RecursionPuzzle using Recursion
N eed le A
. . . . . . . .
N eed le CN eed le B N eed le C
. . . . . . . .
N eed le BN eed le A
N eed le A N eed le B N eed le C N eed le A N eed le B N eed le C
56
N eed le A N eed le B N eed le C N eed le A N eed le B N eed le C
7
43 Main IndexMain Index ContentsContents
Fibonacci Numbers using Fibonacci Numbers using IterationIteration
int fibiter(int n)
{// integers to store previous two
// Fibonacci value
int oneback = 1, twoback = 1, current;
int i;
// return is immediate for first two numbers
if (n == 1 || n == 2)
return 1;
44 Main IndexMain Index ContentsContents
Fibonacci Numbers using Fibonacci Numbers using IterationIteration
else// compute successive terms beginning at 3
for (i = 3; i <= n; i++)
{
current = oneback + twoback;
twoback = oneback;// update for next calculation
oneback = current;
}
return current;
}
45 Main IndexMain Index ContentsContents45 Main IndexMain Index ContentsContents
Summary Slide 1Summary Slide 1
§- The simplest form of searching is the sequential search.
§- It compares the target with every element in a list until matching the target or reaching the end of
the list.
§- If the list is in sorted order, the binary search algorithm is more efficient.
§- It exploits the structure of an ordered list to produce very fast search times.
46 Main IndexMain Index ContentsContents46 Main IndexMain Index ContentsContents
Summary Slide 2Summary Slide 2
§- Big-O notation measures the efficiency of an algorithm by estimating the number of certain
operations that the algorithm must perform.
- For searching and sorting algorithms, the operation is data comparison.
- Big-O measure is very useful for selecting among competing algorithms.
47 Main IndexMain Index ContentsContents47 Main IndexMain Index ContentsContents
Summary Slide 3Summary Slide 3
§- The running time of the sequential search is O(n) for the worst and the average cases.
§- The worst and average case for the binary search is O(log2n).
§- Timing data obtained from a program provides experimental evidence to support the greater
efficiency of the binary search.
48 Main IndexMain Index ContentsContents48 Main IndexMain Index ContentsContents
Summary Slide 4Summary Slide 4
§- C++ provides a template mechanism that allows a programmer to write a single version of a function with general type arguments.
- If a main program wants to call the function several times with different runtime arguments, the compiler looks at the types of the runtime arguments and creates different versions of the function that matches the types.
49 Main IndexMain Index ContentsContents49 Main IndexMain Index ContentsContents
Summary Slide 5Summary Slide 5
§- An algorithm is recursive if it calls itself for smaller problems of its own type.
§- Eventually, these problems must lead to one or more stopping conditions.
- The solution at a stopping condition leads to the solution of previous problems.
- In the implementation of recursion by a C++ function, the function calls itself.