Ch 5-2. Arrays Part 2

Transcription

1 Ch 5-2. Arrays Part 2 March 29, 2014 Advanced Networking Technology Lab. (YU-ANTL) Dept. of Information & Comm. Eng, Graduate School, Yeungnam University, KOREA (Tel : ; Fax : ytkim@yu.ac.kr)

2 Outline Programming with Arrays Searching Binary search Bubble sorting Selection sorting Multidimensional Arrays ch

3 Search ( 탐색 ) Examples of Searching an Array search an array (e.g., array of student numbers for all students in a given course) for a given value (a particular student) Search Schemes Sequential search ( 순차탐색 ) Binary search ( 이진탐색 ) ch

4 Sequential Searching Searching an Array (1) ch

5 Searching an Array (2) ch

6 Searching an Array (3) ch

7 Searching an Array (4) ch

8 Binary Search with Recursion Binary Search Algorithm precondition: given data array, data[0..n-1], is sorted vkey = value key to be searched Procedure BinarySearch(int data[], int N, int vkey, int left, int right) //int data[0..n-1]; // sorted array //int vkey: value key to be searched // int left, int right: index of data[] range to be searched if (left > right) found = false; else { mid = approximate midpoint between left and right; // e.g.) mid = (left + right) / 2 if (vkey == data[mid]) { found = true; location = mid; } else if (vkey < data[mid]) BinarySearch(data, N, vkey, left, mid-1); else BinarySearch(data, N, vkey, mid+1, right); } ch

9 Example Execution of Binary Search Function data[n], N = 20; vkey = 9; left = 0 right = 19 mid = (0+19)/2 => 9 vkey < data[9] left = 0 right = 8 mid = (0+8)/2 => 4 vkey > data[4] left = 5 right = 8 mid = (5+8)/2 => 6 vkey < data[6] left = 5 right = 5 mid = (5+5)/2 => 5 vkey == data[5] found=true; location = 5; ch

10 Sorting ( 정렬 ) Sorting array A sorting algorithm is an algorithm that puts elements of a list in a certain order. The most-used orders are numerical order and lexicographical order. Efficient sorting is important for optimizing the use of other algorithms (such as search and merge algorithms) which require input data to be in sorted lists; it is also often useful for canonicalizing data and for producing human-readable output. More formally, the output must satisfy two conditions: The output is in non-decreasing order (each element is no smaller than the previous element according to the desired total order); The output is a permutation (reordering) of the input. Further, the data is often taken to be in an array, which allows random access, rather than a list, which only allows sequential access, though often algorithms can be applied with suitable modification to either type of data. ch

11 Bubble Sorting Bubble Sorting Algorithm 1. Compare 1 st two elements and exchange them if they are out of order. 2. Move down one element and compare 2 nd and 3 rd elements. Exchange if necessary. Continue until the end of the array. 3. Pass through array again, repeating process and exchanging as necessary. 4. Repeat until a pass is made with no exchanges. Example of Bubble sort (increasing order) 1-st process 2-nd process 3-rd process ch

12 // This program uses the bubble sort algorithm // to sort an array in ascending order. #include <iostream> using namespace std; // Function prototypes void bubblesort(int [], int); void showarray(int [], int); int main() { const int SIZE = 6; int values[size] = {7, 2, 3, 8, 9, 1}; } cout << "The unsorted values are: n"; showarray(values, SIZE); bubblesort(values, SIZE); cout << "The sorted values are: n"; showarray(values, SIZE); return 0; ch

