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
• E.g., Binary search
• 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]);
```

User: Guest

Check: HTML CSS
Edit History Source

Modified: 2018-04-16T11:33

Apply to CSU | Contact CSU | Disclaimer | Equal Opportunity
Colorado State University, Fort Collins, CO 80523 USA
© 2018 Colorado State University