Presentation on binary search, quick sort, merge sort and problems
sort search in C
-
Upload
faizankhan260690 -
Category
Education
-
view
2.748 -
download
0
description
Transcript of sort search in C
![Page 1: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/1.jpg)
Spring Semester 2007 Programming and Data Structure 1
Searching Elements in an Array:Linear and Binary Search
![Page 2: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/2.jpg)
Spring Semester 2007 Programming and Data Structure 2
Searching
• Check if a given element (called key) occurs in the array.– Example: array of student records; rollno can be
the key.• Two methods to be discussed:
– If the array elements are unsorted.• Linear search
– If the array elements are sorted.• Binary search
![Page 3: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/3.jpg)
Spring Semester 2007 Programming and Data Structure 3
Linear Search
![Page 4: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/4.jpg)
Spring Semester 2007 Programming and Data Structure 4
Basic Concept
• Basic idea:– Start at the beginning of the array.– Inspect elements one by one to see if it matches the key.
• Time complexity:– A measure of how long an algorithm takes to run.– If there are n elements in the array:
• Best case:match found in first element (1 search operation)
• Worst case: no match found, or match found in the last element (n search operations)
• Average case:(n + 1) / 2 search operations
![Page 5: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/5.jpg)
Spring Semester 2007 Programming and Data Structure 5
Contd./* The function returns the array index where the
match is found. It returns -1 if there is nomatch. */
int linear_search (int a[], int size, int key){
int pos = 0;while ((pos < size) && (a[pos] != key))
pos++;if (pos < size)
return pos; /* Return the position of match */return -1; /* No match found */
}
![Page 6: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/6.jpg)
Spring Semester 2007 Programming and Data Structure 6
Contd.
int x[]= {12, -3, 78, 67, 6, 50, 19, 10};
• Trace the following calls :search (x, 8, 6) ;search (x, 8, 5) ;
Returns 4
Returns -1
![Page 7: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/7.jpg)
Spring Semester 2007 Programming and Data Structure 7
Binary Search
![Page 8: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/8.jpg)
Spring Semester 2007 Programming and Data Structure 8
Basic Concept
• Binary search works if the array is sorted.– Look for the target in the middle.– If you don’t find it, you can ignore half of the
array, and repeat the process with the other half.
• In every step, we reduce the number of elements to search in by half.
![Page 9: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/9.jpg)
Spring Semester 2007 Programming and Data Structure 9
The Basic Strategy
• What we want?– Find split between values larger and smaller than key:
– Situation while searching:• Initially L and R contains the indices of first and last elements.
– Look at the element at index [(L+R)/2]. • Move L or R to the middle depending on the outcome of test.
0<=key >keyx:
n-1
L R
![Page 10: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/10.jpg)
Spring Semester 2007 Programming and Data Structure 10
Contd./* If key appears in x[0..size-1], return its location, pos
such that x[pos]==key. If not found, return -1 */
int bin_search (int x[], int size, int key){
int L, R, mid;_________________;while ( ____________ ){
__________________;}_________________ ;
}
![Page 11: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/11.jpg)
Spring Semester 2007 Programming and Data Structure 11
The basic search iteration
int bin_search (int x[], int size, int key){
int L, R, mid;_________________;while ( ____________ ){
mid = (L + R) / 2;if (x[mid] <= key)
L = mid;else R = mid;
}_________________ ;
}
![Page 12: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/12.jpg)
Spring Semester 2007 Programming and Data Structure 12
Loop termination
int bin_search (int x[], int size, int key){
int L, R, mid;_________________;while ( L+1 != R ){
mid = (L + R) / 2;if (x[mid] <= key)
L = mid;else R = mid;
}_________________ ;
}
![Page 13: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/13.jpg)
Spring Semester 2007 Programming and Data Structure 13
Return result
int bin_search (int x[], int size, int key){
int L, R, mid;_________________;while ( L+1 != R ){
mid = (L + R) / 2;if (x[mid] <= key)
L = mid;else R = mid;
}if (L >= 0 && x[L] == key) return L;else return -1;
}
![Page 14: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/14.jpg)
Spring Semester 2007 Programming and Data Structure 14
Initialization
int bin_search (int x[], int size, int key){
int L, R, mid;L = -1; R = size;while ( L+1 != R ){
mid = (L + R) / 2;if (x[mid] <= key)
L = mid;else R = mid;
}if (L >= 0 && x[L] == key) return L;else return -1;
}
![Page 15: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/15.jpg)
Spring Semester 2007 Programming and Data Structure 15
Binary Search Examples
-17 -5 3 6 12 21 45 63 50
Trace :
binsearch (x, 9, 3);
binsearch (x, 9, 145);
binsearch (x, 9, 45);
Sorted array
L= –1; R= 9; x[4]=12;L= –1; R=4; x[1]= –5;L= 1; R=4; x[2]=3;L=2; R=4; x[3]=6;L=2; R=3; return L;
We may modify the algorithm by checking equality with x[mid].
![Page 16: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/16.jpg)
Spring Semester 2007 Programming and Data Structure 16
Is it worth the trouble ?
• Suppose that the array x has 1000 elements.• Ordinary search– If key is a member of x, it would require 500 comparisons
on the average.• Binary search
– after 1st compare, left with 500 elements.– after 2nd compare, left with 250 elements.– After at most 10 steps, you are done.
![Page 17: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/17.jpg)
Spring Semester 2007 Programming and Data Structure 17
Time Complexity
• If there are n elements in the array.– Number of searches required:
log2n• For n = 64 (say).
– Initially, list size = 64.– After first compare, list size = 32.– After second compare, list size = 16.– After third compare, list size = 8.– …….– After sixth compare, list size = 1.
log264 = 6log21024 = 10
2k= n, where k is the number of steps.
![Page 18: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/18.jpg)
Spring Semester 2007 Programming and Data Structure 18
Sorting
![Page 19: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/19.jpg)
Spring Semester 2007 Programming and Data Structure 19
The Basic Problem
• Given an array x[0], x[1], ... , x[size-1]
reorder entries so thatx[0] <= x[1] <= . . . <= x[size-1]
• List is in non-decreasing order.
• We can also sort a list of elements in non-increasing order.
![Page 20: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/20.jpg)
Spring Semester 2007 Programming and Data Structure 20
Example
• Original list:10, 30, 20, 80, 70, 10, 60, 40, 70
• Sorted in non-decreasing order:10, 10, 20, 30, 40, 60, 70, 70, 80
• Sorted in non-increasing order:80, 70, 70, 60, 40, 30, 20, 10, 10
![Page 21: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/21.jpg)
Spring Semester 2007 Programming and Data Structure 21
Unsorted list
Sorting Problem
• What we want ?– Data sorted in order
x:0 size-1
Sorted list
![Page 22: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/22.jpg)
Spring Semester 2007 Programming and Data Structure 22
Selection Sort
![Page 23: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/23.jpg)
Spring Semester 2007 Programming and Data Structure 23
How it works?
• General situation :
remainder, unsortedsmallest elements, sorted
0 size-1k
• Step :• Find smallest element, mval, in x[k..size-1]• Swap smallest element with x[k], then increase k.
x:
0 k size-1mval
swap
![Page 24: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/24.jpg)
Spring Semester 2007 Programming and Data Structure 24
Subproblem
/* Yield index of smallest element in x[k..size-1];*/
int min_loc (int x[], int k, int size) {
int j, pos;
pos = k; for (j=k+1; j<size; j++)
if (x[j] < x[pos])pos = j;
return pos;}
![Page 25: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/25.jpg)
Spring Semester 2007 Programming and Data Structure 25
The main sorting function
/* Sort x[0..size-1] in non-decreasing order */
int sel_sort (int x[], int size){ int k, m;
for (k=0; k<size-1; k++){
m = min_loc (x, k, size);temp = a[k];
a[k] = a[m]; SWAPa[m] = temp;
}}
![Page 26: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/26.jpg)
Spring Semester 2007 Programming and Data Structure 26
int main(){
int x[ ]={-45,89,-65,87,0,3,-23,19,56,21,76,-50};int i;for(i=0;i<12;i++)
printf("%d ",x[i]);printf("\n");sel_sort(x,12);for(i=0;i<12;i++)
printf("%d ",x[i]);printf("\n");
}
-45 89 -65 87 0 3 -23 19 56 21 76 -50 -65 -50 -45 -23 0 3 19 21 56 76 87 89
![Page 27: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/27.jpg)
Spring Semester 2007 Programming and Data Structure 27
Example
-17 12 -5 6 14221 3 45x:
3 12 -5 6 14221 -17 45x:
-17 -5 12 6 14221 3 45x:
-17 -5 3 6 14221 12 45x:
-17 -5 3 6 142 21 12 45x:
-17 -5 3 6 12 2114245x:
-17 -5 3 6 12 21 45142x:
-17 -5 3 6 12 2114245x:
![Page 28: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/28.jpg)
Spring Semester 2007 Programming and Data Structure 28
Analysis
• How many steps are needed to sort nitems ? – Total number of steps proportional to n2.
– No. of comparisons?
– Worst Case? Best Case? Average Case?
(n-1)+(n-2)+……+1= n(n-1)/2
Of the order of n2
![Page 29: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/29.jpg)
Spring Semester 2007 Programming and Data Structure 29
Insertion Sort
![Page 30: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/30.jpg)
Spring Semester 2007 Programming and Data Structure 30
0 size-1
i
How it works?
• General situation :
remainder, unsortedsorted
0 size-1ix:
i
j
Compare and shift till x[i] is larger.
![Page 31: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/31.jpg)
Spring Semester 2007 Programming and Data Structure 31
void insert_sort (int list[], int size){
int i,j,item;
for (i=1; i<size; i++){item = list[i] ;for (j=i-1; (j>=0)&& (list[j] > i); j--)
list[j+1] = list[j];list[j+1] = item ;
}}
Insertion Sort
![Page 32: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/32.jpg)
Spring Semester 2007 Programming and Data Structure 32
int main(){
int x[ ]={-45,89,-65,87,0,3,-23,19,56,21,76,-50};int i;for(i=0;i<12;i++)
printf("%d ",x[i]);printf("\n");insert_sort(x,12);for(i=0;i<12;i++)
printf("%d ",x[i]);printf("\n");
}
-45 89 -65 87 0 3 -23 19 56 21 76 -50 -65 -50 -45 -23 0 3 19 21 56 76 87 89
![Page 33: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/33.jpg)
Spring Semester 2007 Programming and Data Structure 33
Time Complexity
• Number of comparisons and shifting:
– Worst case? 1 + 2 + 3 + …… + (n-1) = n(n-1)/2
– Best case?1 + 1 + …… to (n-1) terms = (n-1)
![Page 34: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/34.jpg)
Spring Semester 2007 Programming and Data Structure 34
Bubble Sort
![Page 35: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/35.jpg)
Spring Semester 2007 Programming and Data Structure 35
How it works?
• The sorting process proceeds in several passes.– In every pass we go on comparing neighboring
pairs, and swap them if out of order.– In every pass, the largest of the elements under
considering will bubble to the top (i.e., the right).10 5 17 11 -3 125 10 17 11 -3 125 10 17 11 -3 125 10 11 17 -3 125 10 11 -3 17 125 10 11 -3 12 17
Largest
![Page 36: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/36.jpg)
Spring Semester 2007 Programming and Data Structure 36
• How the passes proceed?– In pass 1, we consider index 0 to n-1.– In pass 2, we consider index 0 to n-2.– In pass 3, we consider index 0 to n-3.– ……– ……– In pass n-1, we consider index 0 to 1.
![Page 37: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/37.jpg)
Spring Semester 2007 Programming and Data Structure 37
Bubble Sort
void swap(int *x, int *y){
int tmp = *x;*x = *y; *y = tmp;
}
void bubble_sort(int x[], int n)
{int i,j;
for (i=n-1; i>0; i--)for (j=0; j<i; j++)
if (x[j] > x[j+1]) swap(&x[j],&x[j+1]);
}
![Page 38: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/38.jpg)
Spring Semester 2007 Programming and Data Structure 38
int main(){
int x[ ]={-45,89,-65,87,0,3,-23,19,56,21,76,-50};int i;for(i=0;i<12;i++)
printf("%d ",x[i]);printf("\n");bubble_sort(x,12);for(i=0;i<12;i++)
printf("%d ",x[i]);printf("\n");
}
-45 89 -65 87 0 3 -23 19 56 21 76 -50 -65 -50 -45 -23 0 3 19 21 56 76 87 89
![Page 39: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/39.jpg)
Spring Semester 2007 Programming and Data Structure 39
Time Complexity
• Number of comparisons :
– Worst case?
1 + 2 + 3 + …… + (n-1) = n(n-1)/2
– Best case? Same
![Page 40: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/40.jpg)
Spring Semester 2007 Programming and Data Structure 40
• How do you make best case with (n-1) comparisons only?– By maintaining a variable flag, to check if
there has been any swaps in a given pass.– If not, the array is already sorted.
![Page 41: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/41.jpg)
Spring Semester 2007 Programming and Data Structure 41
void bubble_sort(int x[], int n)
{int i,j;int flag = 0;
for (i=n-1; i>0; i--){
for (j=0; j<i; j++)if (x[j] > x[j+1]){
swap(&x[j],&x[j+1]);flag = 1;
}if (flag == 0) return;
}
![Page 42: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/42.jpg)
Spring Semester 2007 Programming and Data Structure 42
Some Efficient Sorting Algorithms
![Page 43: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/43.jpg)
Spring Semester 2007 Programming and Data Structure 43
• Two of the most popular sorting algorithms are based on divide-and-conquer approach.– Quick sort– Merge sort
• Basic concept (divide-and-conquer method):
sort (list){
if the list has length greater than 1{
Partition the list into lowlist and highlist;sort (lowlist);sort (highlist);combine (lowlist, highlist);
}}
![Page 44: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/44.jpg)
Spring Semester 2007 Programming and Data Structure 44
Quick Sort
![Page 45: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/45.jpg)
Spring Semester 2007 Programming and Data Structure 45
How it works?
• At every step, we select a pivot element in the list (usually the first element).– We put the pivot element in the final position
of the sorted list.– All the elements less than or equal to the pivot
element are to the left.– All the elements greater than the pivot element
are to the right.
![Page 46: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/46.jpg)
Spring Semester 2007 Programming and Data Structure 46
Partitioning
0 size-1
x:
pivot
Values smaller Values greater
Perform partitioning
Perform partitioning
![Page 47: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/47.jpg)
Spring Semester 2007 Programming and Data Structure 47
Example
26 33 35 29 19 12 2222 35 29 19 12 3322 12 29 19 35 3322 12 19 29 35 33
19 22 12 26 29 35 33
Recursively carry out the partitioning
The partitioning process
![Page 48: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/48.jpg)
Spring Semester 2007 Programming and Data Structure 48
void print (int x[], int low, int high){
int i;
for(i=low; i<=high; i++)printf(" %d", x[i]);
printf("\n");}
void swap (int *a, int *b){
int tmp=*a;*a=*b; *b=tmp;
}
![Page 49: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/49.jpg)
Spring Semester 2007 Programming and Data Structure 49
void partition (int x[], int low, int high){
int i = low+1, j = high;int pivot = x[low];if (low >= high) return;while (i<j) {
while ((x[i]<pivot) && (i<high)) i++;while ((x[j]>=pivot) && (j>low)) j--;if (i<j) swap (&x[i], &x[j]);
}if (j==high) {
swap (&x[j], &x[low]);partition (x, low, high-1);
} else
if (i==low+1)partition (x, low+1, high);
else {swap (&x[j], &x[low]);partition (x, low, j-1);partition (x, j+1, high);
}}
![Page 50: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/50.jpg)
Spring Semester 2007 Programming and Data Structure 50
int main (int argc, char *argv[]){
int *x;int i=0;int num;
num = argc - 1;x = (int *) malloc(num * sizeof(int));
for (i=0; i<num; i++)x[i] = atoi(argv[i+1]);
partition(x,0,num-1);
printf(“Sorted list: ");print (x,0,num-1);
}
![Page 51: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/51.jpg)
Spring Semester 2007 Programming and Data Structure 51
0
Trace of Partitioning
./a.out 45 -56 78 90 -3 -6 123 0 -3 45 69 68
Sorted list: -56 -6 -3 -3 0 45 45 68 69 78 90 123
45 -56 78 90 -3 -6 123 0 -3 45 69 68
-6 -56 -3 0 -3 45 123 90 78 45 69 68
-3 0 -3-6-56
0 -3-3
-3
68 90 78 45 69 123
78 90 696845
7869 90
![Page 52: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/52.jpg)
Spring Semester 2007 Programming and Data Structure 52
Time Complexity
• Worst case:n2 ==> list is already sorted
• Average case:n log2n
• Statistically, quick sort has been found to be one of the fastest algorithms.
![Page 53: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/53.jpg)
Spring Semester 2007 Programming and Data Structure 53
• Corollary of quick sort:– Given a list of numbers stored in an array,
determine how many numbers are smaller than a given number p?
– Given a list of integers (negative and non-negative), reorder the list so that all negative numbers precede the non-negative ones.
![Page 54: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/54.jpg)
Spring Semester 2007 Programming and Data Structure 54
Merge Sort
![Page 55: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/55.jpg)
Spring Semester 2007 Programming and Data Structure 55
Merge Sort
Input Array
Part-I Part-II
Part-I Part-IIPart-I Part-II
SplitMergeSorted Arrays
![Page 56: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/56.jpg)
Spring Semester 2007 Programming and Data Structure 56
Merging two sorted arrays
0
Sorted Array Sorted Array
0m n
a b
Merged sorted array
0 m+n-1
c
pa pb
Move and copy elements pointed by pa if its value is smallerthan the element pointed by pb in (m+n-1) operations; otherwise,
copy elements pointed by pb .
![Page 57: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/57.jpg)
Spring Semester 2007 Programming and Data Structure 57
Example
• Initial array A contains 14 elements:– 66, 33, 40, 22, 55, 88, 60, 11, 80, 20, 50, 44, 77, 30
• Pass 1 :: Merge each pair of elements– (33, 66) (22, 40) (55, 88) (11, 60) (20, 80) (44, 50) (30, 70)
• Pass 2 :: Merge each pair of pairs– (22, 33, 40, 66) (11, 55, 60, 88) (20, 44, 50, 80) (30, 77)
• Pass 3 :: Merge each pair of sorted quadruplets– (11, 22, 33, 40, 55, 60, 66, 88) (20, 30, 44, 50, 77, 80)
• Pass 4 :: Merge the two sorted subarrays to get the final list– (11, 20, 22, 30, 33, 40, 44, 50, 55, 60, 66, 77, 80, 88)
![Page 58: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/58.jpg)
Spring Semester 2007 Programming and Data Structure 58
void merge_sort (int *a, int n){
int i, j, k, m;int *b, *c;
if (n>1) {k = n/2; m = n-k;b = (int *) calloc(k,sizeof(int));c = (int *) calloc(m,sizeof(int));for (i=0; i<k; i++)
b[i]=a[i];for (j=k; j<n; j++)
c[j-l]=a[j];
merge_sort (b, k);merge_sort (c, m);merge (b, c, a, k, m);free(b); free(c);
}}
![Page 59: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/59.jpg)
Spring Semester 2007 Programming and Data Structure 59
void merge (int *a, int *b, int *c, int m, int n){
int i, j, k, p;
i = j = k = 0;
do {if (a[i] < b[j]) {c[k]=a[i]; i=i+1;
}else { c[k]=b[j]; j=j+1;
}k++;
} while ((i<m) && (j<n));
if (i == m) {for (p=j; p<n; p++) { c[k]=b[p]; k++; }
}else {
for (p=i; p<m; p++) { c[k]=a[p]; k++; }}
}
![Page 60: sort search in C](https://reader034.fdocuments.us/reader034/viewer/2022052522/54833e8ab079593d0c8b4981/html5/thumbnails/60.jpg)
Spring Semester 2007 Programming and Data Structure 60
main(){
int i, num;int a[ ] = {-56,23,43,-5,-3,0,123,-35,87,56,75,80};
for (i=0;i<12;i++) printf ("%d ",a[i]);
printf ("\n");
merge_sort (a, 12);
printf (“\nSorted list:");for (i=0;i<12;i++)
printf (“ %d", a[i]); printf ("\n");
}