There are often many approaches (algorithms) to solve a problem. How do we choose between them?
At the heart of computer program design are two (sometimes conflicting) goals.
- To design an algorithm that is easy to understand, code, debug.
- To design an algorithm that makes efficient use of the computer’s resources.
Goal (1) is the concern of Software Engineering
Goal (2) is the concern of data structures and algorithm analysis
Example 1: Find largest value
// Return position of largest value in integer array A
static int largest(int[] A) {
int currlarge = 0; // Position of largest element seen
for (int i=1; i<A.length; i++) { // For each element
if (A[currlarge] < A[i]) { // if A[i] is larger
currlarge = i; // remember its position
}
}
return currlarge; // Return largest position
}
Example 2: Assignment statement
Example 3: Double loop
sum = 0;
for (j=1; j<=n; j++) { // First for loop
for (i=1; i<=j; i++) { // is a double loop
sum++;
}
}
for (k=0; k<n; k++) { // Second for loop
A[k] = k;
}
Not all inputs of a given size take the same time to run.
Sequential search for K in an array of \(n\) integers:
Best case:
Worst case:
Average case:
Suppose we buy a computer 10 times faster.
Definition: For \(\mathbf{T}(n)\) a non-negatively valued function, \(\mathbf{T}(n)\) is in the set \(O(f(n))\) if there exist two positive constants \(c\) and \(n_0\) such that \(T(n) \leq cf(n)\) for all \(n > n_0\).
Use: The algorithm is in \(O(n^2)\) in [best, average, worst] case.
Meaning: For all data sets big enough (i.e., \(n>n_0\)), the algorithm always executes in less than \(cf(n)\) steps in the [best, average, worst] case.
Big-oh notation indicates an upper bound.
Example: If \(\mathbf{T}(n) = 3n^2\) then \(\mathbf{T}(n)\) is in \(O(n^2)\).
Look for the tightest upper bound:
Example 1: Finding value X in an array (average cost).
Then \(\textbf{T}(n) = c_{s}n/2\).
For all values of \(n > 1, c_{s}n/2 \leq c_{s}n\).
Therefore, the definition is satisfied for \(f(n)=n, n_0 = 1\), and \(c = c_s\). Hence, \(\textbf{T}(n)\) is in \(O(n)\).
Example 2: Suppose \(\textbf{T}(n) = c_{1}n^2 + c_{2}n\), where \(c_1\) and \(c_2\) are positive.
\(c_{1}n^2 + c_{2}n \leq c_{1}n^2 + c_{2}n^2 \leq (c_1 + c_2)n^2\) for all \(n > 1\).
Then \(\textbf{T}(n) \leq cn^2\) whenever \(n > n_0\), for \(c = c_1 + c_2\) and \(n_0 = 1\).
Therefore, \(\textbf{T}(n)\) is in \(O(n^2)\) by definition.
Example 3: \(\textbf{T}(n) = c\). Then \(\textbf{T}(n)\) is in \(O(1)\).
“The best case for my algorithm is n=1 because that is the fastest.”
WRONG!
Big-oh refers to a growth rate as n grows to \(\infty\)
Best case is defined for the input of size n that is cheapest among all inputs of size \(n\).
Definition: For \(\textbf{T}(n)\) a non-negatively valued function, \(\textbf{T}(n)\) is in the set \(\Omega(g(n))\) if there exist two positive constants \(c\) and \(n_0\) such that \(\textbf{T}(n) \geq cg(n)\) for all \(n > n_0\).
Meaning: For all data sets big enough (i.e., \(n > n_0\)), the algorithm always requires more than \(cg(n)\) steps.
Lower bound.
\(\textbf{T}(n) = c_1n^2 + c_2n\).
\(c_1n^2 + c_2n \geq c_1n^2\) for all \(n > 1\).
\(\textbf{T}(n) \geq cn^2\) for \(c = c_1\) and \(n_0 = 1\).
Therefore, \(\textbf{T}(n)\) is in \(\Omega(n^2)\) by the definition.
We want the greatest lower bound.
When big-Oh and \(\Omega\) coincide, we indicate this by using \(\Theta\) (big-Theta) notation.
Definition: An algorithm is said to be in \(\Theta(h(n))\) if it is in \(O(h(n))\) and it is in \(\Omega(h(n))\).
Confusing worst case with upper bound.
Upper bound refers to a growth rate.
Worst case refers to the worst input from among the choices for possible inputs of a given size.
.
Example: a = b;
This assignment takes constant time, so it is \(\Theta(1)\).
Example:
sum = 0;
for (i=1; i<=n; i++) {
sum += n;
}
Example:
sum = 0;
for (j=1; j<=n; j++) { // First for loop
for (i=1; i<=j; i++) { // is a double loop
sum++;
}
}
for (k=0; k<n; k++) { // Second for loop
A[k] = k;
}
Example: Compare these two code fragments:
sum1 = 0;
for (i=1; i<=n; i++) { // First double loop
for (j=1; j<=n; j++) { // do n times
sum1++;
}
}
sum2 = 0;
for (i=1; i<=n; i++) { // Second double loop
for (j=1; j<=i; j++) { // do i times
sum2++;
}
}
Not all double loops are \(\Theta(n^2)\).
sum1 = 0;
for (k=1; k<=n; k*=2) { // Do log n times
for (j=1; j<=n; j++) { // Do n times
sum1++;
}
}
sum2 = 0;
for (k=1; k<=n; k*=2) { // Do log n times
for (j=1; j<=k; j++) { // Do k times
sum2++;
}
}
How many elements are examined in worst case?
// Return the position of an element in sorted array A with value K.
// If K is not in A, return A.length.
public static int binarySearch(int[] A, int K) {
int low = 0;
int high = A.length - 1;
while(low <= high) { // Stop when low and high meet
int mid = (low + high) / 2; // Check middle of subarray
if( A[mid] < K) low = mid + 1; // In right half
else if(A[mid] > K) high = mid - 1; // In left half
else return mid; // Found it
}
return A.length; // Search value not in A
}
while loop: Analyze like a for loop.
if statement: Take greater complexity of then/else clauses.
switch statement: Take complexity of most expensive case.
Subroutine call: Complexity of the subroutine.
Upper bound: Upper bound of best known algorithm.
Lower bound: Lower bound for every possible algorithm.
May or may not be able to obtain matching upper and lower bounds.
Example of imperfect knowledge: Sorting
One can often reduce time if one is willing to sacrifice space, or vice versa.
Disk-based Space/Time Tradeoff Principle: The smaller you make the disk storage requirements, the faster your program will run.
Compute the rank ordering for all C pixel values in a picture of P pixels.
for (i=0; i<C; i++) { // Initialize count
count[i] = 0;
}
for (i=0; i<P; i++) { // Look at all of the pixels
count[value(i)]++; // Increment a pixel value count
}
sort(count); // Sort pixel value counts
If we use P as the measure, then time is \((P \log P)\).
More accurate is \(\Theta(P + C log C)\).
Space complexity can also be analyzed with asymptotic complexity analysis.
Time: Algorithm
Space: Data Structure