Unit II_Searching and Sorting Algorithms.ppt

Unit II
Searching and Sorting Algorithms
Data Structures

Data Structure
• is a storage that is used to store and organize data. It is a way of arranging data on
a computer so that it can be accessed and updated efficiently.
• also used for processing, retrieving, and storing data

Algorithm
• a step-by-step process to solve a particular problem or accomplish a particular
task
• is correct if, for every input, it gives correct/expected output
• can represent an algorithm in simple English like sentences, as a computer
program or as a flowchart

Algorithm and Program
Algorithm
• comprises simple English like steps
usually written on paper before we
write the program
• machine-independent
• language independent
• write the algorithm during the
design time
Program
• conversion of these simple
English like steps into the
instruction set in a particular
programming language
• machine-independent
• language independent
• write the program during the
implementation time
• implementation of the algorithm
in a particular programming
language

Algorithm for sum of n
Int findSum(int n)
{
return n*(n+1)/2;
}
Int findSum(int n)
{
int sum = 0;
for int(i=1; i<=n; i++)
{
sum = sum+ i;
}
return sum;
}

Aspects of algorithm
• Designing
• Analyzing

Design an algorithm -
To find the factorial of a number
• Step1: START
• Step2: Declare integer variables num, factorial, i
• Step3: Initialize the variables as factorial←1 and i←1
• Step4: Input the value of num from the user
• Step5: Repeat the following steps until i=n
5.1 factorial ← factorial * i
5.2 i ← i + 1
• Step6: print factorial
• Step7: END

Analysis of an algorithm
• is an important part of computational complexity theory.
• predict the behavior of an algorithm without implementing.
• by analyzing different algorithms gives comparison and determines the best one
for the purpose.
• provides theoretical estimation for the required resources of an algorithm to
solve a specific computational problem.
• determination of the amount of time and space resources required to execute it.

Analysis of an algorithm
• To measure the efficiency of an algorithm
• For this, following criteria’s are used to measure the efficiency of the algorithm
• Running time of the algorithm
• Space/memory occupied by the algorithm
• analysis is only an approximation; it is not perfect

Efficiency of an algorithm
• Performance: How much time/memory is used when a program is run. This
depends on the machine, compiler, etc. as well as the code written.
• Complexity: How do the resource requirements of a program or algorithm scale,
i.e. what happens as the size of the problem being solved by the code gets larger.

Time complexity
• Amount taken by an algorithm to run
• Always depend upon input size
• Time taken by an algorithm to process the input determines the time complexity
• accurate running time is not done, rather, approximations are considered - this is
known as asymptotic analysis

Space complexity
• Amount of memory or space taken by an algorithm to run
• The memory required to process the input by an algorithm determines the space
complexity
• Space / complexity can be computed through two different approach –
i. Using iterative approach
ii. Using recursive approach

Iterative algorithm
• Repeating a certain number of steps continuously until a particular condition is
met successfully.
• The repeated execution of some groups of code statements in a program is
called iteration.
• Iterations can be an infinite number of times.
• Loops are tools provided by programming languages to implement iteration.

Iterative approach
• for loop
• while loop

Recursive algorithm
• calls itself with smaller input values and returns the result for the current input by
carrying out basic operations on the returned value for the smaller input.
• the given problem statement is separated into two parts. The first one is the base
case, and the second one is the recursive step
• Base Case: is the simplest instance of a problem, consisting of a condition that
terminates the recursive function. This base case evaluates the result when a
given condition is met.
• Recursive Step: computes the result by making recursive calls to the same
function, but with the inputs decreased in size or complexity.

Recursive approach
• Print sum of n natural numbers using recursion
• F(n) = 1 + 2 + 3 + 4 + …………..+ (n-2) + (n-1) + n

Recursive algorithm
• While performing recursion, we call the function again and again, which increases
the memory used by the program.
• stack as well comes along with it because recursion uses the stack for
implementation.
• Due to the usage of the stack in recursion, this program has space complexity of
the order ‘n’ i.e. linear order which is higher than constant order.

Difference between Recursion and Iteration

Types of Algorithm Analysis
1.Best case - Define the input for which algorithm takes less time or minimum
time. calculate the lower bound of an algorithm.
2.Worst case - Define the input for which algorithm takes a long time or maximum
time. In the worst calculate the upper bound of an algorithm.
3.Average case - take all random inputs and calculate the computation time for all
inputs. And then divide it by the total number of inputs.

