Arrays

1. Arrays Searching & Sorting Briana B. Morrison CSE 1302C Spring 2010

2. Topics Declaring arrays Instantiating arrays Operations on arrays Searching Sorting

3. Arrays and Their Properties Hold several values of the same type (homogeneous) Based on a slot number (the index number) Instant access Linear (one after the other) Static – once their size is set, it’s set…

4. What arrays look like Things to notice There are 7 slots, with index numbers 0 – 6 The name of the array is myArray Easy to be off by one 1 2 3 4 5 6 0 myArray

5. Creating Arrays <data type>[] <name> = new <data type> [<size>]; new brings complex variables to life in C# Notice that we can create an array of any data type, just by changing the data type!

6. Examples An array of shorts: short[] someArray = new short[50]; An array of floats: float[] myArray = new float[25]; An array of booleans: bool[] list = new bool[65]; An array of chars: char[] characters = new char[255];

7. Initializing Arrays with Values <data type>[] <name> = new <data type> [<size>] {VALUES}; Or <data type>[] <name> = {VALUES};

8. Modifying an Array You must specify which slot you are putting information in Example: int[] myArray = new int[50]; myArray[3] = 12; This won’t work: int[] myArray = new int[50]; myArray = 12; Data type on the left of = is an array Data type on right of = is an int 0 1 2 3 4 49 … 12

9. Accessing Information Copying information out of a particular slot Example: int clientAge; clientAge = myArray[4]; This copies information from the fifth slot (slot four) into the variable clientAge

10. Initializing Arrays(large arrays) For most arrays, you will use a loop to initialize Problem: create an array of 50 bytes and fill each slot with the number 42 Solution: byte[] myList = new byte[50]; for (int counter=0; counter < 50; counter++) { myList[counter] = 42; }

11. Operations on Arrays

12. Searching Arrays • Sequential • What if array is sorted • Binary

13. Searching • Searching is the process of finding a target element within a group of items called the search pool • The target may or may not be in the search pool • We want to perform the search efficiently, minimizing the number of comparisons • Let's look at two classic searching approaches: linear search and binary search

14. Sequential Search • A Sequential Search can be used to determine if a specific value (the search key) is in an array. • Approach is to start with the first element and compare each element to the search key: • If found, return the index of the element that contains the search key. • If not found, return -1. • Because -1 is not a valid index, this is a good return value to indicate that the search key was not found in the array.

15. Code to Perform a Sequential Search public int findWinners( int key ) { for ( int i = 0; i < winners.length; i++ ) { if ( winners[i] == key ) return i; } return -1; }

16. Sequential Search of a Sorted Array • When the array is sorted, we can implement a more efficient algorithm for a sequential search. • If the search key is not in the array, we can detect that condition when we find a value that is higher than the search key. • All elements past that position will be greater than the value of that element, and therefore, greater than the search key.

