lecture 4 sept 4 goals: chapter 1 (completion)
DESCRIPTION
Lecture 4 Sept 4 Goals: chapter 1 (completion) 1-d array examples Selection sorting Insertion sorting Max subsequence sum Algorithm analysis (Chapter 2). Parameter passing call by value and reference: - PowerPoint PPT PresentationTRANSCRIPT
Lecture 4 Sept 4
Goals:• chapter 1 (completion)
• 1-d array examples•Selection sorting•Insertion sorting•Max subsequence sum
•Algorithm analysis (Chapter 2)
Parameter passing• call by value and reference:
What are the outputs of the following program?
#include <iostream>
using namespace std;
int f(int x) { x++; cout << x << endl; return x*x; }
int main(){
int x = 5; cout << f(x) << endl; cout << x << endl;
}
#include <iostream>
using namespace std;
int f(int& x) { x++; cout << x << endl; return x*x; }
int main(){
int x = 5; cout << f(x) << endl; cout << x << endl;
}
Parameter passing
• In c++, all parameter passing is done by value unless & is used preceding the name of the variable.
• Advantage of call by value:• safer• easier to understand and debug
• Disadvantage of call by value:• not efficient (copying costs both in time and space)• especially a problem when a large object is passed as parameter.
• call by reference is complementary
Parameter passing
• call by const reference:• getting advantages of both conventions• should be used when passing objects (especially when it is large)
• call by const reference:
• getting advantages of both conventions• should be used when passing objects (especially when it is large)
•Constant return value from a function (The returned object can’t be modified.)
• Section 1.6 templates
Implementation of a list class
• list class with the following functionality:
• list is singly-linked, with a head pointer
• constructor(s)
• functions:• insert(int item, int posn)• length()• delete(int posn)• search(int item)
Implementing insert
To insert a key x as the k-th key
a k g c
x = ‘b’ and k = 5
a k g c
b
Recursive version of insert
void insert(int x, int k) { // insert x as the k-th item of the list // assume that the list has at least k – 1 items Node* tmp = new Node(k); if (k == 1) { tmp->next = head; head = tmp; } else { List temp(head->next); temp.insert(x, k – 1); }}
Insertion sorting
At the start of the k-th cycle: A[0 .. k–1] is sorted. At the end of the k-th cycle: A[k] is inserted into correct place so that A[0 .. k] is sorted.
Example: k = 5
Before: 1 5 9 13 21 11 23 20 4 31 8
After: 1 5 9 11 13 21 23 20 4 31 8
Insertion step
temp = A[j];for (k = j – 1; k >= 0 && A[k] > temp; --k) A[k+1] = A[k];A[k+1] = temp;
Insertion sorting
Repeat the insertion cycle for j = 1, 2, 3, …, n – 1.
The complete code is as follows:
for (j = 1; j < n; ++j) { temp = A[j]; for (k = j – 1; k >= 0 && A[k] > temp; --k) A[k+1] = A[k]; A[k+1] = temp; }
The following link contains an applet to animate various sorting (and other) algorithms:
http://math.hws.edu/TMCM/java/xSortLab/
A screen shot is shown below:
Selection SortSelection Sorting Algorithm:• • During the j-th pass (j = 0, 1, …, n – 2), we will examine the elements of the array a[j] , a[j+1], …, a[n-1] and determine the index min of the smallest key. • Swap a[min] and a[j].
Reselection_sort(vector<int> a) { if (a.size() == 1) return; for (int j = 0; j < n – 1; ++j) { min = j; for (int k= j+1; k<=n-1; ++k) if (a[k] < a[min]) min = k; swap a[min] and a[j]; } }
Selection sorting animation can be found in the same site.
Algorithm analysis
• Analysis is the process of estimating the number of computational steps performed by a program (usually as a function of the input size).
• Useful to compare different approaches. Can be done before coding. Does not require a computer (paper and pencil).
• Order of magnitude (rough) estimate is often enough. We will introduce a notation to convey the estimates. (O notation).
Insertion sorting - analysis
for (j = 1; j < n; ++j) { temp = A[j]; for (k = j – 1; k >= 0 && A[k] > temp; --k) A[k+1] = A[k]; A[k+1] = temp; }
How many comparisons are performed?
• Consider the j-th iteration of the inner loop.
• In the worst-case, the loop will be iterated j times.
• Each time, two comparisons are performed. Total = 2j
First iteration performs 2 x 1 comparisons
Second iteration performs 2 x 2 comparisons
. . . .
n – 1 th iteration performs 2 x (n – 1) comparisons
Total number of comparisons performed by insertion sorting
= 2 x (1 + 2 + … + n – 1) = n (n – 1) ~ n2 comparisons
Note the approximation we used:
When n = 1000, n2 = one million, n2 – n = 999000 so the error in our estimate is 0.1%
Analysis of selection sorting
Consider the program to find the min number in an array:
min = a[0]; for (j = 1; j < n; ++j) if (A[j] > min) min = A[j];
The number of comparisons performed is n – 1.
loop starts with j = 1 and ends with j = n so the number of iterations = n – 1.
In each iteration, one comparison is performed.
Selection sorting – analysis
The inner loop:
n – 1 comparisons during the first iteration of the inner loop
n – 2 comparisons during the 2nd iteration of the inner loop . . . .
1 comparison during the last iteration of the inner loop
Total number of comparisons = 1 + 2 + … + (n – 1) =
n(n – 1)/ 2
General rule
• If there is a nested loop, analyze the inner loop and calculate the number of operations performed by the inner loop.
• Suppose the j-th iteration of the inner loop performs f(j) operations
• Suppose the value of j in the outer loop goes from 1 to m, then the total number of operations is
f(1) + f(2) + … + f(m)
Exercise: What is the number of operations (additions) by the following program?
for (j = 100; j < 200; ++j) if (j % 2 == 0) sum+= A[j];
Exercise: What is the number of operations (additions) by the following program?
for (j = 100; j < 200; ++j) if (j % 2 == 0) sum+= A[j];
Answer: The number of iterations of the loop = 100,But the addition is performed in every other iteration so the number of additions performed = 50.
O (order) notationDefinition: Let f(n) and g(n) be two functions defined on the set of integers. If there is a c > 0 such that f(n) <= c g(n) for all large enough n. Then, we say f(n) = O(g(n)).
Example: n2 + 2n – 15 is O(n2)
Rule: When the expression involves a sum, keep only the term with the highest power, drop the rest. You can also drop constant multiplying terms.
(3n2 + 2 n + 1) (4 n – 5) is O(n3)
Max Subsequence Problem Given a sequence of integers A1, A2, …, An, find the
maximum possible value of a subsequence Ai, …, Aj.
Numbers can be negative.
You want a contiguous chunk with largest sum.
Example: -2, 11, -4, 13, -5, -2 The answer is 20 (subsequence A2 through A4).
We will discuss three different algorithms, with time complexities O(n3), O(n2), and O(n).
With n = 106, algorithm 1 may take > 10 years; algorithm 3 will take a fraction of a second!
int maxSum = 0;
for( int i = 0; i < a.size( ); i++ )for( int j = i; j < a.size( ); j++ ){
int thisSum = 0;for( int k = i; k <= j; k++ )
thisSum += a[ k ];if( thisSum > maxSum )
maxSum = thisSum;}return maxSum;
Algorithm 1 for Max Subsequence Sum Given A1,…,An , find the maximum value of Ai+Ai+1+···+Aj
0 if the max value is negative
Time complexity: O(n3)
)1(O
( )O j i
)1(O
)1(O
)1(O
1
( ( ))n
j i
O j i
1 1
0
( ( ))n n
i j i
O j i
Algorithm 2 Idea: Given sum from i to j-1, we can compute
the sum from i to j in constant time. This eliminates one nested loop, and reduces the
running time to O(n2).
into maxSum = 0;
for( int i = 0; i < a.size( ); i++ )int thisSum = 0;for( int j = i; j < a.size( ); j+
+ ){ thisSum += a[ j ]; if( thisSum > maxSum )
maxSum = thisSum;}
return maxSum;
Algorithm 3Algorithm 3
int maxSum = 0, thisSum = 0;
for( int j = 0; j < a.size( ); j++ ){
thisSum += a[ j ];
if ( thisSum > maxSum )maxSum = thisSum;
else if ( thisSum < 0 )thisSum = 0;
}return maxSum
The algorithm resets whenever prefix is < 0. Otherwise, it forms new sums and updates maxSum in one pass.