Asymptotic Analysis
• Evaluates the performance of an algorithm in terms of input size , the actual
running time is not calculated but predicted.
• The time (or space) taken by an algorithm increases with the input size is
calculated.
• To have a measure of the efficiency of algorithms that don’t depend on machine-
specific constants and don’t require algorithms to be implemented and time
taken by programs to be compared.
• Mathematical tool to describe the running time of an algorithm in its input size.

Asymptotic notations
1.Omega Notation (Ω-notation)
2.Big-O Notation (O-notation)
3.Theta Notation (Θ-notation)

Asymptotic Analysis
• The running time of one operation is computed as f(n).
• And may be for another operation it is computed as g(n2).
• This means the first operation running time will increase linearly with the
increase in n and the running time of the second operation will increase
exponentially when n increases.
• Similarly, the running time of both operations will be nearly the same if n is
significantly small.

Omega (Ω) Notation
• represents the lower bound of the running time of an algorithm.
• The best amount of (less) time an algorithm takes to complete
• The algorithm takes more time to complete than this but not less than this
• It provides the information of minimum resources need to run the algorithm.

Big O (O) notation
• represents the upper bound of the running time of an algorithm.
• The longest amount of time an algorithm takes to complete.
• The algorithm takes less time to complete than this but not more than this.
• Provides the worst case analysis of an algorithm.

Theta (Ɵ ) notation
• represents both the upper and lower bound of the running time of an algorithm.
• Determines average amount of time an algorithm would take to complete.

• https://www.youtube.com/watch?v=xFRea6xyPgM
• https://freevideolectures.com/course/5003/nptel-design-analysis-
algorithms/8

Searching methods
• is an operation or a technique that helps finds the place of a given element or
value in the list.
• are designed to check for an element or retrieve an element from any data
structure where it is stored.
• is said to be successful or unsuccessful depending upon whether the element
that is being searched is found or not.
• standard techniques
• Sequential Search
• Interval Search

Linear Search
• simplest method for searching.
• defined as a sequential search algorithm.
• starts at one end and goes through each element of a list until the desired
element is found.
• otherwise the search continues till the end of the data set.

Linear Search
• Given an array arr[] of N elements, the task is to write a function to search a
given element x in arr[].
• Iterate from 0 to N-1 and compare the value of every index with x if they match
return index.

Steps for Linear Search
• Start from the leftmost element of arr[] and one by one compare x with each
element of arr[].
• If x matches with an element, return the index.
• If x doesn’t match with any of the elements, return -1.

Linear Search implementation in C

Binary search
• execution needs to compare the element to be searched with the present
element at the center of the list.
• If it matches, then the search is successful otherwise the list is divided into two
halves:
• one from the 0th element to the middle element which is the center element (first
half).
• another from the center element to the last element (which is the 2nd half) where
all values are greater than the center element.
• proceeds from either of the two halves depending upon whether the target
element is greater or smaller than the central element.
• If the element is smaller than the central element, then searching is done in the
first half, otherwise searching is done in the second half.

Binary search
• is a very fast and efficient searching technique.
• a searching algorithm used in a sorted array by repeatedly dividing the search
interval in half.
• The idea of binary search is to use the information that the array is sorted and
reduce the time complexity to O(Log n).

Binary search
• Begin with the mid element of the whole array as a search key.
• If the value of the search key is equal to the item then return an index of the
search key.
• Or if the value of the search key is less than the item in the middle of the interval,
narrow the interval to the lower half.
• Otherwise, narrow it to the upper half.
• Repeatedly check from the second point until the value is found or the interval is
empty.

Step-by-step Binary Search Algorithm
• Compare x with the middle element.
• If x matches with the middle element, we return the mid index.
• Else If x is greater than the mid element, then x can only lie in the right half
subarray after the mid element. So we recur for the right half.
• Else (x is smaller) recur for the left half.

Binary Search implementation in C

Binary Search implementation
#include <stdio.h>
// A recursive binary search function. It returns location of x in given array arr[l..r] is present, otherwise -1
int binarySearch(int arr[], int l, int r, int x)
{
if (r >= l) {
int mid = l + (r - l) / 2;
// If the element is present at the middle itself
if (arr[mid] == x)
return mid;
// If element is smaller than mid, then it can only be present in left subarray
if (arr[mid] > x)
return binarySearch(arr, l, mid - 1, x);
// Else the element can only be present in right subarray
return binarySearch(arr, mid + 1, r, x);
}
// We reach here when element is not present in array
return -1;
}