17. Sample Code public intsearchSortedArray( int key ) { for ( inti = 0; i < array.length &&array[i] <= key; i++ ) { if ( array[i] == key ) return i; } return –1; // end of array reached without // finding keyor // an element larger than // the key was found }

18. Binary Search • A Binary Search is like the "Guess a Number" game. • To guess a number between 1 and 100, we start with 50 (halfway between the beginning number and the end number). • If we learn that the number is greater than 50, we immediately know the number is not 1 - 49. • If we learn that the number is less than 50, we immediately know the number is not 51 - 100. • We keep guessing the number that is in the middle of the remaining numbers (eliminating half the remaining numbers) until we find the number.

19. Binary Search • The "Guess a Number" approach works because 1 - 100 are a "sorted" set of numbers. • To use a Binary Search, the array must be sorted. • Our Binary Search will attempt to find a search key in a sorted array. • If the search key is found, we return the index of the element with that value. • If the search key is not found,we return -1.

20. The Binary Search Algorithm • We begin by comparing the middle element of the array and the searchkey. • If they are equal, wefound the searchkey and return the index of the middle element. • If the middle element's value isgreaterthan the searchkey, then the searchkeycannotbefound in elementswithhigherarray indexes. So, we continue oursearch in the lefthalf of the array. • If the middle element's value islessthan the searchkey, then the searchkeycannotbefound in elementswithlowerarray indexes. So, we continue oursearch in the right half of the array.

21. The Binary Search Algorithm (con't) • As we keep searching, the subarray we search keeps shrinking in size. In fact, the size of the subarray we search is cut in half at every iteration.   • If the search key is not in the array, the subarray we search will eventually become empty. At that point, we know that we will not find our search key in the array, and we return –1.  

22. Example of a Binary Search • For example, we will search for the value 7 in this sorted array: • To begin, we find the index of the center element, which is 8, and we compare our search key (7) with the value 45.

23. Binary Search Example (con't) • Because 7 is less than 35, we eliminate all array elements higher than our current middle element and consider elements 0 through 7 the new subarray to search. • The index of the center element is now 3, so we compare 7 to the value 8.

24. Binary Search Example (con't) • Because 7 is less than 8, we eliminate all array elements higher than our current middle element (3) and make elements 0 through 2 the new subarray to search. • The index of the center element is now 1, so we compare 7 to the value 6.

25. Binary Search: Finding the search key • Because 7 is greater than 6, we eliminate array elements lower than our current middle element (1) and make element 2 the new subarray to search. • The value of element 2 matches the search key, so our search is successful and we return the index 2.

26. Binary Search Example 2 • This time, we search for a value not found in the array, 34. Again, we start with the entire array and find the index of the middle element, which is 8. • We compare our search key (34) with the value 45.

27. Binary Search Example 2 (con't) • Because 34 is less than 45, we eliminate array elements higher than our current middle element and consider elements 0 through 7 the new subarray to search. • The index of the center element is now 3, so we compare 34 to the value 8.

28. Binary Search Example 2 (con't) • Because 34 is greater than 8, we eliminate array elements lower than our current middle element and consider elements 4 through 7 the new subarray to search. • The index of the center element is now 5, so we compare 34 to the value 15.

29. Binary Search Example 2 (con't) • Again, we eliminate array elements lower than our current middle element and make elements 6 and 7 the new subarray to search. • The index of the center element is now 6, so we compare 34 to the value 22.

30. Binary Search 2: search key is not found • Next, we eliminate array elements lower than our current middle element and make element 7 the new subarray to search. • We compare 34 to the value 36, and attempt to eliminate the higher subarray, which leaves an empty subarray. • We have determined that 32 is not in the array. We return -1 to indicate an unsuccessful search.

31. Binary Search Code public intbinarySearch( int [] array, int key ) { int start = 0, end = array.length - 1; while ( end >= start ) { int middle = ( start + end ) / 2; if ( array[middle] == key ) return middle; // key found else if ( array[middle] > key ) end = middle - 1; // search left else start = middle + 1; // search right } return -1; // key not found }

32. Sorting • Sorting is the process of arranging a list of items in a particular order • The sorting process is based on specific value(s) • sorting a list of test scores in ascending numeric order • sorting a list of people alphabetically by last name • There are many algorithms, which vary in efficiency, for sorting a list of items

33. Sorting • When an array's elements are in random order, our Sequential Searchmethod needs to look at every element in the array before discovering that the search key is not in the array. This is inefficient; the larger the array, the more inefficient a Sequential Searchbecomes. • We could simplify the search by arranging the elements in numeric order, which is called sorting the array. Once the array is sorted, we can use various search algorithms to speed up a search, including binary search.

34. Sorting • We will review three different sorts: • Selection Sort • Bubble Sort • Insertion Sort

35. Selection Sort • In a Selection Sort, we select the smallest element in the array and place it at the beginning of the array. Then we select the next-smallest element and put it in the second position in the array, and so on. • To do this, we consider the unsorted portion of the array as a subarray. Werepeatedly select the smallest value in the currentsubarray and move it to the beginning of the subarray, thenconsider a new subarray by eliminating the elementsthat are in theirsorted locations. We continue until the subarray has only one element. Atthat time, the arrayissorted.

36. The Selection Sort Algorithm To sort an arraywithnelements in ascendingorder: 1.  Consider the nelements as a subarraywithm = nelements. 2.  Find the index of the smallest value in thissubarray. 3.  Swap the values of the elementwith the smallest value and the element in the first position in the subarray. 4.  Consider a new subarray of m = m - 1 elements by eliminating the first element in the previoussubarray 5.  Repeatsteps 2 through 4 untilm = 1.

37. Selection Sort • Algorithm: for index = 0 to length-2 do for index2 = index to length -1 do find minimum value swap minimum value with list[index]

38. Swapping Values • To swap two values, we define a temporary variable to hold the value of one of the elements, so that we don't lose that value during the swap. To swap elements a and b: • define a temporary variable, temp. • assign element a to temp. • assign element b to element a. • assign temp to element b.

39. Swapping Example • This code will swap elements 3 and 6 in an int array named array: int temp; // step 1 temp = array[3]; // step 2 array[3] = array[6]; // step 3 array[6] = temp; // step 4

40. The picture shows an array of six integers that we want to sort from smallest to largest. Sorting Integers [0][1] [2] [3] [4] [5]

41. Start by finding the smallest entry. Selection Sort Algorithm [0][1] [2] [3] [4] [5]

42. Start by finding the smallest entry. Swap the smallest entry with the first entry. Selection Sort Algorithm [0][1] [2] [3] [4] [5]

43. Selection Sort Algorithm • Start by finding the smallest entry. • Swap the smallest • entry with the • first entry. [0][1] [2] [3] [4] [5]

44. Part of the array is now sorted. Selection Sort Algorithm Sorted side Unsorted side [0][1] [2] [3] [4] [5]

45. Find the smallest element in the unsorted side. Selection Sort Algorithm Sorted side Unsorted side [0][1] [2] [3] [4] [5]

46. Find the smallest element in the unsorted side. Swap with the front of the unsorted side. Selection Sort Algorithm Unsorted side Sorted side [0][1] [2] [3] [4] [5]

47. We have increased the size of the sorted side by one element. Selection Sort Algorithm Sorted side Unsorted side [0][1] [2] [3] [4] [5]

48. The process continues... Selection Sort Algorithm Sorted side Unsorted side Smallest from unsorted [0][1] [2] [3] [4] [5]

49. The process continues ... Selection Sort Algorithm Sorted side Unsorted side Swap with front [0][1] [2] [3] [4] [5]

50. The process continues ... Selection Sort Algorithm Sorted side is bigger Sorted side Unsorted side [0][1] [2] [3] [4] [5]