ICS103 Programming in C Lecture 14: Searching and Sorting

Download Presentation

ICS103 Programming in C Lecture 14: Searching and Sorting

Loading in 2 Seconds...

- 53 Views
- Uploaded on
- Presentation posted in: General

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 - - - - - - - - - - - - - - - - - - - - - - - - - -

ICS103 Programming in CLecture 14: Searching and Sorting

- 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

- 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.

- 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
- Start with initial array element
- 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

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

- If the current element matches the target
- If the target was found
- Return the target index as the search result
else

- Return -1 as the search result

- Return the target index as the search result

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

* Returns index of target or -1 if not found */

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);

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

int main(void) {

double x[SIZE], target;

int index;

read_array(x, SIZE);

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

printf("Sorry, target item was not found");

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]);

}

- 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

/* Recursive implementation of binary search */

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

int middle;

if (low > high) /*base case1:target not found*/

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);

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

int main(void) {

double x[SIZE], target;

int index;

read_array(x, SIZE);

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

printf("Sorry, target item was not found");

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]);

}

- 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 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.

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 read_array(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;

read_array(x, SIZE);

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]);

}

}

- 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.

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 read_array(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;

read_array(x, SIZE);

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;

}