Binary Search implementation
// A iterative binary search function. It returns location of x in given array arr[l..r] if present, otherwise -1
int binarySearch(int arr[], int l, int r, int x)
{
while (l <= r) {
int m = l + (r - l) / 2;
// Check if x is present at mid
if (arr[m] == x)
return m;
// If x greater, ignore left half
if (arr[m] < x)
l = m + 1;
// If x is smaller, ignore right half
else
r = m - 1;
}
// if we reach here, then element was not present
return -1;
}

Example of Binary Search
int main(void)
{
int arr[] = { 2, 3, 4, 10, 40 };
int n = sizeof(arr) / sizeof(arr[0]);
int x = 10;
int result = binarySearch(arr, 0, n - 1, x);
(result == -1)
? printf("Element is not present in array")
: printf("Element is present at index %d", result);
return 0;
}

Linear Search and Binary Search

Time and Space complexity in Linear Search algorithm
• The time complexity of linear search algorithm is divided into three main cases.
• In the best-case scenario, the linear search algorithm performs O(1) operations.
• In the worst-case scenario, the linear search algorithm performs O(n) operations.
• When the element to be searched is in the middle of the array, the average case of the Linear
Search Algorithm is O(n).
• The linear search algorithm takes up no extra space; its space complexity is O(n) for an array of n
elements.

Time and Space complexity of Binary Search algorithm
• The time complexity of the binary search algorithm is O(log n).
• The best-case time complexity would be O(1) when the central index would directly match the
desired value.
• The worse case time complexity of the binary search T(n)= T(n/2)+1 is known as the recurrence
relation for binary search.
• The space complexity of the binary search algorithm depends on the implementation of the
algorithm.
• In the iterative method, the space complexity would be O(1).
• While in the recursive method, the space complexity would be O(log n).

Fibonacci search algorithm
• involves the Fibonacci Numbers.
• just like the Binary search method,
• a comparison-based searching algorithm
• based on the divide and conquer technique.
• works on an array that is sorted in the non-decreasing order.

Fibonacci Numbers
• a sequence of numbers where any term is equal to the sum of the previous two
terms i.e.,
• play a very important role in the information coding theory.
• are heavily used in various security coding algorithms.

Fibonacci search algorithm
• Find a Fibonacci number that is greater than or equal to the size of the given array in which key is
to be searched .
• If the size of the array is n then we must find a Fibonacci number Fk such that Fk >=n .
• Compute Fk-1, Fk-2, the of Fset , and the index value. The index is computed using the of Fset, n , and Fk-2.
• Compare the key with the element at index in the array. The outcomes will be:
• If the key and array element at index are equal then the key is at position index in the given
array, then return it and stop.
• If the key is less than the array element at index , then search the key in the left sub-tree to Fk-2 .
• If the given key is greater than the array element at index, then search the right sub-tree to Fk-2 .
• If the key is not found, repeat above steps as long as Fk-2 >=0. The Fibonacci number is greater
than the length of the array .
After each iteration the size of array n is reduced either by 2/3 or by 1/3 of the array.

Fibonacci search algorithm - Example
10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Smallest fibonacci number >=12 is 13

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Fk =13, Fk-1 = 8, Fk-2 = 5

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Fk =13, Fk-1 = 8, Fk-2 = 5
• Index = min((of Fset + Fk-2 ),n-1) = min((-1+5),11)=4

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Fk =13, Fk-1 = 8, Fk-2 = 5
• The element at index 4 in array is 67. Since 110> 47, we move one Fibonacci number down.

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Fk =13, Fk-1 = 8, Fk-2 = 5
• Iteration 2-
•

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Fk =13, Fk-1 = 8, Fk-2 = 5
• Iteration 2-
• Fk =8, Fk-1 = 5, Fk-2 = 3

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Fk =13, Fk-1 = 8, Fk-2 = 5
• Iteration 2-
• Fk =8, Fk-1 = 5, Fk-2 = 3
• Index = min((of Fset + Fk-2 ),n-1) = min((4+3),11)=7

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Fk =13, Fk-1 = 8, Fk-2 = 5
• Iteration 2-
• Fk =8, Fk-1 = 5, Fk-2 = 3

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Fk =13, Fk-1 = 8, Fk-2 = 5
• Iteration 2-
• Fk =8, Fk-1 = 5, Fk-2 = 3
• Iteration 3-
•

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Fk =13, Fk-1 = 8, Fk-2 = 5
• Iteration 2-
• Fk =8, Fk-1 = 5, Fk-2 = 3
• Iteration 3-
• Fk =5, Fk-1 = 3 , Fk-2 = 2

