Presentation on binary search, quick sort, merge sort and problems

By- Sumita Das
Presentation On Binary Search, Quick
Sort, Merge Sort And Problems
Created by Sumita Das

Binary Search
• If we have an ordered list and we know how
many things are in the list (i.e., number of records
in a file), we can use a different strategy.
• The binary search gets its name because the
algorithm continually divides the list into two
parts.

How a Binary Search Works
Always look at the center
value. Each time you get to
discard half of the remaining
list.

Initialize
FailureGet Midpoint
High < Low
< >Compare
Adjust High Adjust Low
Success=

Algorithm:
Low= 1; High = n;
while Low < High {
m = floor( (Low+High)/2 );
if k <= A[m]
then High = m - 1
else Low = m + 1
}
if A[Low] = k then j = Low else j = 0

•Similar to merge sort - divide-and-
conquer recursive algorithm
•One of the fastest sorting algorithms
•Average running time O(NlogN)
•Worst-case running time O(N2
)
Quick sort

Basic idea
1.Pick one element in the array, which will be
the pivot.
2.Make one pass through the array, called a
partition step, re-arranging the entries so that:
•the pivot is in its proper place.
•entries smaller than the pivot are to the left
of the pivot.
•entries larger than the pivot are to its right.

3.Recursively apply quick sort to the part
of the array that is to the left of the pivot,
and to the right part of the array.
Note:
Here we don't have the merge step, at
the end all the elements are in the proper
order.

Algorithm:
• Input: Array E and indices first, and last, s.t. elements
E[i] are defined for first ≤ i ≤ last
• Ouput: E[first], …, E[last] is a sorted rearrangement of
the array
• Void quickSort(Element[] E, int first, int last)
if (first < last)
Element pivotElement = E[first];
int splitPoint = partition(E, pivotElement, first,
last);
quickSort (E, first, splitPoint –1 );
quickSort (E, splitPoint +1, last );
return;

Merge Sort
• Uses recursion. Slightly faster than heap, but uses
twice as much memory from the 2nd
array.
• Sometimes called “divide and conquer” sort.
• Works by recursively splitting an array into two
equal halves, sorting the items, then re-merging
them back into a new array.

Algorithm:
• Split array A[1..n] in two and make copies of each half in
arrays B[1.. n/2 ] and C[1.. n/2 ]
• sort arrays B and C
• Merge sorted arrays B and C into array A

Using Divide and Conquer: Merge Sort
• Merge Sort Strategy
Sorted
Merge
Sorted Sorted
Sort recursively
by Mergesort
Sort recursively
by Mergesort
first last
(first + last)/2

Example : Binary Searching
14?
14?

Binary Searching
14

Example : Quick sort

Example : Merge Sort
– n Power of 2
1 2 3 4 5 6 7 8
q = 462317425
1 2 3 4
7425
5 6 7 8
6231
1 2
25
3 4
74
5 6
31
7 8
62
1
5
2
2
3
4
4
7 1
6
3
7
2
8
6
5
Divide

Example – n Power of 2
1
5
2
2
3
4
4
7 1
6
3
7
2
8
6
5
1 2 3 4 5 6 7 8
76543221
1 2 3 4
7542
5 6 7 8
6321
1 2
52
3 4
74
5 6
31
7 8
62
Conquer
and
Merge

Example – n Not a Power of 2
62537416274
1 2 3 4 5 6 7 8 9 10 11
q = 6
416274
1 2 3 4 5 6
62537
7 8 9 10 11
q = 9q = 3
274
1 2 3
416
4 5 6
537
7 8 9
62
10 11
74
1 2
2
3
16
4 5
4
6
37
7 8
5
9
2
10
6
11
4
1
7
2
6
4
1
5
7
7
3
8
Divide

Example – n Not a Power of 2
77665443221
1 2 3 4 5 6 7 8 9 10 11
764421
1 2 3 4 5 6
76532
7 8 9 10 11
742
1 2 3
641
4 5 6
753
7 8 9
62
10 11
2
3
4
6
5
9
2
10
6
11
4
1
7
2
6
4
1
5
7
7
3
8
74
1 2
61
4 5
73
7 8
Conquer
and
Merge

References
[1]Introduction to Algorithms 2nd ,Cormen, Leiserson, Rivest and
Stein, The MIT Press, 2001.

Thank you….

Presentation on binary search, quick sort, merge sort and problems

More Related Content

What's hot (20)

Viewers also liked (20)

Similar to Presentation on binary search, quick sort, merge sort and problems (20)

More from Sumita Das (10)

Recently uploaded (20)

Presentation on binary search, quick sort, merge sort and problems