search_sort_v1.pptgghghhhggggjjjjjjllllllllvbbbbbcfdsdfffg

The process used to find the location
of a target among a list of objects
Searching an array finds the index of first element in an array
containing that value
Searching

Unordered Linear Search
Search an unordered array of integers for a value and return its index if
the value is found. Otherwise, return -1.
A[0] A[1] A[2] A[3] A[4] A[5] A[6] A[7]
Algorithm:
Start with the first array element (index 0)
while(more elements in array){
if value found at current index, return index;
Try next element (increment index);
}
Value not found, return -1;
14 2 10 5 1 3 17 2

Unordered Linear Search
// Searches an unordered array of integers
int search(int data[], //input: array
int size, //input: array size
int value){ //input: search value
// output: if found, return index;
// otherwise, return –1.
for(int index = 0; index < size; index++){
if(data[index] == value)
return index;
}
return -1;
}

8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
Binary Search
lo
Binary search. Given value and sorted array a[], find index i
such that a[i] = value, or report that no such index exists.
Invariant. Algorithm maintains a[lo]  value  a[hi].
Ex. Binary search for 33.
hi

Binary Search
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo hi
mid

Binary Search
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo hi

Binary Search
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo mid hi

Binary Search
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo
hi

Binary Search
8
2
1 3 4 6
5 7 10
9 11 12 14
13
0
64
14
13 25 33 51
43 53 84
72 93 95 97
96
6
lo
hi
mid

17
Example: Binary Search
Searching for an element k in a sorted array A with n
elements
Idea:

Choose the middle element A[n/2]

If k == A[n/2], we are done

If k < A[n/2], search for k between A[0] and A[n/2 -
1]

If k > A[n/2], search for k between A[n/2 + 1] and
A[n-1]

Repeat until either k is found, or no more elements
to search
Requires less number of comparisons than linear
search in the worst case (log2n instead of n)

18
int main() {
int A[100], n, k, i, mid, low, high;
scanf(“%d %d”, &n, &k);
for (i=0; i<n; ++i)
scanf(“%d”, &A[i]);
low = 0; high = n – 1; mid = (high + low)/2;
while (high >= low) {
if (A[mid] == k) {
printf(“%d is foundn”, k);
break;
}
if (k < A[mid]) high = mid – 1;
else
low = mid + 1;
mid = (high + low)/2;
}
If (high < low) printf(“%d is not foundn”, k);
}

20
Bubble Sort
Stage 1: Compare each element (except the last one) with
its neighbor to the right

If they are out of order, swap them

This puts the largest element at the very end

The last element is now in the correct and final place
Stage 2: Compare each element (except the last two)
with its neighbor to the right

If they are out of order, swap them

This puts the second largest element next to last

The last two elements are now in their correct and final places
Stage 3: Compare each element (except the last three)
with its neighbor to the right

Continue as above until you have no unsorted elements on the left

21
Example of Bubble Sort
7 2 8 5 4
2 7 8 5 4
2 7 8 5 4
2 7 5 8 4
2 7 5 4 8
2 7 5 4 8
2 5 7 4 8
2 5 4 7 8
2 7 5 4 8
2 5 4 7 8
2 4 5 7 8
2 5 4 7 8
2 4 5 7 8
2 4 5 7 8
(done)
Stage 1 Stage 2 Stage 3 Stage 4

22
Code for Bubble Sort
void bubbleSort(int[] a) {
int stage, inner, temp;
for (stage = a.length - 1; stage > 0; stage--) { // counting down
for (inner = 0; inner < stage; inner++) { // bubbling up
if (a[inner] > a[inner + 1]) { // if out of order...
temp = a[inner]; // ...then swap
a[inner] = a[inner + 1];
a[inner + 1] = temp;
}
}
}
}

24
Insertion Sort
Suppose we know how to insert a new element x in its proper
place in an already sorted array A of size k, to get a new
sorted array of size k+1
Use this to sort the given array A of size n as follows:

Insert A[1] in the sorted array A[0]. So now A[0],A[1] are
sorted

Insert A[2] in the sorted array A[0],A[1]. So now
A[0],A[1],A[2] are sorted

Insert A[3] in the sorted array A[0],A[1],A[2]. So now
A[0],A[1],A[2],A[3] are sorted

…..

Insert A[i] in the sorted array A[0],A[1],…,A[i-1]. So now
A[0],A[1],…A[i] are sorted

Continue until i = n-1 (outer loop)

25
How to do the first step
Compare x with A[k-1] (the last element)

If x ≥ A[k-1], we can make A[k] = x (as x is the max
of all the elements)

If x < A[k-1], put A[k] = A[k-1] to create a hole in
the k-th position, put x there
Now repeat by comparing x with A[k-2] (inserting x in
its proper place in the sorted subarray A[0],A[1],…
A[k-1] of k-2 elements)
The value x bubbles to the left until it finds an
element A[i] such that x ≥ A[i]
No need to compare any more as all elements A[0],
A[1], A[i] are less than x