10, 23, 34,45,67,89,97,101,110,145, 156, 169 find key 110.
• n=12, of Fset = -1
• Iteration 1-
• Fk =13, Fk-1 = 8, Fk-2 = 5
• Iteration 2-
• Fk =8, Fk-1 = 5, Fk-2 = 3
• Iteration 3-
• Fk =5, Fk-1 = 3 , Fk-2 = 2
• The element at index 9 in array is 110, return index and stop

Unit II_Searching and Sorting Algorithms.ppt

Space and Time Complexity of Fibonacci Search
• The Fibonacci Search scheme shrinks the starting search space by
either two-thirds or one-third in every iteration depending upon
whether the key is smaller than Fk-1 or is greater than it.
• On average, the search space is reduced by 1/3, so n/3k =1 or n=3k
• k=log(n)

Space and Time Complexity of Fibonacci Search
• Best Case: Time complexity of the the Fibonacci search is O(1). We’ll
find this case when the search key is the first element we start
comparing.
• Worst Case: for the Fibonacci search method occurs when the key is
always present in the larger subarray. Its worst-case time complexity
is O(log n).
• Average Case: shrink the search space by 1/3, so the average case
time complexity of the Fibonacci search algorithm is O(log n).
• Fibonacci search has O(1) space complexity because no extra space
other than temporary variables is used.

Sorting methods
• Sorting - A method to rearrange a given array or list of elements in
according to a comparison operator on the elements.
• An in-place sorting algorithm uses constant space for producing the
output.
• It sorts the list only by modifying the order of the elements within the
list.

Sorting
• Types of Sorting
• Internal Sorting - all data is placed in the main
memory or internal memory
• External Sorting - all data that needs to be sorted cannot be
placed in memory at a time
• Sort Stability
• Stable Sort - two same data appear in the same order in sorted
data
• Unstable Sort - two same data appear in the different order in
sorted data

Bubble Sort
• one of the simplest algorithms.
• repeatedly iterates through the list.
• compares the elements next to each other.
• swaps according to the condition passed to them.

Bubble Sort
// 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]);
printf("n");
}
// 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;
}

Bubble Sort
• This algorithm is not suitable for large data sets as its average and
worst-case time complexity is quite high.
• Time Complexity: O(N2)
• Auxiliary Space: O(1)

Insertion Sort
• a simple sorting algorithm.
• an in-place comparison-based sorting algorithm.
• a sub-list is maintained which is always sorted.
• an element which is to be 'insert'ed in this sorted sub-list, has to find
its appropriate place and then it has to be inserted there.
• the array is searched sequentially.
• unsorted items are moved and inserted into the sorted sub-list (in the
same array).

Insertion Sort
• not suitable for large data sets as its average and worst case
complexity are of Ο(n2), where n is the number of items.
• Auxiliary Space: O(1)

Selection sort algorithm
• a simple sorting algorithm.
• an in-place comparison-based algorithm in which the list is divided
into two parts,
• the sorted part at the left end.
• the unsorted part at the right end.
• Initially, the sorted part is empty and the unsorted part is the entire
list.
• The smallest element is selected from the unsorted array and
swapped with the leftmost element, and that element becomes a
part of the sorted array.
• This process continues moving unsorted array boundary by one
element to the right.

Selection sort algorithm
• This algorithm is not suitable for large data sets.
• Its average and worst case complexities are of Ο(n2), where n is the
number of items.

Merge sort
• a sorting algorithm that is based on the Divide and
Conquer paradigm.
• the array is initially divided into two equal halves and then they are
combined in a sorted manner.
• a recursive algorithm continuously splits the array in half until it
cannot be further divided.

Merge Sort algorithm
• with worst-case time complexity being Ο(n log n), it is one of the
most respected algorithms.
• requires an additional memory space of 0(n) for the temporary array.

Quick sort
• a highly efficient sorting algorithm.
• based on partitioning of array of data into smaller arrays.
• A large array is partitioned into two arrays one of which holds values
smaller than the specified value, say pivot, based on which the
partition is made and another array holds values greater than the
pivot value.

Quick sort
• This algorithm is quite efficient for large-sized data sets as its average
and worst-case complexity are O(n2), respectively.
• has a space complexity of O(logn).

Pseudo code
• Pseudocode is a way of expressing an algorithm without conforming
to specific syntax rules.
• No broad standard for pseudocode syntax exists.
• Pseudocode resembles skeleton programs, which can be compiled
without errors.

Comparison of Sorting algorithms

Unit II_Searching and Sorting Algorithms.ppt

Recommended

More Related Content

Similar to Unit II_Searching and Sorting Algorithms.ppt (20)

More from HODElex (7)

Recently uploaded (20)

Unit II_Searching and Sorting Algorithms.ppt