Searching and sorting Techniques in Data structures

Searching & Sorting
• Searching

When to use Linear Search?
• When we are dealing with a small dataset.
• When you are searching for a dataset stored in
contiguous memory.

Example:2
Consider the array arr[] = {10, 50, 30, 70, 80,
20, 90, 40} and key = 30

// C code to linearly search x in arr[].
#include <stdio.h>
int search(int arr[], int N, int x)
{
for (int i = 0; i < N; i++)
if (arr[i] == x)
return i;
return -1; }
// Driver code
int main(void)
{
int arr[] = { 2, 3, 4, 10, 40 };
int x = 10;
int N = sizeof(arr) / sizeof(arr[0]);
// Function call
int result = search(arr, N, x);
(result == -1)
? printf("Element is not present in array")
: printf("Element is present at index %d", result);
return 0; }

Bubble sort
Bubble sort: orders a list of values by repetitively
comparing neighboring elements and swapping their
positions if necessary
• more specifically:
– scan the list, exchanging adjacent elements if they are
not in relative order; this bubbles the highest value to
the top
– scan the list again, bubbling up the second highest value
– repeat until all elements have been placed in their
proper order
33

• 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
0 1 2 3 4 5
Swap
42 77
"Bubbling" largest element
34

5
12
35
77
42 101
0 1 2 3 4 5
Swap
35 77
35

5
12
77
35
42 101
0 1 2 3 4 5
Swap
12 77
36

5
77
12
35
42 101
0 1 2 3 4 5
No need to swap
37

5
77
12
35
42 101
0 1 2 3 4 5
Swap
5 101
38

77
12
35
42 5
0 1 2 3 4 5
101
Largest value correctly placed
39

Bubble sort code
public static void bubbleSort(int a[])
{
for (int i = 0; i < a.length; i++)
{
for (int j = 1; j < a.length - i; j++)
{
// swap adjacent out-of-order elements
if (a[j-1] > a[j]) {
swap(a, j-1, j);
}
}
}
} 40

Example :1
Input: arr[] = {6, 3, 0, 5}

First Pass:
• The largest element is placed in its correct
position, i.e., the end of the array.

Second Pass:
• Place the second largest element at correct
position

Third Pass:
• Place the remaining two elements at their
correct positions.

Total no. of passes: n-1
• Total no. of comparisons: n*(n-1)/2
Complexity Analysis of
Bubble Sort:
Time Complexity: O(N2)
Auxiliary Space: O(1)

Implementation of Bubble sort
#include <stdbool.h>
#include <stdio.h>
void swap(int* xp, int* yp)
{
int temp = *xp;
*xp = *yp;
*yp = temp;
}
// An optimized version of Bubble Sort
void bubbleSort(int arr[], int n)
{
int i, j;
bool swapped;
for (i = 0; i < n - 1; i++) {
swapped = false;
for (j = 0; j < n - i - 1; j++) {
if (arr[j] > arr[j + 1]) {
swap(&arr[j], &arr[j + 1]);
swapped = true;
} }
// If no two elements were swapped by inner loop,
// then break
if (swapped == false)
break;
}}
/ Function to print an array
void printArray(int arr[], int size)
{
int i;
for (i = 0; i < size; i++)
printf("%d ", arr[i]);
}
// Driver program to test above
functions
int main()
{
int arr[] = { 64, 34, 25, 12, 22,
11, 90 };
int n = sizeof(arr) /
sizeof(arr[0]);
bubbleSort(arr, n);
printf("Sorted array: n");
printArray(arr, n);
return 0;
}
Output:Sorted array: 11 12 22 25 34 64 90

Advantages of Bubble Sort:
• Bubble sort is easy to understand and implement.
• It does not require any additional memory space.
• It is a stable sorting algorithm, meaning that elements
with the same key value maintain their relative order
in the sorted output.
• Disadvantages of Bubble Sort:
• Bubble sort has a time complexity of O(N2) which
makes it very slow for large data sets.
• Bubble sort is a comparison-based sorting algorithm,
which means that it requires a comparison operator to
determine the relative order of elements in the input
data set. It can limit the efficiency of the algorithm in
certain cases.

Selection sort
• selection sort: orders a list of values by
repetitively putting a particular value into its
final position
• find the smallest value in the list
• switch it with the value in the first position
• find the next smallest value in the list
• switch it with the value in the second position
• repeat until all values are in their proper places
48

Index
0 1 2 3 4 5 6 7
Value
27 63 1 72 64 58 14 9
1st pass
1 63 27 72 64 58 14 9
2nd pass
1 9 27 72 64 58 14 63
3rd pass
1 9 14 72 64 58 27 63
…
Selection sort example 2
50

