//Array

Selection Sort     Selection sort algorithm sorts an array by reapetly finding  the minimum element (considering ascending order) from unsorted port and putting it at the beginning. Complexity of Selection Sort: Time Complexity Best Case: O(n2) Worst Case: O(n2) Space Complexity Worst Case: O(1) Advantages of Selection Sort Selction sort algorithm easy to implement. No additional data-structure is required. It is in-place sorting method & stable method. The number of swap reduced.O(n) swap  in all cases. Disadvantages of Selction Sort Best & Worst case efficiency is O(n2). CODE 👇 #include <stdio.h> int comp_cnt=0; int main() { int a[20], n , i; printf("\t>>Selection Sort<<\n"); printf("How many numbers you want in array ?\t"); scanf("%d",&n); printf("\nEnter %d element:",n); accept(a,n); selection_sort(a,n); printf("\t>>Sorted Array<<\n"); display(a,n); printf("\nTotal

Binary Search The method is based on the Divide-Conquer algorithmic strategy. Precondition For Binary Search Data must be organized in a linear way. Data has to be in the sorted oder in either ascending or decending order. Advantages of Binary Serach Worst case time complexity is O(log2n), which is very efficient compared to linear search O(n). Disadvantages of Binary  Search Data has to be in sorted order. Complexity of Binary Search Best Case :-The key is found at the middle position after 1 comparision.                       -The best case time complexity is  Ω(1). Worst Case :-The Worst case time complexity is O(log2n). CODE 👇 #include <stdio.h> int main() {        int first, middle,last, n, i, search, a[100];        setbuf(stdout, NULL);        printf("ENTER THE SIZE OF ARRAY:");        scanf("%d", &n);        printf("ENTER %d ELEMENT IN ASCENDING ORDER:\n",n);        for(i=0; i<n; i++)             scanf("%d", &a[i]);      

  Linear Search It is also Called as "Sequential Search". This is simplest method. It can be applied to sequential storage structure like files, array, or linked list. Advantages of Linear Search It is very simple method. It does not require the data to be sorted. It does not require any additional data structure. Disadvanatges of Linear Search If  'n' is very large, this method is very in efficient and slow. It's worst case complexity O(n). Analysis of sequential search Best Case : -The best case  occurs when the key is found at the first position i.e at index 0.                       -The best case time complesxity  Ω (1).   Worst Case :-The case occurs when the key is not found in array.                         -The worst case time complexity O(n). Average Case :-Average comparisons = n(n+1)/2n = (n+1)/2.                              -The average case time complexity of this method is O(n). CODE 👇 #include <stdio.h> int linear_search(int a[10], int n, in

Radix Sort: Radix sort algorithm requires the number of passes which  are equal to the number of digits present in the largest number among the list of numbers . For example, if the largest number is a 3 digit number then that list is sorted with 3 passes. Example: Original, unsorted list: 170, 45, 75, 90, 802, 24, 2, 66 Sorting by least significant digit (1s place) gives:  [*Notice that we keep 802 before 2, because 802 occurred  before 2 in the original list, and similarly for pairs  170 & 90 and 45 & 75.] 170, 90, 802, 2, 24, 45, 75, 66 Sorting by next digit (10s place) gives:   [*Notice that 802 again comes before 2 as 802 comes before  2 in the previous list.] 802, 2, 24, 45, 66, 170, 75, 90 Sorting by the most significant digit (100s place) gives: 2, 24, 45, 66, 75, 90, 170, 802 Advantages 1. Fast when the keys are short i.e. when the range of the array elements is less. 2. Used in suffix array constuction algorithms like Manber's algorithm and DC3 algorithm. Disadvan

  Counting Sort Counting sort is a sorting algorithm that sorts the elements of an array by counting the number of occurrences of each unique element in the array. Advantages of Counting Sort: Counting sort generally performs faster than all comparison-based sorting algorithms, such as merge sort and quicksort, if the range of input is of the order of the number of input. Counting sort is easy to code. Disadvantages of Counting Sort: Counting sort doesn’t work on decimal values. Counting sort is inefficient if the range of values to be sorted is very large. Complexity: Best :       O(n+k) Worst: O(n+k) Average: O(n+k) Space : O(max) Stability Yes CODE: #include <stdio.h> void  countingsort( int  a[],  int  k,  int  n); void  main() { int  n, i, k=0, a[15]; printf( "How many element in array:" ); scanf( "%d" , &n); printf( "\n Enter the element for array:" ); for( i=1; i<=n; i++) { scanf( "%d" ,  &a[i]);

Quick Sort Quicksort is an in-place sorting algorithm which means it doesn't take an additional array to sort the data. It uses the same array to sort the elements. Advantages; The quick sort is regarded as the best sorting algorithm. It is able to deal well with a huge list of items. Because it sorts in place, no additional storage is required as well Disadvantages: The slight disadvantage of quick sort is that its worst-case performance is similar to average performances of the bubble, insertion or selections sorts. If the list is already sorted than bubble sort is much more efficient than quick sort If the sorting element is integers than radix sort is more efficient than quick sort. Complexity of the Quick Sort Algorithm; Data structure: Array Worst-case time complexity: O(n2) Average-case time complexity Θ(nlogn) Best-case time complexity:            Ω(nlogn) Worst-case space complexity: O(logn) CODE: #include <stdio.h> void  quicksort( int  a[20],  int  low,  in

 Mergesort Merge sort is a recursive algorithm based on Divide-and-Conquer. The algorithm divides the unsorted list into n sublists, recursively, until all sublists are of length one, which is considered already sorted. The algorithm compares and repeatedly merge sublists to produce sorted sublists by calling the merge function, this is done until the sorted sublists merge into one final sorted list. Merge sort is preferred over quick sort when there is a large dataset, and/or stored in external storage. Example:   The merge sort procedure recursively divides the unsorted list into sublists of equal halves in a top-down manner, until sublists of length one. As the list recursively divides, the original order of the list is preserved. In the case of odd length, the list is divided into sublists of near-equal size, using round functions.                Input List:     [7, 6, 5, 4, 3, 2, 1]                                            /               \                                [7, 6