26
Example of first step
5 7 11 13 20 22
A Insert x = 15

27
5 7 11 13 20 22
5 7 11 13 20 15 22
A Insert x = 15
Compare with 22. x < 22, so move 22 right

28
5 7 11 13 20 22
5 7 11 13 20 15 22
5 7 11 13 15 20 22
A Insert x = 15

29
5 7 11 13 20 22
5 7 11 13 20 15 22
5 7 11 13 15 20 22
5 7 11 13 15 20 22
A Insert x = 15
Compare with 13. x > 13, so stop
A

30
Sort using the insertion
7 5 13 11 22 20
5 7 13 11 22 20
5 7 13 11 22 20
5 7 11 13 22 20
A
Insert 5 in 7
Insert 13 in 5, 7
Insert 11 in 5, 7, 13
Insert 22 in 5, 7, 11, 13
Insert 20 in 5, 7, 11, 13, 22
5 7 11 13 20 22
5 7 11 13 22 20

31
Insertion Sort Code
void InsertionSort (int A[ ], int size)
{
int i, j, item;
for (i=1; i<size; i++)
{ /* Insert the element in A[i] */
item = A[i] ;
for (j = i-1; j >= 0; j--)
if (item < A[j])
{ /* push elements down*/
A[j+1] = A[j];
A[j] = item ; /* can do this on
}
else break; /*inserted, exit loop */
}
}

32
Look at the sorting!
8
2
9
4
7
6
2
1
5
i = 1:: 2, 9, 4, 7, 6, 2, 1, 5
i = 2:: 9, 2, 4, 7, 6, 2, 1, 5
i = 3:: 9, 4, 2, 7, 6, 2, 1, 5
i = 4:: 9, 7, 4, 2, 6, 2, 1, 5
i = 5:: 9, 7, 6, 4, 2, 2, 1, 5
i = 6:: 9, 7, 6, 4, 2, 2, 1, 5
i = 7:: 9, 7, 6, 4, 2, 2, 1, 5
Result = 9, 7, 6, 5, 4, 2, 2, 1
void InsertionSort (int A[ ], int size) {
int i,j, item;
for (i=1; i<size; i++) {
printf("i = %d:: ",i);
for (j=0;j<size;j++) printf("%d, ",A[j]);
printf("n"); item = A[i] ;
for (j=i-1; j>=0; j--)
if (item > A[j])
{ A[j+1] = A[j]; A[j] = item ; }
else break;
}
int main() {
int X[100], i, size;
scanf("%d",&size);
for (i=0;i<size;i++) scanf("%d",&X[i]);
InsertionSort(X,size);
printf("Result = ");
for (i=0;i<size;i++) printf("%d, ",X[i]);
printf("n"); return 0;
}

34
Basic Idea
Divide the array into two halves
Sort the two sub-arrays
Merge the two sorted sub-arrays into a single
sorted array
Step 2 (sorting the sub-arrays) is done
recursively (divide in two, sort, merge) until
the array has a single element (base
condition of recursion)

35
Merging Two Sorted Arrays
3 4 7 8 9
2 5 7
2
3 4 7 8 9
2 5 7
2 3
3 4 7 8 9
2 5 7
2 3 4
3 4 7 8 9
2 5 7
Problem: Two sorted arrays A and B are given. We are required
produce a final sorted array C which contains all elements of A

36
2 3 4 5
3 4 7 8 9
2 5 7
2 3 4 5 7
3 4 7 8 9
2 5 7
2 3 4 5 7 7
3 4 7 8 9
2 5 7
2 3 4 5 7 7 8
3 4 7 8 9
2 5 7

37
Merge Code
2 3 4 5 7 7 8 9
3 4 7 8 9
2 5 7
void
merge (int A[], int B[], int C[], int m,int n)
{
int i=0,j=0,k=0;
while (i<m && j<n)
{
if (A[i] < B[j]) C[k++] = A[i++];
else C[k++] = B[j++];
}
while (i<m) C[k++] = A[i++];
while (j<n) C[k++] = B[j++];
}

38
Merge Sort: Sorting an array
recursively
void mergesort (int A[], int n)
{
int i, j, B[max];
if (n <= 1) return;
i = n/2;
mergesort(A, i);
mergesort(A+i, n-i);
merge(A, A+i, B, i, n-i);
for (j=0; j<n; j++) A[j] = B[j];
free(B);
}

search_sort_v1.pptgghghhhggggjjjjjjllllllllvbbbbbcfdsdfffg

More Related Content

Similar to search_sort_v1.pptgghghhhggggjjjjjjllllllllvbbbbbcfdsdfffg (20)

Recently uploaded (20)

search_sort_v1.pptgghghhhggggjjjjjjllllllllvbbbbbcfdsdfffg