Selection sort code
public static void selectionSort(int[] a) {
for (int i = 0; i < a.length; i++) {
// find index of smallest element
int min = i;
for (int j = i + 1; j < a.length; j++) {
if (a[j] < a[min]) {
min = j;
}
}
// swap smallest element with a[i]
swap(a, i, min);
} 51

Insertion sort
• insertion sort: orders a list of values by repetitively
inserting a particular value into a sorted subset of the
list
– consider the first item to be a sorted sublist of length 1
– insert the second item into the sorted sublist, shifting the first
item if needed
– insert the third item into the sorted sublist, shifting the other
items as needed
– repeat until all values have been inserted into their proper
positions
53

Insertion sort
• Simple sorting algorithm.
• n-1 passes over the array
• At the end of pass i, the elements that occupied A[0]…A[i]
originally are still in those spots and in sorted order.
2 8 15 1 17 10 12 5
0 1 2 3 4 5 6 7
1 2 8 15 17 10 12 5
0 1 2 3 4 5 6 7
after
pass 2
after
pass 3
2 15 8 1 17 10 12 5
0 1 2 3 4 5 6 7
54

Insertion sort code
public static void insertionSort(int[] a) {
for (int i = 1; i < a.length; i++) {
int temp = a[i];
// slide elements down to make room for a[i]
int j = i;
while (j > 0 && a[j - 1] > temp) {
a[j] = a[j - 1];
j--;
}
a[j] = temp;
}
}
56

Comparing sorts
• We've seen "simple" sorting algos. so far, such as:
– selection sort
– insertion sort
• They all use nested loops and perform approximately n2
comparisons
• They are relatively inefficient
comparisons swaps
selection n2/2 n
insertion
worst: n2/2
best: n
worst: n2/2
best: n
57

Average Case Analysis
• Given an array A of elements, an inversion is an
ordered pair (i, j) such that i < j, but
A[i] > A[j].(out of order elements)
• Assume no duplicate elements.
• Theorem: The average number of inversions in
an array of n distinct elements is n (n - 1) / 4.
• Corollary: Any algorithm that sorts by
exchanging adjacent elements requires O(n2)
time on average.
58

Shell Sort description
• shell sort: orders a list of values by comparing
elements that are separated by a gap of >1 indexes
– a generalization of insertion sort
– invented by computer scientist Donald Shell in 1959
• based on some observations about insertion sort:
– insertion sort runs fast if the input is almost sorted
– insertion sort's weakness is that it swaps each element
just one step at a time, taking many swaps to get the
element into its correct position
60

Shell sort example
• Idea: Sort all elements that are 5 indexes apart,
then sort all elements that are 3 indexes apart, ...
61

Shell sort code
public static void shellSort(int[] a)
{
for (int gap = a.length / 2; gap > 0; gap /= 2)
{
for (int i = gap; i < a.length; i++)
{
// slide element i back by gap indexes
// until it's "in order"
int temp = a[i];
int j = i;
while (j >= gap && temp < a[j - gap]) {
a[j] = a[j – gap];
j -= gap;
}
a[j] = temp;
}
}
}
62

Sorting practice problem
• Consider the following array of int values.
[22, 11, 34, -5, 3, 40, 9, 16, 6]
(a) Write the contents of the array after 3 passes of the outermost loop of bubble
sort.
(b) Write the contents of the array after 5 passes of the outermost loop of
insertion sort.
(c) Write the contents of the array after 4 passes of the outermost loop of
selection sort.
(d) Write the contents of the array after 1 pass of shell sort, using gap = 3.
(e) Write the contents of the array after a pass of bogo sort. (Just kidding.)
63

Example:
• In the first loop, n is equal to 8 (size of the array),
so the elements are lying at the interval of 4 (n/2
= 4). Elements will be compared and swapped if
they are not in order
• At the interval of 4, the sublists are {33, 12}, {31,
17}, {40, 25}, {8, 42}.

• In the second loop, elements are lying at the
interval of 2 (n/4 = 2), where n = 8.
• With an interval of 2, two sublists will be
generated - {12, 25, 33, 40}, and {17, 8, 31, 42}.

• In the third loop, elements are lying at the interval
of 1 (n/8 = 1), where n = 8

Time Complexity
Case Time Complexity
Best Case O(n*logn)
Average Case O(n*log(n)
2
)
Worst Case O(n
2
)

Radix Sort
• Radix sort is one of the sorting algorithms used to sort a
list of integer numbers in order.
• In radix sort algorithm, a list of integer numbers will be
sorted based on the digits of individual numbers.
• Sorting is performed from least significant digit to the
most significant digit.

Step by Step Process
• Step 1 - Define 10 queues each representing a
bucket for each digit from 0 to 9.
• Step 2 - Consider the least significant digit of
each number in the list which is to be sorted.
• Step 3 - Insert each number into their respective
queue based on the least significant digit.
• Step 4 - Group all the numbers from queue 0 to
queue 9 in the order they have inserted into their
respective queues.
• Step 5 - Repeat from step 3 based on the next
least significant digit.
• Step 6 - Repeat from step 2 until all the numbers
are grouped based on the most significant digit.

Complexity of the Radix
Sort Algorithm
• To sort an unsorted list with 'n' number of
elements, Radix sort algorithm needs the
following complexities...
WorstCase:O(n)
BestCase:O(n)
Average Case : O(n)

102
Double Hashing Example
0
1
2
3
4
5
6 76
76
0
1
2
3
4
5
6
93
76
93
0
1
2
3
4
5
6
93
40
76
40
0
1
2
3
4
5
6
47
93
40
76
47
0
1
2
3
4
5
6
47
93
10
40
76
10
0
1
2
3
4
5
6
47
93
10
55
40
76
55
h(k) = k mod 7 and g(k) = 5 – (k mod 5)
Probes 1 1 1 2 1 2

Searching and sorting Techniques in Data structures

Searching and sorting Techniques in Data structures

More Related Content

Similar to Searching and sorting Techniques in Data structures

Recently uploaded

Searching and sorting Techniques in Data structures