# ICS103 Programming in C Lecture 14: Searching and Sorting - PowerPoint PPT Presentation

1 / 13

ICS103 Programming in C Lecture 14: Searching and Sorting. Outline. Searching Linear Search Algorithm Linear Search Implementation Binary Search Algorithm Binary Search Implementation Sorting Selection Sort Algorithm Selection Sort Implementation Bubble Sort Algorithm

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

ICS103 Programming in C Lecture 14: Searching and Sorting

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

#### Presentation Transcript

ICS103 Programming in CLecture 14: Searching and Sorting

### Outline

• Searching

• Linear Search Algorithm

• Linear Search Implementation

• Binary Search Algorithm

• Binary Search Implementation

• Sorting

• Selection Sort Algorithm

• Selection Sort Implementation

• Bubble Sort Algorithm

• Bubble Sort Implementation

### Introduction to Searching

• Searching means scanning through a list of items (in an array) to find if a particular one exists.

• It usually requires the user to specify the target item – the item he wishes to locate

• If the target item is found, the item or its location (index) is returned, otherwise, an appropriate message or flag is returned.

• An important issue in processing a search request is response time. Some factors affecting response time are:

• The size of the array to search from

• The organization of data in the array; random or ordered

• The searching method or algorithm; linear or binary

• In this lecture, we study two searching methods; Linear Search and Binary Search.

### Linear Search Algorithm

• This involves searching through the array sequentially until the target item is found or the array is exhausted.

• If the target is found, its location is returned, otherwise a flag such as –1 is returned. Here is the algorithm for Linear Search

• Assume that the target has not been found

• Repeat while the target is not found and there are more array elements

• If the current element matches the target

• Set a flag to indicate that the target has been found

else

• Advance to the next array element

• If the target was found

• Return the target index as the search result

else

• Return -1 as the search result

### Linear Search Implementation

/* Searches for target in an array using Linear search;

int linear_search(double a[], double target,

int size)

{

int i, found = 0, where;

i = 0;

while (!found && i < size) {

if (a[i] == target)

found = 1;

else

++i;

}

if (found)

where = i;

else

where = -1;

return where;

}

#include <stdio.h>

#define SIZE 8

int linear_search(double a[], double target, int size);

int main(void) {

double x[SIZE], target;

int index;

printf("Enter Element to search for: ");

scanf("%lf", &target);

index = linear_search(x, target, SIZE);

if (index != -1)

printf("Target was found at index %d\n", index);

else

system("pause");

return 0;

}

void read_array (double a[], int size) {

int i;

printf("Enter %d integer numbers separated by blanks\n> ", size);

for (i = 0; i < size; ++i)

scanf("%lf", &a[i]);

}

### Binary Search Algorithm

• For a list of n elements, the linear search takes an average of n/2 comparisons to find an item, with the best case being 1 comparison and the worst case being n comparisons.

• However, if the list is ordered, it is a waste of time to look for an item using linear search - it would be like looking for a word in a dictionary sequentially.

• In this case we apply a more efficient method called binary search. Binary search works by comparing the target with the item at the middle of the list. This leads to one of three results:

• If the middle item is the target – we are done.

•  If the middle item is less than target, we apply the algorithm to the upper half of the list.

• If the middle item is bigger than the target, we apply the algorithm to the lower half of the list.

• This process is repeated until the item is found or the list is exhausted

### Binary Search Implementation

/* Recursive implementation of binary search */

int binary_search (double x[], int low, int high, double target) {

int middle;

return -1;

middle = (low + high)/2;

if (x[middle] == target)

return (middle); /*base case2:target

found*/

else if (x[middle] < target)

return binary_search(x,

middle+1,high,target);

else

return binary_search(x, low,

middle-1,target);

}

#include <stdio.h>

#define SIZE 8

int binary_search (double x[], int low, int high, double target);

int main(void) {

double x[SIZE], target;

int index;

printf("Enter Element to search for: ");

scanf("%lf", &target);

index = binary_search(x, 0, SIZE-1, target);

if (index != -1)

printf("Target was found at index %d\n", index);

else

system("pause");

return 0;

}

