Lecture 14. Arrays II. Selection Sort & Parallel Arrays. CptS 121 Summer 2016 Armen Abnousi

Transcription

1 Lecture 14 Arrays II Selection Sort & Parallel Arrays CptS 121 Summer 2016 Armen Abnousi

2 Sorting an array We have seen how to search in an array Often we want to sort our arrays for more efficient future operations or for a readable output. A sorted array contains all the elements of the original array but in an increasing (decreasing) order. i.e.: a[0] <= a[1] <= a[2] <= a[3] <= <= a[arraysize 1] or: a[0] >= a[1] >= a[2] >= a[3] >= >= a[arraysize 1] There are multiple sorting algorithms

3 Selection Sort Selection sort is an intuitive but inefficient algorithm for sorting: Given an array of size n: Find the minimum in the array (indices 0 to n-1). Swap the minimum value with the value in index 0. Assume the new array starts at position 1. Find the minimum of the new array (index 1 to n-1). Swap the new minimum value with the value in index 1. And so on.

4

5

6 Now we need to work on the array starting from index 1 only. Index 0 contains the correct value for the sorted array.

7 Now we need to work on the array starting from index 1 only. Index 0 contains the correct value for the sorted array.

8 Now we need to work on the array starting from index 2 only. Indices 0 and 1 contain the correct values for the sorted array.

9 Now we need to work on the array starting from index 2 only. Indices 0 and 1 contain the correct values for the sorted array.

10 Now we need to work on the array starting from index 3 only. Indices 0, 1 and 2 contain the correct values for the sorted array.

11 Now we need to work on the array starting from index 3 only. Indices 0, 1 and 2 contain the correct values for the sorted array.

12 Now we need to work on the array starting from index 4 only. Indices 0, 1, 2 and 3 contain the correct values for the sorted array.

13 Now we need to work on the array starting from index 4 only. Indices 0, 1, 2 and 3 contain the correct values for the sorted array.

14 Now we need to work on the array starting from index 5 only. Indices 0, 1, 2, 3 and 4 contain the correct values for the sorted array.

15 Now we need to work on the array starting from index 5 only. Indices 0, 1, 2, 3 and 4 contain the correct values for the sorted array.

16 Now we need to work on the array starting from index 6 only. Indices 0, 1, 2, 3, 4 and 5 contain the correct values for the sorted array.

17 Now we need to work on the array starting from index 6 only. Indices 0, 1, 2, 3, 4 and 5 contain the correct values for the sorted array.

18 Now we need to work on the array starting from index 7 only. Indices 0, 1, 2, 3, 4, 5 and 6 contain the correct values for the sorted array.

19 Now we need to work on the array starting from index 7 only. Indices 0, 1, 2, 3, 4, 5 and 6 contain the correct values for the sorted array.

20 Now we need to work on the array starting from index 8 only. Indices 0, 1, 2, 3, 4, 5, 6 and 7 contain the correct values for the sorted array.

21 Now we need to work on the array starting from index 8 only. Indices 0, 1, 2, 3, 4, 5, 6 and 7 contain the correct values for the sorted array.

22 Now we need to work on the array starting from index 9 only. Indices 0, 1, 2, 3, 4, 5, 6, 7 and 8 contain the correct values for the sorted array.

23 Now we need to work on the array starting from index 9 only. Indices 0, 1, 2, 3, 4, 5, 6, 7 and 8 contain the correct values for the sorted array. But the last one is automatically sorted now!

24 Selection Sort program analysis Need one variable ( fill ) to indicate the current index that needs to be filled with the min In each iteration need to search on some part of the array (starting from fill ) to the end of the array to find the minimum In each iteration the index of the current min needs to be stored in a variable minindex We need to swap the values of the array in indices fill and minindex (in order to swap we either need to use the function swap that we wrote before or use a new variable temp ) This operation needs to be repeated for each index of the array except the last one (that is sorted automatically)

25 Selection Sort - Implementation void selectionsort(int list[], int listsize) { int fill = 0, minindex = 0, temp = 0; for (fill = 0; fill < listsize - 1; fill++) /*last fill is listsize 2*/ { } } minindex = findminindex(list, fill, listsize); /*gives the index of the minimum element of the list in the portion starting from fill to the end of the list*/ if (minindex!= fill) /* if list[fill] is already the min, no swap needed */ { temp = list[fill]; list[fill] = list[minindex]; list[minindex] = temp; }

26 Selection Sort - Implementation /* finds the index of the minimum element in the portion of the array that starts in index beginindex */ int findminindex(int list[], int beginindex, int listsize) { int minindex = beginindex, index = 0; } for (index = beginindex + 1; index < listsize; index++) { if (list[index] < list[minindex]) { minindex = index; } } return minindex;