13 void bubblesort(int array[], int size) { int temp; bool swap; do { swap = false; for (int i = 0; i < (size - 1); i++) { if (array[i] > array[i + 1]) { temp = array[i]; // if out-of-order, then swap array[i] = array[i + 1]; array[i + 1] = temp; swap = true; } // end if } // end for } while (swap); } void showarray(int array[], int size) { for (int i = 0; i < size; i++) cout << array[i] << " "; cout << endl; } ch

14 Analysis of the Performance of Bubble Sorting Comparisons of each elements in each round multiple swapping of elements in each round ch

15 Selection Sorting Selection Sort Algorithm ch

16 Basic selection algorithm for array Selection sort is a sorting algorithm, specifically an in-place comparison sort. It has O(n 2 ) time complexity, making it inefficient on large lists, and generally performs worse than the similar insertion sort. Selection sort is noted for its simplicity, and also has performance advantages over more complicated algorithms in certain situations, particularly where auxiliary memory is limited. The algorithm works as follows: Find the minimum value in the list Swap it with the value in the first position Repeat the steps above for the remainder of the list (starting at the second position and advancing each time) ch

17 procedure selectionsort( a[] : array of sortable items, n: size ) 1. /* a[0] to a[n-1] is the array to sort */ 2. int ipos, jpos; 3. int imin; /* advance the position through the entire array */ 6. for (ipos = 0; ipos < n-1; ipos++) { // outer loop 7. /* find the min element in the unsorted a[ipos.. n-1] */ 8. imin = ipos; /* assume the min is the first element */ /* test against all other elements */ 11. for (jpos = ipos+1; jpos < n; jpos ++) { // inner loop 12. /* if this element is less, then it is the new minimum */ 13. if (a[jpos] < a[imin]) { 14. /* found new minimum; remember its index */ 15. imin = jpos; 16. } // end if 17. } // end of inner-loop /* imin is the index of the minimum element. 20. Swap it with the current position */ 21. if ( imin!= ipos ) { 22. swap(a, ipos, imin); 23. } 24. } // end of outer-loop 25. end procedure ch

18 Divide and Conquer Quick Sorting Quicksort is a divide and conquer algorithm. Quicksort first divides a large list into two smaller sub-lists: the lower elements and the higher elements. Quicksort can then recursively sort the sub-lists. Steps in Quick Sort Pick an element, called a pivot, from the list. Reorder the list so that all elements with values less than the pivot come before the pivot, while all elements with values greater than the pivot come after it (equal values can go either way). After this partitioning, the pivot is in its final position. This is called the partition operation. Recursively sort the sub-list of lesser elements and the sub-list of greater elements. ch

19 function quicksort('array') // Simple Version if length('array') 1 return 'array' // an array of zero or one elements is already sorted select and remove a pivot value 'pivot' from 'array' create empty lists 'less' and 'greater' for each 'x' in 'array' if 'x' 'pivot' then append 'x' to 'lesser' else append 'x' to 'greater' return concatenate(quicksort('lesser'), 'pivot', quicksort('greater')) // two recursive calls Problems of simple quicksort version need additional memory space for lesser and greater memory is limited valuable resource in most embedded systems => need in-place version ch

20 In-place version of QuickSorting // left is the index of the leftmost element of the array // right is the index of the rightmost element of the array // (inclusive) number of elements in subarray: right-left+1 int partition(array[], left, right, pivotindex) { pivotvalue = array[pivotindex]; swap array[pivotindex] and array[right] // Move pivot to right end storeindex = left; for (i = left; i<= right 1; i++) // left i< right { if (array[i] pivotvalue) { swap array[i] and array[storeindex]; storeindex = storeindex + 1; } } swap array[storeindex] and array[right]; // Move pivot to its final place return storeindex; Yeungnam } University (YU-ANTL) ch

21 function quicksort(array, left, right) { if (left >= right) return; else if (left < right) // subarray of 0 or 1 elements already sorted select a pi (pivotindex) in the range left pi right // e.g.) (left + right) / 2 newpi = partition(array, left, right, pi); // element at newpivotindex (newpi) is now at its final position if (left < (newpi-1)) quicksort(array, left, newpi - 1); // recursively sort elements on the left of pivotnewindex if ((newpi+1) < right) quicksort(array, newpi + 1, right); // recursively sort elements on the right of pivotnewindex } ch

22 Overall Process (1) QS(A[], 0, 12) pi = 0+(12-0)/2 = partition(a[], 0, 12, 6) newpi = QS(A[], 0, 4) pi = 0+(4-0)/2 = 2 partition(a[], 0, 4, 2) newpi = QS(A[], 2, 4) pi = 2+(4-2)/2 = 3 partition(a[], 2, 4, 3) newpi = ch

23 Overall Process (2) QS(A[], 6, 12) pi = 6+(12-6)/2 = partition(a[], 6, 12, 9) newpi = QS(A[], 8, 12) pi = 8+(12-8)/2= partition(a[], 8, 12, 10) newpi = QS(A[], 8, 9) pi = 8+(9-8)/2 = partition(a[], 8, 9, 8) newpi = ch

24 Overall Process (3) QS(A[], 11, 12) pi = 11+(12-11)/2 = partition(a[], 8, 9, 11) newpi = ch

25 Example execution of QuickSort ch

26 Comparisons of Sorting Algorithms Bubble sorting comparisons at each consecutive elements at each inner loop swap the consecutive elements, if necessary, at each inner loop Selection sorting comparisons to find the maximum or minimum element at each inner loop only 1 swap in each inner loop no more memory requirements Quick sorting divide and conquer comparisons and swapping at each stage the number of elements for each stage is divided, recursively over head in function call: more memory requirements ch

27 Multidimensional Arrays Arrays with more than one index char page[30][100]; Two indexes: An "array of arrays" Visualize as: page[0][0], page[0][1],, page[0][99] page[1][0], page[1][1],, page[1][99] page[29][0], page[29][1],, page[29][99] C++ allows any number of indexes Typically no more than two ch

28 Multidimensional Array Parameters Similar to one-dimensional array 1 st dimension size not given Provided as second parameter 2 nd dimension size IS given Example: void DisplayPage(const char p[][size], int sizedimension1) { for (int index1=0; index1<sizedimension1; index1++) { for (int index2=0; index2 < SIZE; index2++) cout << p[index1][index2]; cout << endl; } } ch

29 Display 5.10 Two-dimensional Array grade quiz 1 quiz 2 quiz 3 student 1 student 2 student 3 student 4 grade[0][0] grade[0][1] grade[0][2] grade[1][0] grade[1][1] grade[1][2] grade[2][0] grade[2][1] grade[2][2] grade[3][0] grade[3][1] grade[3][2] ch

30 Display 5.11 quiz 1 quiz 2 quiz 3 student 1 student 2 student 3 student stave[0] 1.0 stave[1] 7.7 stave[2] 7.3 stave[3] 7.0 quizave[0] 5.0 quizave[0] 7.5 quizave[0] ch

31 Display 5.9 Two-Dimensional Array //Reads quiz scores for each student into the two-dimensional array grade. //Computes the average score for each student and //the average score for each quiz. Displays the quiz scores and the averages. #include <iostream> #include <iomanip> using namespace std; const int NUMBER_STUDENTS = 4, NUMBER_QUIZZES = 3; void computestave(const int grade[][number_quizzes], double stave[]); //Precondition: Global constant NUMBER_STUDENTS and NUMBER_QUIZZES //are the dimensions of the array grade. Each of the indexed variables //grade[stnum-1, quiznum-1] contains the score for student stnum on quiz quiznum. //Postcondition: Each stave[stnum-1] contains the average for student number stunum. void computequizave(const int grade[][number_quizzes], double quizave[]); //Precondition: Global constant NUMBER_STUDENTS and NUMBER_QUIZZES //are the dimensions of the array grade. Each of the indexed variables //grade[stnum-1, quiznum-1] contains the score for student stnum on quiz quiznum. //Postcondition: Each quizave[quiznum-1] contains the average for quiz numbered //quiznum. void display(const int grade[][number_quizzes], const double stave[], const double quizave[]); //Precondition: Global constant NUMBER_STUDENTS and NUMBER_QUIZZES are the //dimensions of the array grade. Each of the indexed variables grade[stnum-1, //quiznum-1] contains the score for student stnum on quiz quiznum. Each //stave[stnum-1] contains the average for student stunum. Each quizave[quiznum-1] //contains the average for quiz numbered quiznum. //Postcondition: All the data in grade, stave, and quizave have been output. ch

32 Display 5.9 Two-Dimensional Array (2) int main( ) { int grade[number_students][number_quizzes]; double stave[number_students]; double quizave[number_quizzes]; grade[0][0] = 10; grade[0][1] = 10; grade[0][2] = 10; grade[1][0] = 2; grade[1][1] = 0; grade[1][2] = 1; grade[2][0] = 8; grade[2][1] = 6; grade[2][2] = 9; grade[3][0] = 8; grade[3][1] = 4; grade[3][2] = 10; } computestave(grade, stave); computequizave(grade, quizave); display(grade, stave, quizave); return 0; void computestave(const int grade[][number_quizzes], double stave[]) { for (int stnum = 1; stnum <= NUMBER_STUDENTS; stnum++) {//Process one stnum: double sum = 0; for (int quiznum = 1; quiznum <= NUMBER_QUIZZES; quiznum++) sum = sum + grade[stnum-1][quiznum-1]; //sum contains the sum of the quiz scores for student number stnum. stave[stnum-1] = sum/number_quizzes; //Average for student stnum is the value of stave[stnum-1] } } ch

33 Display 5.9 Two-Dimensional Array (3) void computequizave(const int grade[][number_quizzes], double quizave[]) { for (int quiznum = 1; quiznum <= NUMBER_QUIZZES; quiznum++) {//Process one quiz (for all students): double sum = 0; for (int stnum = 1; stnum <= NUMBER_STUDENTS; stnum++) sum = sum + grade[stnum-1][quiznum-1]; //sum contains the sum of all student scores on quiz number quiznum. quizave[quiznum-1] = sum/number_students; //Average for quiz quiznum is the value of quizave[quiznum-1] } } ch

34 Display 5.9 Two-Dimensional Array (4) void display(const int grade[][number_quizzes], const double stave[], const double quizave[]) { cout.setf(ios::fixed); cout.setf(ios::showpoint); cout.precision(1); cout << setw(10) << "Student" << setw(5) << "Ave" << setw(15) << "Quizzes n"; for (int stnum = 1; stnum <= NUMBER_STUDENTS; stnum++) {//Display for one stnum: cout << setw(10) << stnum << setw(5) << stave[stnum-1] << " "; for (int quiznum = 1; quiznum <= NUMBER_QUIZZES; quiznum++) cout << setw(5) << grade[stnum-1][quiznum-1]; cout << endl; } } cout << "Quiz averages = "; for (int quiznum = 1; quiznum <= NUMBER_QUIZZES; quiznum++) cout << setw(5) << quizave[quiznum-1]; cout << endl; ch

35 Homework Test driver program to measure the elapsed time of sorting functions. In order to test a function as a module in a large scale system, a driver program is temporarily prepared and used. This driver program prepares the testing conditions (i.e., arrays to be sorted, input data file and output data files, etc.), and invokes the module to be tested. The measurement of the elapsed time taken to process some function, is usually performed with system clock readings. In Visual C++, QueryPerformanceCounter (LARGE_INTEGER & time) provides the current time in microsecond. So, reading the system time before and after the function call can provide the time taken for the function call. Write a driver program should prepare 6 integer arrays with 10, 100, 1000, 10,000, 100,000 and 1,000,000 non-duplicated data elements using rand() function. Using the test driver program should check the time taken for the selection sorting and quick sorting algorithm for the 6 integer arrays, individually, and print out the elapsed times for each array size. For each case, print out the first 100 (or the total number of elements) and last 100 elements, before sorting and after sorting. ch

36 ch

37 5-2.2 Measurement of elapsed processing times for binary searching functions. Write a pseudo code for searching an array. Based on the pseudo code, write C++ program of binarysearch(int ma[], int size, int vkey). Write a test driver program that prepares eight integer arrays of 100, 500, 1,000, 5,000, 10,000, 50,000, 100,000, and 500,000 nonduplicated data elements using genbigrandarray(int ma[], int range) function. The generated array should be sorted by using selectionsort() function. The test driver randomly generates vkey, invokes the binarysearch() function, and measures the processing time of each sorting and searching function. Compare and explain the results of measurements of processing time of selectionsort() and quicksort() function with different data size. Explain the general formula for the time taken for selectionsort() and quicksort() from a non-sorted array of size N. ch