Up to date

class ArrayOperations {     int[] array;     static int size;     void swap(int a, int b) {         array[a] = array[a] + array[b];         array[b] = array[a] - array[b];         array[a] = array[a] - array[b];     }     void displayArray() {         Arrays.stream(array).forEach(num -> System.out.print(num + " "));         System.out.println();     }     void displaySortedArray() {         for(int i = 0; i <= size; i++) {             System.out.print(array[i] + " ");         }         System.out.println();     }     int get(int index) {         if(index >= 0 && index < array.length) {             return array[index];       ...

 Code :  class BinarySearch {     private int[] array;     int binarySearch_iterative (int low, int high, int key) {         while (low <= high){             int mid = (low+high)/2;             if(array[mid] == key) {                 return mid; // serach successful             } else if(key < array[mid]) {                 high = mid - 1;             } else {                 low = mid + 1;             }         }         return -1; // search unsuccessful     }     int binarySearch_recursive (int low, int high, int key) {         if(low <= high) {           ...

 class LinearSearch {     int[] array;     // Linear search : Time Complexity O(n) and Space Complexity O(1)     int search(int key) {         for(int i = 0; i < array.length; i++) {             if(array[i] == key) {                 return i;             }         }         return -1;     }     // Transposition Method : Time Complexity O(n) and Space Complexity O(1)     int search_improved_transposition (int key) {         for(int i = 0; i < array.length; i++) {             if(array[i] == key) {                 if(i > 0) {                     int temp = array[i-1];               ...

 1. Linear Search 2. Binary Search

 class TowerOfHanoi {     // Time Complexity O(n) and Space Complexity O(1)     void tower_recursive(int numberOfDisks, int sourceTower, int additionalTower, int destinationTower) {         if(numberOfDisks > 0){             tower_recursive(numberOfDisks - 1, sourceTower, destinationTower, additionalTower);             System.out.println("Moving disk from tower " + sourceTower + " to " + destinationTower);             tower_recursive(numberOfDisks - 1, additionalTower, sourceTower, destinationTower);         }     } public static void main (String[] args) {     TowerOfHanoi obj = new TowerOfHanoi();     obj.tower_recursive(3, 1, 2, 3); } }

  class NCR {     // Time Complexity O(n) and Space Complexity O(1)     int nCr (int n, int r) {         // Formula n!/(r!*(n-r)!)         int factorialN = factorial(n);         int factorialR = factorial(r);         int factorialNMinusR = factorial(n-r);         return factorialN / (factorialR * factorialNMinusR);     }         // Time Complexity O(n) and Space Complexity O(n)     int nCr_pascalTriangle (int n, int r) {         if(r == 0 || n == r) {             return 1;         }         return nCr_pascalTriangle(n-1, r-1) + nCr_pascalTriangle(n-1, r);     }     // Time Complexity O(n) and Space Complexity O(1)     int factorial (int n) {         if(n <= 1) { //To return 1st ...

 class FibonacciSeries {     int[] dp;     // Time Complexity O(2^n) and Space Complexity O(n)     int fibonacci_recursive (int n) {         if(n <= 1) { //To return 1st and 2nd term             return n;         }         return fibonacci_recursive(n-2) + fibonacci_recursive(n-1);     }     // Time Complexity O(n) and Space Complexity O(n)     int fibonacci_recursive_memoization (int n) {         if(n <= 1) { //To return 1st and 2nd term             return n;         }         if(dp[n-2] == -1) {             dp[n-2] = fibonacci_recursive(n-2);         }         if(dp[n-1] == -1) {             dp[n-1] = fibonacci_recursive(n-1);    ...

class TaylorSeries {     int powerOfX;     int factorialOfN;     double result;     // Time Complexity O(n) and Space Complexity O(n)     double taylor_recursive (int x, int n) {         if(x <= 0 || n < 0) { // Corner case             return -1;         }         if(n == 0) {              return 1;         }         double result = taylor_recursive(x, n - 1);         powerOfX *= x;         factorialOfN *= n;         return (double)powerOfX / factorialOfN + result;     }          // Time Complexity O(n) and Space Complexity O(1)     double taylor_iterative (int x, int n) {         if(x <= 0 || n < 0) { // Corner case       ...

 // Time Complexity O(n) and Space Complexity O(n) int pow_recursive (int m, int n) {     if(n == 0) {         return 1;     }     return pow_recursive(m, n - 1) * m; } // Time Complexity O(n/2) and Space Complexity O(n) int pow_recursive_improved(int m, int n) {     if(n < 0) {        return 0;     }     if(n == 0) {         return 1;     }     if(n % 2 == 0) { // Even         return pow_recursive_improved(m*m, n/2);     }     return m * pow_recursive(m*m, (n - 1) / 2); } // Time Complexity O(n) and Space Complexity O(1) int pow_iterative(int m, int n) {     if(n < 0) {         return 0;     }     if(n == 0) {         return 1;     }     int result = 1;     for(int i = 0; i < n; i++) {   ...

 0! = 1 1! = 1 //Time complexity O(n) and Space complexity O(n) int factorial_recursive(int n) {     if(n < 0) {          return 0;     }     if(n == 0) {         return 1;     }     return factorial_recursive(n - 1) * n; }    //Time complexity O(n) and Space complexity O(1) int factorial_iterative(int n) {     if(n < 0) {         return 0;     }     if(n == 0) {         return 1;     }     int result = 1;     for(int i = 1; i <= n; i++) {         result *= i;     }     return result; }

//Time complexity O(n) and Space complexity O(n) int sum_recursive(int n) {     if(n == 0) {         return 0;     }     return sum_recursive(n - 1) + n; } //Time complexity O(n) and Space complexity O(1) int sum_iterative(int n) {     int sum = 0;     for(int i = 1; i <= n; i++) {         sum += i;     }     return sum; }      //Time complexity O(1) and Space complexity O(1) int sum_usingFormula(int n) {     return n * (n + 1) / 2; }

 1. Tail Recursion : Function call itself is the last statement. Operations perform at calling time of the recursion. // Time complexity O(n) & Space complexity O(n) void tail_recursion(int n) {          if(n > 0) {             System.out.print(n + " ");             tail_recursion(n - 1);         }     } // Time complexity O(n) & Space complexity O(1) void tail_recursion_iterative(int n) {         System.out.println();         while(n > 0) {             System.out.print(n + " ");             n--;         }     } 2. Head Recursion : Function call itself is the first statement. Operations perform at returning time of the recursion. //Time complexity O(n) & Space complexity O(n) void head_recursion(int n) {     ...

 

 

 A program is a set of instructions that perform operations on data. When program is dealing with data, the way you organising the data in the main (RAM) memory is called data structures. Arrangement of collection of data items so that operations on the data can be done efficiently. More Elaboration : When you start a program that deal with some data stored in any storage (Hard disk, cloud storage etc), data is loaded into the main memory. The way data is organised into the main memory for performing the operations by the program is called data structures. Data structure is part of the running program. Physical Data Structures : Array (They had collection of contagious memory locations), LinkedList(Dynamic nodes connected to each others). Logical Data Structures : These can be created using physical data structures. Stack, Queue, Tree, Graph, Hash Table

Explanation Video Useful for representing resource allocation problem. Time Complexity = O(n^2) Java program /* package codechef; // don't place package name! */ import java.util.*; import java.lang.*; import java.io.*; /* MultiStageGraph to find rout of shortest path. This program can be     used to print shortest rout or sum of shortest path. */ class MultiStageGraph {     // Find shortest path     private static String findShortestPath() {         // Get input graph         int[][] graph = populateGraph();                  // Size of the graph         int size = graph.length;                  // Store the result         StringBuilder result = new StringBuilder("1");                  // Store cost of choosing particular rout     ...