Search Sort v1

Searching
Searching
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
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]
14 2 10 5 1 3 17 2
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;
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;
}
Binary Search
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.
13
14
25
33
43
51
53
64
72
84
93
95
96
97
10
11
12
13
14
lo
hi
Binary Search
13
14
25
33
43
51
53
64
72
84
93
95
96
97
10
11
12
13
14
lo
mid
hi
Binary Search
13
14
25
33
43
51
53
64
72
84
93
95
96
97
10
11
12
13
14
lo
hi
Binary Search
13
14
25
33
43
51
53
64
72
84
93
95
96
97
10
11
12
13
14
lo
mid
hi
Binary Search
13
14
25
33
43
51
53
64
72
84
93
95
96
97
10
11
12
13
14
lo
hi
Binary Search
13
14
25
33
43
51
53
64
72
84
93
95
96
97
10
11
12
13
14
lo
mid
hi
Binary Search
13
14
25
33
43
51
53
64
72
84
93
95
96
97
10
11
12
13
14
lo
hi
Binary Search
13
14
25
33
43
51
53
64
72
84
93
95
96
97
10
11
12
13
14
lo
hi
mid
Binary Search
13
14
25
33
43
51
53
64
72
84
93
95
96
97
10
11
12
13
14
lo
hi
mid
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)
17
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 found\n, k);
break;
}
if (k < A[mid]) high = mid 1;
else
low = mid + 1;
mid = (high + low)/2;
}
}
If (high < low) printf(%d is not found\n, k);

18
Sorting
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
20
Example of Bubble Sort
Stage 1
Stage 2
Stage 3
Stage 4
(done)
21
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;
}
}
}
}
22
Insertion Sort
23
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)
24
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
25
Example of first step
A 5 7
11 13 20 22
Insert x = 15
26
A 5 7
11 13 20 22
Insert x = 15
Compare with 22. x < 22, so move 22 right
5 7
11 13 20 15 22
27
A 5 7
11 13 20 22
Insert x = 15
5 7
11 13 20 15 22
5 7
11 13 15 20 22
28
A 5 7
11 13 20 22
Insert x = 15
5 7
11 13 20 15 22
5 7
11 13 15 20 22
Compare with 13. x > 13, so stop
5 7
11 13 15 20 22
29
Sort using the insertion
A 7 5
13 11 22 20
Insert 5 in 7
5 7
13 11 22 20
Insert 13 in 5, 7
5 7
13 11 22 20
Insert 20 in 5, 7, 11, 13, 22
5 7
11 13 20 22
Insert 11 in 5, 7, 13
5 7
11 13 22 20
Insert 22 in 5, 7, 11, 13
5 7
11 13 22 20
30
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 */
}
}
31
void InsertionSort (int A[ ], int size) {

int i,j, item;
for (i=1; i<size; i++) {
printf("i = %d:: ",i);
8 ",A[j]);
for (j=0;j<size;j++) printf("%d,
2
printf("\n"); item = A[i] ;
9
for (j=i-1; j>=0; j--)
4
if (item > A[j])
7
{ A[j+1] = A[j]; A[j] = item6 ; }
2
else break;
1
}
5
int main() {
i = 1:: 2,
int X[100], i, size;
i = 2:: 9,
i = 3:: 9,
scanf("%d",&size);
i = 4:: 9,
for (i=0;i<size;i++) scanf("%d",&X[i]);
i = 5:: 9,
InsertionSort(X,size);
i = 6:: 9,
printf("Result = ");
i = 7:: 9,
for (i=0;i<size;i++) printf("%d,
",X[i]);
Result
= 9,
printf("\n"); return 0;
}
Look at the sorting!
9,
2,
4,
7,
7,
7,
7,
7,
4,
4,
2,
4,
6,
6,
6,
6,
7,
7,
7,
2,
4,
4,
4,
5,
6,
6,
6,
6,
2,
2,
2,
4,
2,
2,
2,
2,
2,
2,
2,
2,
32
1,
1,
1,
1,
1,
1,
1,
2,
5
5
5
5
5
5
5
1
Mergesort
33
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)
34
Merging Two Sorted Arrays
Problem: Two sorted arrays A and B are given. We are required

produce a final sorted array C which contains all
3 4 7 8 9
3 4 7 8 9
2 5 7
2 5 7
elements of A
2
3 4 7 8 9
3 4 7 8 9
2 5 7
2 5 7
2 3
2 3 4
35
3 4 7 8 9
3 4 7 8 9
2 5 7
2 5 7
2 3 4 5
2 3 4 5 7
3 4 7 8 9
3 4 7 8 9
2 5 7
2 5 7
2 3 4 5 7 7
2 3 4 5 7 7 8
36
Merge Code
3 4 7 8 9
2 5 7
2 3 4 57 7 8 9
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++];
}
37
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);
}
38

Search Sort v1

Transféré par

Informations du document

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Search Sort v1

Transféré par

Droits d'auteur :

Formats disponibles

Searching

The process used to find the location

Unordered Linear Search

Start with the first array element (index 0)

Unordered Linear Search

// Searches an unordered array of integers

Ex. Binary search for 33.

Ex. Binary search for 33.

Ex. Binary search for 33.

Ex. Binary search for 33.

Ex. Binary search for 33.

Ex. Binary search for 33.

Ex. Binary search for 33.

Ex. Binary search for 33.

Ex. Binary search for 33.

Example: Binary Search

If (high < low) printf(%d is not found\n, k);

If they are out of order, swap them

Stage 2: Compare each element (except the last two)

If they are out of order, swap them

Stage 3: Compare each element (except the last three)

Continue as above until you have no unsorted elements on the left

Example of Bubble Sort

Code for Bubble Sort

Suppose we know how to insert a new element x in its proper

How to do the first step

Compare x with A[k-1] (the last element)

Example of first step

Example of first step

Compare with 22. x < 22, so move 22 right

Example of first step

Compare with 22. x < 22, so move 22 right

Compare with 20. x < 20, so move 20 right

Example of first step

Compare with 22. x < 22, so move 22 right

Compare with 20. x < 20, so move 20 right

Compare with 13. x > 13, so stop

Sort using the insertion

Insert 20 in 5, 7, 11, 13, 22

Insertion Sort Code

void InsertionSort (int A[ ], int size)

void InsertionSort (int A[ ], int size) {

Look at the sorting!

Divide the array into two halves

Merging Two Sorted Arrays

Problem: Two sorted arrays A and B are given. We are required

Merge Sort: Sorting an array

void mergesort (int A[], int n)

Vous aimerez peut-être aussi