Data Structures_Searching and Sorting.pptx

05/03/2025 JSPM's RSCOE
Unit V: Searching & Sorting
Dr. Rushali A. Deshmukh

CONTENTS
• Sorting Order and Stability in Sorting.
• Concept of Internal and External Sorting.
• Bubble Sort,
• Insertion Sort,
• Selection Sort,
• Quick Sort and
• Merge Sort,
• Radix Sort, and
• Shell Sort,
• External Sorting, Time complexity analysis of Sorting
Algorithms.
JSPM's RSCOE

Sequential Search
• To search the key ‘22’:
int SeqSearch(int a[], int n, key)
{
int i;
for (i=0; i<n && a[i] != key; i++)
;
if (i >= n)
return -1;
return i;
}
23
0
2
1
7
2
15
3
42
4
12
5
The search makes n key comparisons when it is unsuccessful.

Analysis of Time Complexity
• Worst case:
– O(n) when the search is unsuccessful.
– Each element is examined exactly once.
• Average case:
– When the search is successful, the number of
comparison depends on the position of the
search key.
2
1
1
2
)
1
(
1







 










n
n
n
n
n
i
n
i

Binary Search
int BinarySearch(int a[], int n, in key)
{
int left = 0, right = n-1;
while (left <= right)
{
int middle = (left + right) / 2;
if (key < a[middle]) right = middle - 1;
else if (key > a[middle]) left = middle + 1;
else return middle;
}
return -1;
}
2
0
7
1
12
2
15
3
23
4
42
5
left right
middle
To find 23, middle
found.

Binary Search
• Even when the search is
unsuccessful, the time complexity is
still O(log n).
– Something is to be gained by maintaining
the list in an order manner.

Sentinel Search
• To reduce overhead of checking the list’s length,
the value to be searched can be appended to the
list at the end as a “sentinel value”.
• A sentinel value is one whose presence
guarantees the termination of a loop that
processes structured (or sequential) data.
• Thus on encountering a matching value, its
index is returned.

Sorting
Sorting is the operation of arranging the
records of a table according to the key value of
each record, or it can be defined as the process
of converting an unordered set of elements to
an ordered set.

Types of Sorting
Types of Sorting
Internal Sorts
External sorts

Internal Sorts
 Any sort algorithm that uses
main memory exclusively
during the sorting is called
as an internal sort
algorithm. This assumes
high-speed and random
access to all data members.
 Internal sorting is faster
than external sorting.
The various internal sorting
techniques are the following:
1. Bubble sort
2. Insertion sort
3. Selection sort
4. Quick sort
5. Heap sort
6. Shell sort
7. Bucket sort
8. Radix sort
9. File sort
10. Merge sort

External sorts
 Any sort algorithm that uses external memory,
such as tape or disk, during the sorting is called as
an external sort algorithm.
 Merge sort uses external memory.

Sorting
• Sorting takes an unordered collection and
makes it an ordered one.
5
12
35
42
77 101
1 2 3 4 5 6
5 12 35 42 77 101
1 2 3 4 5 6

Sorting an Array of Integers
• Example:
we are
given an
array of
six
integers
that we
want to
sort from
smallest
to largest
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

"Bubbling Up" the Largest Element
• Traverse a collection of elements
– Move from the front to the end
– “Bubble” the largest value to the end
using pair-wise comparisons and
swapping
5
12
35
42
77 101
1 2 3 4 5 6

swapping
5
12
35
42
77 101
1 2 3 4 5 6
Swap
42 77

swapping
5
12
35
77
42 101
1 2 3 4 5 6
Swap
35 77

swapping
5
12
77
35
42 101
1 2 3 4 5 6
Swap
12 77

swapping
5
77
12
35
42 101
1 2 3 4 5 6
No need to swap

swapping
5
77
12
35
42 101
1 2 3 4 5 6
Swap
5 101

swapping
77
12
35
42 5
1 2 3 4 5 6
101
Largest value correctly placed

void BubbleSort(int a[],n)
{
int i,j,temp;
for(i=1;i<n;i++)
for(j=0;j<n-i;j++)
if(a[j]>a[j+1])
{
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}

void BubbleSort(int a[],n)
{
int i,j,temp;
for(i=1;i<n;i++)
{ bool flag = false
for(j=0;j<n-i;j++)
{ if(a[j]>a[j+1])
{ flag = true
temp=a[j];
a[j]=a[j+1];
a[j+1]=temp;
}
}
if(!flag) break;
}
}
Optimized Bubble Sort

Time and Space Complexity Analysis
Complexity Type Complexity
Time Complexity Best: O(n)
Average: O(n^2)
Worst: O(n^2)
Space Complexity Worst: O(1)
Bubble Sort only needs a constant
amount of additional space during
the sorting process.

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Insertion Sort Algorithm
• The
Insertion
Sort
algorithm
also views
the array as
having a
sorted side
and an
unsorted
side.
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• The sorted
side starts
with just
the first
element,
which is
not
necessarily
the
smallest
element. 0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]
Sorted side Unsorted side

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• The
sorted
side
grows by
taking the
front
element
from the
unsorted
side... 0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• ...and
inserting it
in the
place that
keeps the
sorted
side
arranged
from
small to
large.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• Sometime
s we are
lucky and
the new
inserted
item
doesn't
need to
move at
all.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Insertionsort Algorithm
• Sometime
s we are
lucky
twice in a
row.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
How to Insert One Element
Copy the
new
element
to a
separate
location.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
Shift
elements
in the
sorted
side,
creating
an open
space for
the new
element.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
Shift
elements
in the
sorted
side,
creating
an open
space for
the new
element.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
Continue
shifting
elements..
.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
...until you
reach the
location
for the
new
element.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
Copy the
new
element
back into
the array,
at the
correct
location.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• The last
element
must also
be
inserted.
Start by
copying
it...
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
Sorted Result
[0] [1] [2] [3] [4] [5]

void insertion_sort (int data[], int n)
{
int i, j;
int temp;
if(n < 2) return; // nothing to sort!!
for(i = 1; i < n; ++i)
{
// take next item at front of unsorted part of array
// and insert it in appropriate location in sorted part of array
temp = data[i];
for(j = i; data[j-1] > temp && j > 0; --j)
data[j] = data[j-1]; // shift element forward
data[j] = temp;
}
}

Insertion Sort Time Analysis
• In O-notation, what is:
– Worst case running time for n items?
– Average case running time for n items?
• Steps of algorithm:
for i = 1 to n-1
take next key from unsorted part of array
insert in appropriate location in sorted part of array:
for j = i down to 0,
shift sorted elements to the right if key > key[i]
increase size of sorted array by 1
Outer loop:
O(n)

• In O-notation, what is:
– Worst case running time for n items?
– Average case running time for n items?
for i = 1 to n-1
Outer loop:
O(n)
Inner loop:
O(n)

template <class Item>
void insertion_sort(Item data[ ], size_t n)
{
size_t i, j;
Item temp;
for(i = 1; i < n; ++i)
{
// take next item at front of unsorted part of array
// and insert it in appropriate location in sorted part of array
temp = data[i];
for(j = i; data[j-1] > temp and j > 0; --j)
data[j] = data[j-1]; // shift element forward
data[j] = temp;
}
}
O(n)
O(n)

for i = 1 to n-1

Complexity Analysis of Insertion Sort
Time Complexity
Worst Case: O(n2)
Best Case: O(n)
Average Case: O(n2)
Auxiliary Space: O(1)

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
The Selection Sort Algorithm
• Start by
finding the
smallest
entry.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• Swap the
smallest
entry with
the first
entry.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• Part of the
array is
now
sorted.
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• Find the
smallest
element in
the
unsorted
side.
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• Swap with
the front
of the
unsorted
side.
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• We have
increased
the size of
the sorted
side by
one
element.
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• The
process
continues.
..
Smallest
from
unsorted
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• The
process
continues.
..
[0] [1] [2] [3] [4] [5]
Swap
with
front

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• The
process
continues.
..
Sorted side
is bigger
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• The process
keeps adding
one more
number to the
sorted side.
• The sorted
side has the
smallest
numbers,
arranged from
small to large.
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• We can stop
when the
unsorted
side has just
one number,
since that
number must
be the
largest
number.
[0] [1] [2] [3] [4] [5]

0
10
20
30
40
50
60
70
[1] [2] [3] [4] [5] [6]
• The array is
now sorted.
• We
repeatedly
selected the
smallest
element, and
moved this
element to
the front of
the unsorted [0] [1] [2] [3] [4] [5]

void selectionsort(int arr[], int n)
{
int i, j, min_idx;
// One by one move boundary of
// unsorted subarray
for (i = 0; i < n-1; i++)
{
// Find the minimum element in
// unsorted array
min_idx = i;
for (j = i+1; j < n; j++)
if (arr[j] < arr[min_idx])
min_idx = j;
// Swap the found minimum element
// with the first element
int temp = arr[min_idx];
arr[min_idx] = arr[i];
arr[i] = temp;
} }

Selection Time Sort Analysis
for i = 1 to n-1
find smallest key in unsorted part of array
swap smallest item to front of unsorted array
decrease size of unsorted array by 1

void selection_sort(Item data[ ], size_t n)
{
size_t i, j, smallest;
Item temp;
for(i = 0; i < n-1 ; ++i)
{
// find smallest in unsorted part of array
smallest = i;
for(j = i+1; j < n; ++j)
if(data[smallest] > data[j]) smallest = j;
// put it at front of unsorted part of array (swap)
temp = data[i];
data[i] = data[smallest];
data[smallest] = temp;
}
}
Outer loop:
O(n)

void selection_sort(Item data[ ], size_t n)
{
size_t i, j, smallest;
Item temp;
for(i = 0; i < n-1 ; ++i)
{
// find smallest in unsorted part of array
smallest = i;
for(j = i+1; j < n; ++j)
if(data[smallest] > data[j]) smallest = j;
// put it at front of unsorted part of array (swap)
temp = data[i];
data[i] = data[smallest];
data[smallest] = temp;
}
}
Outer loop:
O(n)
Inner loop:
O(n)

Selection Time Sort Analysis
for i = 1 to n-1 O(n)
find smallest key in unsorted part of array O(n)
swap smallest item to front of unsorted array
decrease size of unsorted array by 1
• Selection sort analysis: O(n2
)

Complexity Analysis of Selection Sort
Time Complexity
Worst Case: O(n^2)
Best Case: O(n^2)
Average Case: O(n^2)
Auxiliary Space: O(1)

Quicksort Algorithm
Given an array of n elements (e.g., integers):
• If array only contains one element, return
• Else
– pick one element to use as pivot.
– Partition elements into two sub-arrays:
• Elements less than or equal to pivot
• Elements greater than pivot
– Quicksort two sub-arrays
– Return results

Example
We are given array of n integers to sort:
40 20 10 80 60 50 7 30 100

Pick Pivot Element
There are a number of ways to pick the pivot element.
In this example, we will use the first element in the
array:
40 20 10 80 60 50 7 30 100

Partitioning Array
Given a pivot, partition the elements of the array
such that the resulting array consists of:
1. One sub-array that contains elements >= pivot
2. Another sub-array that contains elements < pivot
The sub-arrays are stored in the original data
array.
Partitioning loops through, swapping elements
below/above pivot.

40 20 10 80 60 50 7 30 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j

40 20 10 80 60 50 7 30 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
1. While data[i] <= data[pivot]
++i
i j

40 20 10 80 60 50 7 30 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
++i
j
i

40 20 10 80 60 50 7 30 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
j
++i
2. While data[j] > data[pivot]
--j
i

40 20 10 80 60 50 7 30 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j
++
--j

40 20 10 80 60 50 7 30 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j
++i
--j
3. If i < j
swap data[i] and data[j]

40 20 10 30 60 50 7 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j
++i
--j
3. If i< j

40 20 10 30 60 50 7 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [ 5] [6] [7] [8]
i j
++i
--j
3. If i < j
4. While j > i go to 1.

40 20 10 30 60 50 7 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j
++i
--j
3. If i<j
4. While j> i, go to 1.

40 20 10 30 60 50 7 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j
++i
--j
3. If i< j
4. While j > i, go to 1.

40 20 10 30 60 50 7 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j
++i
--j
3. If i < j

++i
--j
3. If i < j
40 20 10 30 7 50 60 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j

++i
--j
3. If i< j
40 20 10 30 7 50 60 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j

++i
--j
3. If i < j
40 20 10 30 7 50 60 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j

++i
--j
3. If i< j
40 20 10 30 7 50 60 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j

++i
--j
3. If i<j
40 20 10 30 7 50 60 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j

++I
--j
3. If i < j
5. Swap data[j] and data[pivot_index]
40 20 10 30 7 50 60 80 100
pivot_index = 0
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j

++I
--j
3. If i<j
5. Swap data[j] and
data[pivot_index]
7 20 10 30 40 50 60 80 100
pivot_index = 4
[0] [1] [2] [3] [4] [5] [6] [7] [8]
i j

Partition Result
7 20 10 30 40 50 60 80 100
[0] [1] [2] [3] [4] [5] [6] [7] [8]
<= data[pivot] > data[pivot]

Time Complexity of Quick Sort
Variation Time
Complexity
Best Case O(n log n)
Average Case O(n log n)
Worst Case O(n^2)

Divide and Conquer
• Divide and Conquer cuts the problem in half
each time, but uses the result of both halves:
– cut the problem in half until the problem is
trivial
– solve for both halves
– combine the solutions

Mergesort
• A divide-and-conquer algorithm:
• Divide the unsorted array into 2 halves until
the sub-arrays only contain one element
• Merge the sub-problem solutions together:
– Compare the sub-array’s first elements
– Remove the smallest element and put it into
the result array
– Continue the process until all elements have
been put into the result array
37 23 6 89 15 12 2 19

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98
Merge

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98
23
Merge

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98
23 98
Merge

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
23 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
Merge
23 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
14
Merge
23 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
45
Merge
23 98 14

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
Merge
98 45
14
23

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
Merge
98 14
14
23 45

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
Merge
23 14
14 23
98 45

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
Merge
23 98 45
14
14 23 45

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
Merge
23 98 45
14
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
23 98 45
14
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6
23 98 45
14
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6
Merge
23 98 45
14
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6
6
Merge
23 98 45
14
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6
67
Merge
23 98 45
14 6
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
23 98 45
14 67
6
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
33
23 98 45
14 67
6
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
42
23 98 45
14 67
6 33
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
14 23 45 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 6 42
33
14 23 45 98 6
67

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 6 33
14 23 45 98 6 33
67 42

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 6 42
33
14 23 45 98 6 33 42
67

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
14 23 45 98 6 33 42 67

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
23 45 98 33 42 67
14 6

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
23 45 98 6 42 67
6
14 33

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
14 45 98 6 42 67
6 14
23 33

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
14 23 98 6 42 67
6 14 23
45 33

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
14 23 98 6 33 67
6 14 23 33
45 42

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
14 23 98 6 33 42
6 14 23 33 42
45 67

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
14 23 45 6 33 42
6 14 23 33 42 45
98 67

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
14 23 45 98 6 33 42 67
6 14 23 33 42 45 67

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
Merge
23 98 45
14 67
6 42
33
14 23 45 98 6 33 42 67
6 14 23 33 42 45 67 98

67
45
23 14 6 33
98 42
67
45
23 14 6 33
98 42
45
23 14
98
23
98 45 14
67
6 33 42
67
6 33 42
23 98 45
14 67
6 42
33
14 23 45 98 6 33 42 67
6 14 23 33 42 45 67 98

67
45
23 14 6 33
98 42
6 14 23 33 42 45 67 98

// The subarray to be sorted is in the index range [left-right]
void mergeSort(int arr[], int left, int right) {
if (left < right) {
// Calculate the midpoint
int mid = (right + left) / 2;
// Sort first and second halves
mergeSort(arr, left, mid);
mergeSort(arr, mid + 1, right);
// Merge the sorted halves
merge(arr, left, mid, right);
}

void merge(int arr[], int left, int mid, int right) {
int i, j, k;
int n1 = mid - left + 1;
int n2 = right - mid;
// Create temporary arrays
int leftArr[n1], rightArr[n2];
// Copy data to temporary arrays
for (i = 0; i < n1; i++)
leftArr[i] = arr[left + i];
for (j = 0; j < n2; j++)
rightArr[j] = arr[mid + 1 + j];

// Merge the temporary arrays back
into arr[left..right]
i = 0;
j = 0;
k = left;
while (i < n1 && j < n2) {
if (leftArr[i] <= rightArr[j]) {
arr[k] = leftArr[i];
i++;
}
else {
arr[k] = rightArr[j];
j++;
}
k++;
}
// Copy the remaining elements of leftArr[], if any
while (i < n1) {
arr[k] = leftArr[i];
i++;
k++;
}
// Copy the remaining elements of rightArr[], if any
while (j < n2) {
arr[k] = rightArr[j];
j++;
k++;
}
}

Time Complexity of Merge Sort
Variation Time
Complexity
Best Case O(n log n)
Average Case O(n log n)
Worst Case O(n log n)

Bucket sort is a sorting algorithm in which
the elements are separated into several
groups that are called buckets. Each bucket
is then sorted individually using any other
algorithm or recursively using bucket sort
itself. Then the sorted buckets are gathered
together.

Bucket Sort Algorithm:
The algorithm can be expressed as following:
1. Take the array then find the maximum and minimum elements of the array.
Find the range of each bucket.
Bucket range:((maximum element – minimum element)/number of elements)
2. Now insert the element into the bucket based on Bucket Index.
Bucket Index: floor(a[i]-minimum element)/range
3. Once the elements are inserted into each bucket, sort the elements within
each bucket using the insertion sort.

Consider an array arr[] = {22, 72, 62, 32, 82, 142}
Range= (maximum-minimum) / number of elements
So, here the range will be given as: Range = (142 – 22)/6 = 20
Thus, the range of each bucket in bucket sort will be: 20 So, the buckets will
be as:
20-40; 40-60; 60-80; 80-100; 100-120; 120-140; 140-160
Bucket index = floor((a[i]-min)/range)
For 22, bucketindex = (22-22)/20 = 0.
For 72, bucketindex = (72-22)/20 = 2.5.
For 62, bucketindex = (62-22)/20 = 2.
For 32, bucketindex = (32-22)/20 = 0.5.
For 82, bucketindex = (82-22)/20 = 3.
For 142, bucketindex = (142-22)/20 = 6.

Elements can be inserted into the bucket as:
0 -> 22 -> 32
1
2 -> 72 -> 62 (72 will be inserted before 62 as it appears first in the list).
3 -> 82
4
5
6 -> 142
Now sort the elements in each bucket using the insertion sort.
0 -> 22 -> 32
1
2 -> 62 -> 72
3 -> 82
4
5
6 -> 142
Now gather them together.
arr[] = {22, 32, 62, 72, 82, 142}

Radix Sort
Radix sort is a generalization of bucket sort and works in three steps:
1. Distribute all elements into m buckets. Here m is a suitable integer, for
example, to sort decimal numbers with radix 10. We take 10
buckets numbered as 0, 1, 2, …, 9. For sorting strings, we may need 26
buckets, and so on.
2. Sort each bucket individually.
3. Finally, combine all buckets

Radix Sort
 To sort each bucket, we may use any of the other sorting
techniques or radix sort recursively.
 To use radix sort recursively, we need more than one pass
depending upon the range of numbers to be sorted. For
sorting single digit number, we need only one pass.
 For sorting numbers with two digits mean ranging between
00 and 99, we would need two passes; for the range from 0
to 999, we would need three passes, and so on

Radix Sort
Let us consider a set of numbers
to be sorted {07, 10, 99, 02, 80,
14, 25, 63, 88, 33, 11, 72, 68, 39,
21, 50}.
Table below illustrates a sample
run for this list using radix sort.

Time Complexity of Radix Sort
The time complexity of Radix Sort is O(n k), where n is the number of elements in
⋅
the input array and k is the digit length of the number. However, the exact time
complexity depends on the number of digits and the number of values being sorted:
Worst case
If the number of digits in the highest value is the same as the number of values to
sort, the time complexity is O(n2). This is a slow scenario.
Best case
If there are many values to sort, but the values have few digits, the time complexity
can be simplified to O(n).
Average case
If the number of digits is roughly k(n)=logn, the time complexity is O(n logn). This
is similar to Quicksort.
Radix Sort is a non-comparative algorithm that sorts integers digit by digit from
least to most significant. It's not an in-place sorting algorithm because it requires
extra space.

Shell Sort -General Description
•
Essentially a segmented insertion sort
– Divides an array into several smaller non-
contiguous segments
– The distance between successive elements in one
segment is called a gap.
– Each segment is sorted within itself using insertion
sort.
– Then resegment into larger segments (smaller
gaps) and repeat sort.
– Continue until only one segment (gap = 1) - final
sort finishes array sorting.

Shell Sort -Background
•
General Theory:
–
Makes use of the intrinsic strengths of Insertion
sort. Insertion sort is fastest when:
•
The array is nearly sorted.
•
The array contains only a small number of data items.
–
Shell sort works well because:
–
It always deals with a small number of elements.
–
Elements are moved a long way through array
with each swap and this leaves it more nearly
sorted.

Shell Sort - example
80 93 60 68
12 85
42 30 10
Initial Segmenting Gap = 4
10 30 60 68
12 85
42 93 80

Shell Sort - example (2)
10 30 60 68
12 85
42 93 80
Resegmenting Gap = 2
10 12 42 68
30 93
60 85 80

Shell Sort - example (3)
10 12 30 80
42 85
60 68 93
10 12 42 68
30 93
60 85 80
Resegmenting Gap = 1

Data Structures_Searching and Sorting.pptx

Data Structures_Searching and Sorting.pptx

More Related Content

Similar to Data Structures_Searching and Sorting.pptx

More from RushaliDeshmukh2

Recently uploaded

Data Structures_Searching and Sorting.pptx

Editor's Notes