ICS103 Programming in C
This presentation is the property of its rightful owner.
Sponsored Links
1 / 13

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


  • 46 Views
  • Uploaded on
  • Presentation posted in: General

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

Download Presentation

ICS103 Programming in C Lecture 14: Searching and Sorting

An Image/Link below is provided (as is) to download presentation

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 c lecture 14 searching and sorting

ICS103 Programming in CLecture 14: Searching and Sorting


Outline

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

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

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

    • 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

    • If the target was found

      • Return the target index as the search result

        else

      • Return -1 as the search result


Linear search implementation

Linear Search Implementation

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

}


Binary search algorithm

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 algorithm1

Binary Search Algorithm ….


Binary search implementation

Binary Search Implementation

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

}


Introduction to sorting

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

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

}

}


Bubble sort algorithm

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

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

}


  • Login