27 Parallel Arrays We use arrays to store data for various elements of the same type. Sometimes we want to store the data for a group of objects/entities, where each entity has multiple data and each data can be of a different type. group of students, each has a student ID (int), and a GPA (double) One option is to use parallel arrays!

28 Parallel Arrays We keep one array for each type of data for the group of objects For each object its data are stored in multiple arrays but in the same index double gpa[100]; int studentid[100]; For student the studentid for student John Doe is stored in studentid[57] and the GPA for John Doe is stored in gpa[57] If you are doing a computation that will change the index of some data in one of the arrays, you would probably need to make the same change in index happen in other arrays as well

29 Parallel Arrays - Example Read the data for 10 students from the file. This data include student ID, GPA and number of courses passed. Sort these data based on GPA and print on the console. solution: you will need to write a function that sorts based on the GPA s (use selection sort for example). Your sort function should accept other arrays as well and make the necessary index swaps.

30 Parallel Arrays - Example void parallelselectionsort(double gpas[], int studentscount, int studentids[], int numcourses[]) { int fill = 0, minindex = 0, temp = 0; for (fill = 0; fill < studentscount - 1; fill++) { } } minindex = findminindex(gpa, fill, studentscount); /*finding min is performed only based on gpa because that s what we want to sort */ if (minindex!= fill) /* swapping is done for all arrays to keep them consistent */ { } swap(ids[fill], list[minindex]; swap(numcourses[fill], numcourses[minindex]); swap(gpas[fill], gpas[minindex];

31 Notes on Arrays dynamic vs static There are two types of arrays: static and dynamic The arrays we have seen so far are static The memory for static array is decided in compile time The size of static array needs to be a constant (either a numeric value or a constant macro) This won t work: int size = 5; int array[size]; We will learn about dynamic arrays later in the course.

32 Notes on Arrays 2 Assignment operator The assignment operator (=) works on arrays only when initializing during the declaration: This will work: int a[] = {1, 2, 3}; These won t work: int a[3]; a = {1, 2, 3}; int a[3] = {1, 2, 3}; int b[3]; b=a; int a[3] = {1, 2, 3}; int b[3]; *b=*a; (this will copy only the first elememt of a into the first cell in b) If you want to make a copy of an array you should write a loop that copies each element of the source array into the corresponding cell in the destination array. (another option for copying arrays will be to use the functions that we will learn when studying dynamic memory allocation).

33 Stack Stack is a data structure that can be implemented using arrays. Stack is a list of items where we can either insert something at the end of this list (push) or we can take the last inserted element out (pop) Analogy with a number of plates on top of each other, either put one more place on top or take the one at the top. It simulates a LIFO (last in, first out) queue used in economics, business management, planning, etc. Some problems can be easily solved using a stack. E.g. problem of matching parenthesis.

34 Stack push operation Stack a push(a, 5) Stack a

35 Stack pop operation Stack a pop(a) Stack a Returns 5 to the caller

36 Stack example Do the parentheses written in this statement match: (2 * x + ( 5 x) + ((2 * pow(x, 5) / 2) + 1) * 4) Start reading from the left, everytime encountering a ( push in the stack, everytime reading a ) pop one from the stack. If at no point you tried to pop from an empty stack and at the end your stack is empty, then the parentheses match. (Assuming your stack has enough space to contain all ( s).

37 Stack push implementation #define SUCCESS 1 #define STACK_FULL -1 This shows the highest non-empty index in the stack Returns 1 if the operation was succesful; Otherwise returns -1 (when the stack is full) int stackpush(char stack[], int* top, char value) { } int status = SUCCESS; if (*top < STACK_SIZE - 1) { } else { } (*top)++; return status; stack[*top] = value; status = STACK_FULL; The value we want to enter in the stack If the stack is not full, increment top by one and put the new element in this index

38 Stack pop implementation #define STACK_EMPTY -1 This shows the highest non-empty index in the stack Returns 1 if the operation was succesful; Otherwise returns -1 (when trying to pop from an empty stack) int stackpop(char stack[], int* top, char* value) { } int status = SUCCESS; if (*top >= 0) { } else { } *value = stack[*top]; (*top)--; return status; status = STACK_EMPTY; The last value in stack that we want to return to the caller (needs to be pointer) If the stack is not empty, decrement top by one and pop the last element.

39 References J.R. Hanly & E.B. Koffman, Problem Solving and Program Design in C (8thed.), Pearson, 2016 Andy O Fallon s lecture notes for CptS121 (