void read_array (double a[], int size) {

int i;

printf("Enter %d integer numbers separated by blanks\n> ", size);

for (i = 0; i < size; ++i)

scanf("%lf", &a[i]);

}

### Introduction to Sorting

• Sorting is the re-arrangement of a collection of data according to some key-field.

• It is a common activity in data management. Even when a list is maintained in a certain order, there is often a need to re-arrange the list in a different order.

• Because it takes so much processing time, sorting is a serious topic in computer science, and many different sorting algorithms have been designed.

• We shall consider two of such sorting methods; Selection sort and Bubble Sort.

### Selection Sort Algorithm

• Selection sort involved scanning through the list to find (or select) the smallest element and swap it with the first element.

• The rest of the list is then search for the next smallest and swap it with the second element.

• This process is repeated until the rest of the list reduces to one element, by which time the list is sorted.

• The following table shows how selection sort works.

### Selection Sort Implementation

int find_min(double a[], int start, int size) {

int i, min_index = start;

for (i=start+1; i<size; i++)

if (a[i] < a[min_index])

min_index = i;

return min_index;

}

void swap(double *a, double *b) {

double temp = *a;

*a = *b;

*b = temp;

}

void read_array (double a[], int size) {

int i;

printf("Enter %d integer numbers separated by blanks\n> ", size);

for (i = 0; i < size; ++i)

scanf("%lf", &a[i]);

}

void print_array(double a[], int size) {

int i;

for (i = 0; i < size; ++i)

printf("%.1f ", a[i]);

printf("\n");

}

#include <stdio.h>

#define SIZE 10

void selection_sort(double a[], int size);

void print_array(double a[], int size);

int find_min(double a[], int start, int size);

void swap(double *a, double *b);

int main(void) {

double x[SIZE];

int i;

printf("Before Sorting: ");

print_array(x, SIZE);

selection_sort(x, SIZE);

printf("After Sorting: ");

print_array(x, SIZE);

system("pause");

return 0;

}

void selection_sort(double a[], int size) {

int i, min_pos;

for (i = 0; i<=size-2; i++) {

min_pos = find_min(a, i, size);

swap(&a[i], &a[min_pos]);

}

}

### Bubble Sort Algorithm

• The idea of Bubble (or exchange) sort is to scan through the list and swap each pair of adjacent elements that are in the wrong order.

• The process is repeated each time from index zero to one less than the previous limit until either the list is exhausted or until a pass that involve no swap is encountered.

• At the end of first pass, the largest element will move (or bubble up) to the end of the list.

• At the end of the second swap, the second largest will move to its right place, etc.

• The following table shows a trace of how bubble sort works.

### Bubble Sort Implementation

void bubble_sort(double a[], int size) {

int i, pass = 1, swap_occurs;

do{

swap_occurs = 0;

for(i = 1; i <= size - pass; i++) {

if (a[i - 1] > a[i]) {

swap(&a[i-1], &a[i]);

swap_occurs = 1;

}

}

pass++;

} while (swap_occurs && pass <= size-1);

}

void read_array (double a[], int size) {

int i;

printf("Enter %d integer numbers separated by blanks\n> ", size);

for (i = 0; i < size; ++i)

scanf("%lf", &a[i]);

}

void print_array(double a[], int size) {

int i;

for (i = 0; i < size; ++i)

printf("%.1f ", a[i]);

printf("\n");

}

#include <stdio.h>

#define SIZE 10

void bubble_sort(double a[], int size);

void print_array(double a[], int size);

void swap(double *a, double *b);

int main(void) {

double x[SIZE];

int i;

printf("Before Sorting: ");

print_array(x, SIZE);

bubble_sort(x, SIZE);

printf("After Sorting: ");

print_array(x, SIZE);

system("pause");

return 0;

}

void swap(double *a, double *b) {

double temp = *a;

*a = *b;

*b = temp;

}