slide1
Download
Skip this Video
Download Presentation
ICS103 Programming in C Lecture 14: Searching and Sorting

Loading in 2 Seconds...

play fullscreen
1 / 13

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


  • 66 Views
  • Uploaded on

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

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

PowerPoint Slideshow about ' ICS103 Programming in C Lecture 14: Searching and Sorting' - dylan-franks


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

}

ad