See this page as a slide show
Searching and Sorting arrays
CS157 Sorting
Searching & Sorting methodologies
- An array is a list of items (ints, floats, chars, structs, 2-D)
- Commonly, we want to search for an item in the list
- Is X in the list?
- What are the other values associated with X?
- E.g., look up userid “watti”; what is his GPA?
- Usually, we like to have our lists sorted in some way
- Ascending
- Descending
- By column
- By structure element
- Sorted lists are also helpful for more efficient search algorithms
- There are many ways to sort
Linear Search
The easiest algorithm is a Linear Search:
- Sequentially walk through the list.
- Nothing clever—just look everywhere.
- If the key is found, then done.
- Imagine searching through a phone book
that was not in alphabetical order.
- A linear search is generally the slowest search.
Linear Search
#define SIZE 7
int arr[SIZE] = {1, 99, 25, 68, 92, 38, 74};
int key = 68; // searching for this
int where = -1; // Where we found it
for (int i=0; i<SIZE; i++) {
if (arr[i] == key) {
where = i;
break;
}
}
if (where == -1)
printf("Sorry, %d not found in list\n", key);
else
printf("%d found at position %d\n", key, where);
68 found at position 3
Binary Search
Binary search, on the other hand, is smarter.
It takes advantage of the fact that the data that
you’re searching is sorted already.
- Consider the data in the middle.
- If that’s what we want, we’re done.
- Otherwise, focus on either the lower half or the upper half.
Binary Search
#define SIZE 7
int arr[SIZE] = {1, 25, 38, 68, 74, 92, 99};
int key = 68; // searching for this
int low=0, mid, high=SIZE-1;
while (low <= high) {
mid = (low+high) / 2;
if (arr[mid] == key)
break;
else if (arr[mid] > key)
high = mid-1;
else
low = mid+1;
}
if (low <= high)
printf("%d found at position %d\n", key, mid);
else
printf("Sorry, %d not found in list\n", key);
68 found at position 3
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
- We will examine three specific algorithms:
- Selection Sort
- Insertion Sort
- Bubble Sort
Selection Sort
- The approach of Selection Sort:
- select a value and put it in its final place into the list
- repeat for all other values
- In more detail:
- find the smallest value in the list
- switch it with the value in the first position
- find the next smallest value in the list
- switch it with the value in the second position
- repeat until all values are in their proper places
Selection Sort
| Original: | 3 9 6 1 2 |
| Smallest unsorted is 1; swap with first unsorted, 3: | 1 9 6 3 2 |
| Smallest unsorted is 2; swap with first unsorted, 9: | 1 2 6 3 9 |
| Smallest unsorted is 3; swap with first unsorted, 6: | 1 2 3 6 9 |
| Smallest unsorted is 6; swap with first unsorted, 6: | 1 2 3 6 9 |
- The list has two parts: sorted on the left, unsorted on the right.
- Each time, the smallest remaining value is found and exchanged with
the element in the “next” position to be filled
- There are 5 elements in the array, so only 4 exchanges need occur.
After that, the last element must be the largest one.
Swapping
- The processing of the selection sort
algorithm includes the swapping of two values
- Swapping requires three assignment
statements and a temporary storage location:
temp = first;
first = second;
second = temp;
Insertion Sort
- The approach of Insertion Sort:
- pick any item and insert it into its proper place in a sorted sublist
- repeat until all items have been inserted
- In more detail:
- consider the first item to be a sorted sublist (of one item)
- insert the second item into the sorted sublist, shifting the first
item as needed to make room to insert the new addition
- insert the third item into the sorted sublist (of two items),
shifting items as necessary
- repeat until all values are inserted into their proper positions
Insertion Sort
| Original: | 3 9 6 1 2 |
| After inserting 9: | 3 9 6 1 2 |
| After inserting 6: | 3 6 9 1 2 |
| After inserting 1: | 1 3 6 9 2 |
| After inserting 2: | 1 2 3 6 9 |
Comparing Sorts
- The Selection and Insertion sort algorithms are
similar in efficiency.
- They both have outer loops that scan all elements,
and inner loops that compare the value of the outer loop with almost
all values in the list
- Approximately n² number of comparisons are made to sort a list of size n
- We therefore say that these sorts are of order n²
- Other sorts are more efficient: order n·log n
Bubble Sort
- The approach of Bubble Sort:
- Walk through the list
- If the value at the given spot is in incorrect order
with the next element, swap positions
- repeat as the list gets sorted from either smallest
to biggest or vice versa
Bubble Sort
Bubbling largest element to the end of the list:
| Original: | 3 9 6 1 2 |
| After pass 1: | 3 6 1 2 9 |
| After pass 2: | 3 1 2 6 9 |
| After pass 3: | 1 2 3 6 9 |
| After pass 4: | 1 2 3 6 9 |
It resembles selection sort, as the largest element travels to the end
of the list. However, there’s no explicit selection step.
Bubble Sort
Bubbling smallest element to the front of the list:
| Original: | 3 9 6 1 2 |
| After pass 1: | 1 3 9 6 2 |
| After pass 2: | 1 2 3 9 6 |
| After pass 3: | 1 2 3 6 9 |
| After pass 4: | 1 2 3 6 9 |
Bubble Sort
#define SIZE 7
int arr[SIZE] = {1, 99, 25, 68, 92, 38, 74};
for (int i=1; i<SIZE; i++)
for (int j=0; j<SIZE-i; j++)
if (arr[j] > arr[j+1])
swap(arr, j, j+1);
for (int i=0; i<SIZE; i++)
printf("%d\n", arr[i]);
