Merge branch 'branch2' of https://github.com/mukul314/DSA into branch2

.github/workflows/codespell.yml

@@ -11,4 +11,4 @@ jobs:
       - uses: actions/checkout@v2
       - uses: actions/setup-python@v2
       - run: pip install codespell
-      - run: codespell --ignore-words-list="ans,nnumber,nin" --quiet-level=2  --skip="**/**/package-lock.json"
+      - run: codespell --ignore-words-list="ans,nnumber,nin,Hel" --quiet-level=2  --skip="**/**/package-lock.json,./docs/pt,./docs/es,./docs/tr,./.github,./algorithms/CSharp/test"

.gitignore

@@ -11,6 +11,7 @@ Thumbs.db
 *.out
 *.class
 *.idea
+*.exe 
 
-
-
+# Visual Studio Code
+.vscode/

README.md

@@ -12,7 +12,11 @@
 Data structure and Algorithm (DSA)
 
 ## Explanations
+
 - [English](./docs/en)
+- [Español](./docs/es)
+- [Português](./docs/pt)
+- [Turkish](./docs/tr)
 - [繁體中文](./docs/zh-tw)
 - [日本語](./docs/ja)
 
@@ -116,12 +120,12 @@ The programming should keep the naming convention rule of each programming langu
 ## Reviewers
 
 | Programming Language | Users                                                       |
-| -------------------- | ------------------------------------------------- |
-| C or C++             | @Arsenic-ATG, @UG-SEP, @aayushjain7, @Ashborn-SM  |
-| Java                 | @TawfikYasser, @aayushjain7                       |
+| -------------------- | ----------------------------------------------------------- |
+| C or C++             | @Arsenic-ATG, @UG-SEP, @aayushjain7, @Ashborn-SM, @Ashad001 |
+| Java                 | @TawfikYasser, @aayushjain7, @mohitchakraverty              |
 | C#                   | @ming-tsai, @Waqar-107                                      |
-| Go                   | @atin                                             |
-| Python               | @Arsenic-ATG, @atin, @sridhar-5                   |
+| Go                   | @ayo-ajayi                                                  |
+| Python               | @Arsenic-ATG, @sridhar-5                                    |
 | JavaScript           | @ming-tsai                                                  |
 
 ## Contributors

algorithms/C/README.md

@@ -5,7 +5,11 @@
 - [Even and Odd](arrays/even-and-odd.c)
 - [Unique Elements in an array](arrays/unique-elements-in-an-array.c)
 - [Reverse an array](arrays/reverse-array.c)
+- [Shuffle an array](arrays/shuffle_array.c)
 - [Maximum difference](arrays/maximum-difference.c)
+- [Largest Element](arrays/largestElement.c)
+- [Second Largest Element](arrays/secondLargestElement.c)
+- [Sieve of Eratosthenes](arrays/sieve-of-eratosthenes.c)
 
 ## Bit Manipulation
 
@@ -33,12 +37,18 @@
 
 - [Palindrome Number](maths/palindrome.c)
 - [Fibonacci Series](maths/fibonacci-series.c)
+- [Odd or Even Number](maths/odd-or-even-number.c)
+- [Fibonacci Number](maths/fibonacci-number/README.md)
 
 ## Queues
 
 - [Double Ended Queue using array](queues/double-ended-queue-using-array.c)
 - [Circular Queue using array](queues/circular-queue-using-array.c)
 
+## Recursion
+
+- [Tower of Hanoi](recursion/tower-of-hanoi.c)
+
 ## Sorting
 
 - [Bubble Sort](sorting/bubble-sort.c)
@@ -47,6 +57,9 @@
 - [Heap Sort](sorting/heap-sort.c)
 - [Selection Sort](sorting/selection-sort.c)
 - [Quick Sort](sorting/quick-sort.c)
+- [Shell Sort](sorting/shell-sort.c)
+- [Radix Sort](sorting/radix-sort.c)
+- [Bogo Sort](sorting/bogo-sort.c)
 
 ## Strings
 

algorithms/C/arrays/largestElement.c

@@ -0,0 +1,62 @@
+/******************************************************************************
+            Program to compute the largest element in array
+******************************************************************************/
+#include<stdio.h>
+#define maxSize 100
+
+int main()
+{
+    int array[maxSize], size;
+    int max;
+    
+    // Scanning the size of the array
+    printf("Enter the size of the array: ");
+    scanf("%d",&size);
+
+    // Scanning the elements of array
+    printf("Enter the %d elements of the array: \n",size);
+    for(int i=0; i<size; i++)
+    {
+        printf("Element [%d]: ",i);
+        scanf("%d",&array[i]);
+    }
+
+    // Printing the array
+    printf("The input array: \n");
+    for(int i=0; i<size; i++)
+    {
+        printf("%d ", array[i]);
+    }
+
+    // Assigning the first element of the array to max variable
+    max = array[0];
+
+    // Checking for elements maximum than value of max variable
+    for(int i=1; i<size; i++)
+    {
+        if(array[i] > max)
+        {
+            max = array[i];
+        }
+    }
+
+    // Printing out the result
+    printf("\nThe largest element of the array: %d",max);
+    
+    return 0;
+}
+
+/******************************************************************************
+                              OUTPUT SAMPLE
+Enter the size of the array: 5
+Enter the 5 elements of the array: 
+Element [0]: 1
+Element [1]: 2
+Element [2]: 3
+Element [3]: 4
+Element [4]: 6
+The input array: 
+1 2 3 4 6 
+The largest element of the array: 6
+
+******************************************************************************/

algorithms/C/arrays/secondLargestElement.c

@@ -0,0 +1,38 @@
+//Second largest element in the array
+
+#include<stdio.h>
+#include<stdlib.h>
+
+int second(int arr[],int size)
+{
+    int max1=arr[0],max2;
+    for(int i=0;i<size;i++)
+    {
+        if(arr[i]>max1) //Find largest element in the array
+        {
+            max2=max1;
+            max1=arr[i];
+        }
+        else if (arr[i]>max2 && arr[i]<max1) // Find second largest element in the array
+        {
+            max2=arr[i];
+        }
+    }
+        printf("%d %d",max1,max2); // Print both first and second largest element in the array
+}
+
+int main()
+{
+    int arr[]={2,5,1,12,18,88,23,45,4}; // Initialize array
+    int size=sizeof(arr)/sizeof(int); // Calculate array size
+    second(arr,size);
+    return 0;
+}
+
+/*
+----------------Sample Output----------------
+> 88 45
+
+Time Compexity: O(n)
+Space compexity: O(1)
+*/

algorithms/C/arrays/shuffle_array.c

@@ -0,0 +1,54 @@
+/*
+
+[PROBLEM]: Given an array, of size n, shuffle it.
+
+[TIME COMPLEXITY]: O(N)
+
+[SAMPLE OF OUTPUT]:
+
+Before shuffling:
+1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 
+After shuffling:
+9 6 4 10 11 15 5 3 12 1 7 14 2 8 13 
+
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+void swap(int *a, int *b) // Swap values between *a and *b
+{
+    int tmp = *a;
+    *a = *b;
+    *b = tmp;
+}
+
+void shuffle(int *array, int size) // Randomly shuffles given array
+{
+    for (int i = 0; i < size; i++) {
+        swap(array + i, array + (rand() % size)); // Each element swaps with another random element
+    }
+}
+
+void print_array(int *array, int size) // Printing array
+{
+    for (int i = 0; i < size; i++) {
+        printf("%d ", array[i]);
+    }
+    putchar('\n');
+}
+
+int main()
+{
+    srand(time(NULL)); // Setup of random seed for random generation
+    int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15};
+    printf("Before shuffling:\n");
+    print_array(array, 15);
+
+    shuffle(array, 15);
+    printf("After shuffling:\n");
+    print_array(array, 15);
+
+    return 0;
+}

algorithms/C/arrays/sieve-of-eratosthenes.c

@@ -0,0 +1,161 @@
+#include <stdio.h>
+
+#define MAX 1000001
+int sieve[MAX];
+
+/*
+
+    Why do we use such a big number? Because we don't know how big the interval is, 
+    we give as much freedom as possible; note that this number may not work for your 
+    computer, and you will need to make it smaller, or if it works, you can make it bigger.
+
+*/
+
+
+/*
+
+[PROBLEM TO SOLVE]: Given a number "n", find all prime numbers till "n" inclusive.
+
+    A prime number is a number which has only 2 divisors: 1 and itself.
+
+[EXAMPLE]: n = 22
+
+    -> The numbers are: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22
+
+    -> The prime numbers are: 2 3 5 7 11 13 17 19
+
+[APPROACH]: Sieve Of Eratosthenes algorithm
+
+[IDEA]:
+
+    -> We have to analyze numbers from 2 to n. So, firstly, we write them down:
+
+    2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ... n
+
+    -> Next, we will do something which is called marking. To illustrate this, I will put "*" below the numbers.
+
+    -> We begin from 2 till n, and for every number, we mark all its multiples till n inclusive.
+
+    -> We are at 2, so we mark 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26 and all numbers 2 * k, with k > 1 and stop when 2 * k > n.
+
+    2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ... n
+        *   *   *   *     *     *     *     *     *     *     *     *
+
+    -> We move at 3 so we mark 6, 9, 12, 15, 18, 21, 24 and all numbers 3 * k, with k > 1 and stop when 3 * k > n.
+
+    2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 ... n
+        *   *   * * *     *     *  *  *     *     *  *  *     *     *
+
+    -> We continue this process by taking every number till n and marking all its multiples till n inclusive.
+
+    -> By the end of this algorithm, the numbers that remained unmarked are only prime numbers.
+
+[TIME COMPLEXITY]:
+
+    For every i till sqrt(n), we perform n / i operations, where i is prime.
+
+    The ecuation is:
+    sqrt(n) * (n/3 + n/4 + n/5 + n/6 + n/7 + ...)
+    = sqrt(n) * n * (1/3 + 1/4 + 1/5 + 1/6 + 1/7 + ...)
+    The third factor, according to Euler, grows the same as ln(ln(n))
+
+    So the time complexity is: O(sqrt(n) * n * ln(ln(n))).
+
+[SPACE COMPLEXITY]: O(n)
+
+*/
+
+
+void sieve_of_eratosthenes(unsigned long long n)
+{
+    sieve[0] = sieve[1] = 1; // we know that 0 and 1 are already pries so we mark them
+
+    for (unsigned long long i = 4; i <= n; i += 2) sieve[i] = 1; // We know that every even number greater than 2 is not prime.
+                                                                // We can mark in advance these numbers by beginning from 4 and 
+                                                               // iterating from 2 to 2.
+
+    for (unsigned long long i = 3; i * i <= n; i += 2) // it is enough to iterate till sqrt(n)
+    {
+        // marking numbers
+        for (unsigned long long j = i * i; j <= n; j += 2 * i) sieve[j] = 1; // We can begin from i * i because all numbers till i * i have been already marked
+                                                                            // We iterate with j += 2 * i to avoid even numbers marked before 
+    }
+
+    /*
+        In Sieve of Eratosthenes, we use a global array, and global variables are
+        automatically initialized with 0. So we use that to our advantage instead of 
+        manually setting all memory spaces with 0.
+
+
+        We are doing marking like this:
+            0 - prime
+            1 - not prime
+
+
+        Why? I know that using 1 for primes and 0 for not primes would have been more
+        intuitive, but declaring an array in global scope, it got initialized with 0, so
+        it is just a waste to overwrite all memory spaces with 1.
+
+    */
+}
+
+
+// Utility function to print prime numbers
+void print_prime_numbers(unsigned long long n)
+{
+    for (unsigned long long i = 2; i <= n; ++i)
+    {
+        if (sieve[i] == 0) printf("%llu ", i); // if number is not marked (it is a prime number) we print it
+    }
+}
+
+
+// Driver program
+int main()
+{
+    unsigned long long n; printf("Enter number: ");  scanf("%llu", &n);
+    sieve_of_eratosthenes(n);
+
+    printf("\n\nPrime numbers are:\n");
+    print_prime_numbers(n);
+    printf("\n");
+}
+
+
+/*
+
+    [SAMPLE INPUT 1]: 
+    22
+    Output: 2 3 5 7 11 13 17 19
+
+    [SAMPLE INPUT 2]:
+    46
+    Output: 2 3 5 7 11 13 17 19 23 29 31 37 41 43
+
+    [SAMPLE INPUT 3]:
+    100
+    Output: 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 53 59 61 67 71 73 79 83 89 97
+
+*/
+
+
+/*
+
+[OBSERVATIONS]:
+
+    -> Note that I used unsigned long long for variables, and operations like raising to power can
+       easily exceed unsigned long long, so be careful with input numbers.
+
+    -> You can play around with #define MAX 1000000001 and #define MAX_PRIMES 100000001. Try to find
+       which is the maximum limit accepted by your computer.
+
+    -> To make this algorithm space-efficient, you can change to C++ and use a vector container from the STL library like
+       this [vector <bool> vector_name]. Before that, include vector library like #include <vector>. That
+       container is not a regular one. It is a memory-optimization of template classes like vector <T>,
+       which uses only n/8 bytes of memory. Many modern processors work faster with bytes because they
+       can be accessed directly. Template class vector <T> works directly with bits. But these things 
+       require knowledge about template classes, which are very powerful in C++.
+
+    -> This algorithm can be optimized using bits operations to achieve linear time.
+       But ln(ln(n)) can be approximated to O(1).
+*/

algorithms/C/maths/fibonacci-number/.gitignore

@@ -0,0 +1,4 @@
+main
+# binary files
+*.o
+*.exe 

algorithms/C/maths/fibonacci-number/Makefile

@@ -0,0 +1,4 @@
+run: main.c
+	.\a.exe
+main.c:
+	gcc .\src\main.c .\src\fib.c -lm

algorithms/C/maths/fibonacci-number/README.md

@@ -0,0 +1,59 @@
+# Fibonacci Number
+Fibonacci numbers form a Fibonacci sequence where given any number (excluding first 2 terms) is a sum of its two preceding numbers. Usually, the sequence is either start with 0 and 1 or 1 and 1. Below is a Fibonacci sequence starting from 0 and 1:
+
+$$
+0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, \dots
+$$
+
+The problem is to calculate the n-th term Fibonacci number given two starting numbers.
+
+## Prerequisites
+- C compiler (or IDE)
+- MAKE software (optional if you compile the source files manually)
+
+
+## Instructions
+- using makefile
+  ```bash
+   make # or mingw32-make
+  ```
+- compile using gcc
+  ```
+  cd <path>\fibonacci-number
+  gcc .\src\main.c
+  ```
+## Note
+The sequence can be described by a recurrent function as below:
+
+$$
+\begin{align*}
+  F(0) &= 0 \\
+  F(1) &= 1 \\
+  F(n) &= F(n-1) + F(n-2)
+\end{align*}
+$$
+
+- This provides a direct recursive implementation. The time complexity is $O(2^n)$. It can be improved through memomization.
+- It can done iteratively using 2 more states variables. The time complexity is $O(n)$.
+- There exists a clever logarithmic algorithm $O(\log{n})$ in computing n-th term Fibonacci number. The computations can be in form of matrix multiplication, then we can devise some form of Ancient Egyptian multiplication (i.e.: double and squaring) to improve the algorithm. [reference](https://rybczak.net/2015/11/01/calculation-of-fibonacci-numbers-in-logarithmic-number-of-steps/)
+- Lastly, there also exist a formula to approximate n-term Fibonacci number $O(1)$. [reference](https://mathworld.wolfram.com/BinetsFibonacciNumberFormula.html)
+
+The given implementations shall assume that the Fibonacci sequence is starting from 0 and 1. The reader may try to generalize it to certain extent as a practice.
+
+## Test Cases & Output
+
+1. Example output of calling function:
+```
+/* some code */
+printf("%d", iter_fib(7));
+printf("%d\n", memo_fib(7));
+/* some code */
+```
+
+```
+13
+13
+```
+2. The code should yield the same output as other version.
+
+3. The sum of even Fibonacci numbers below 4000000 should be 4613732. [Adapted from Project Euler.net](https://projecteuler.net/problem=2)

algorithms/C/maths/fibonacci-number/src/fib.c

@@ -0,0 +1,92 @@
+#include"./fib.h" // NOLINT(build/include)
+#include<math.h> // sqrt, pow are used in binet_fib
+
+int recur_fib(int n){
+	if(n == 0 || n == 1)
+		return n;
+	else
+		return recur_fib(n-1) + recur_fib(n-2);
+}
+int iter_fib(int n){
+	if(n == 0 || n == 1)
+		return n;
+	int prev2 = 0;
+	int prev1 = 1;
+	int res = prev1 + prev2;
+	for(n = n - 2; n > 0; --n){
+		prev2 = prev1;
+		prev1 = res;
+		res = prev1 + prev2;
+	}
+	return res;
+}
+
+// it should be called before using  the function memo_fib()
+void memomizing_fib(){ 
+	memomized_fib[0] = 0;
+	memomized_fib[1] = 1;
+	for(int i = 2; i < MAXSIZE; ++i)
+		memomized_fib[i] = memomized_fib[i-1]+memomized_fib[i-2];
+}
+
+// return memomized value if exists, or else compute it as usual
+int memo_fib(int n){ 
+	if(n < MAXSIZE && n >= 0)
+		return memomized_fib[n];
+	else
+		return memo_fib(n-1) + memo_fib(n-2);
+}
+/**
+ *  fibonacci based linear transformation (linear algebra)
+ *  reference: https://rybczak.net/2015/11/01/calculation-of-fibonacci-numbers-in-logarithmic-number-of-steps/
+*/
+int iter_log_fib(int n){
+	int a = 0;
+	int b = 1;
+	int p = 0;
+	int q = 1;
+	while(n > 0){
+		if(n%2 == 0){
+			int prev_p = p;
+			int prev_q = q;
+			p = prev_p*prev_p + prev_q*prev_q;
+			q = (2*prev_p + prev_q)*prev_q;
+			n = n/2;
+		}
+		else{
+			int prev_a = a;
+			int prev_b = b;
+			--n;
+			a = p*prev_a + q*prev_b;
+			b = q*prev_a + (p+q)*prev_b;
+		}
+	}
+	return a;
+}
+
+/**
+ *  fibonacci based linear transformation (linear algebra)
+ * 	reference: https://rybczak.net/2015/11/01/calculation-of-fibonacci-numbers-in-logarithmic-number-of-steps/
+*/
+int log_fib_helper(int n, int a, int b, int p, int q){
+	if(n == 0)
+		return a;
+	else if(n%2 == 0)
+		return log_fib_helper(n/2, a, b, p*p+q*q, (2*p+q)*q);
+	else
+		return log_fib_helper(n-1, p*a + q*b, q*a+(p+q)*b, p, q);
+}
+
+int log_fib(int n){
+	return log_fib_helper(n,0,1,0,1);
+}
+/**
+ * Closed form formula
+ * reference: https://mathworld.wolfram.com/BinetsFibonacciNumberFormula.html
+*/
+int binet_fib(int n){ 
+	const double golden_ratio = (1+sqrt(5))/2;
+	const double conjugate_golden_ratio = 1-golden_ratio;
+	double res = (pow(golden_ratio,n) - pow(conjugate_golden_ratio, n))/sqrt(5);
+	return round(res);
+}

algorithms/C/maths/fibonacci-number/src/fib.h

@@ -0,0 +1,23 @@
+
+#ifndef ALGORITHMS_C_MATHS_FIBONACCI_NUMBER_SRC_FIB_H_
+#define ALGORITHMS_C_MATHS_FIBONACCI_NUMBER_SRC_FIB_H_
+
+/**
+ * fib(n) takes nonnegative number n
+ * return n-th term fibonacci number.
+ * The prefix highlights its algorithm used
+ */
+
+int recur_fib(int n);
+int iter_fib(int n);
+
+#define MAXSIZE 30
+int memomized_fib[MAXSIZE];
+void memomizing_fib(); // it should be called before using  the function memo_fib()
+
+int memo_fib(int n);
+int iter_log_fib(int n);
+int log_fib(int n);
+int binet_fib(int n);
+
+#endif  // ALGORITHMS_C_MATHS_FIBONACCI_NUMBER_SRC_FIB_H_"

algorithms/C/maths/fibonacci-number/src/main.c

@@ -0,0 +1,23 @@
+#include<stdio.h>
+#include"./fib.h" // NOLINT(build/include)
+
+int main(){
+	memomizing_fib(); // this is to initialize the memomized table
+	int n = 15;
+	printf("%d\n", recur_fib(n)); // it becomes slow as n get larger for recur_fib
+	for(int i = 0; i <= 35; ++i){
+		printf("n = %d\t", i);
+		printf(" %d", iter_fib(i));
+		printf(" %d", memo_fib(i));
+		printf(" %d", log_fib(i));
+		printf(" %d", binet_fib(i));
+		printf(" %d\n", iter_log_fib(i));
+	}
+	int sum = 0;
+	int bound = 4000000;
+	for(int i = 0; memo_fib(i) < bound; ++i)
+		if(memo_fib(i)%2 == 0)
+			sum += memo_fib(i);
+	printf("The sum of even Fibonacci number below %d = %d", bound, sum);
+	return 0;
+}

algorithms/C/maths/odd-or-even-number.c

@@ -0,0 +1,32 @@
+/**
+     *This program checks if a number is odd or even.
+     * 
+     * Odd numbers are whole numbers that cannot be divided exactly by 2. If the number is not divisible by 2 entirely, 
+     * it'll leave a remainder 1.
+     * Even numbers are whole numbers that can be divided exactly by 2. If we divide the number by 2, it'll leave a remander 0.
+     * 
+     * Complexity -> O(1)
+     *    _______________________________
+     *   | INPUT | OUTPUT                |
+     *   |   2   | It's an even number!  |
+     *   |   1   | It's an odd number!   |
+     *   |   3   | It's an odd number!   |
+     *    _______________________________
+* */
+
+#include <stdio.h>
+
+int main()
+{
+    int n;
+    printf("Enter a number:\n");
+    scanf("%d", &n);
+    
+    if(n % 2 == 0 ){
+        printf("It's an even number!");
+    }else{
+        printf("It's an odd number!");
+    }
+
+    return 0;
+}

algorithms/C/recursion/tower-of-hanoi.c

@@ -0,0 +1,101 @@
+#include <stdio.h>
+/*
+	*Tower of Hanoi*
+
+	*Rule:
+	
+	1. Only one disk can be moved at a time.
+	2. Each move consists of taking the upper disk from one of the stacks 
+	   and placing it on top of another stack i.e. 
+	   a disk can only be moved if it is the uppermost disk on a stack.
+	3. No disk may be placed on top of a smaller disk.
+
+	* Time Complexity : O(2^n) 
+	* Space Complexity: O(n) 
+*/
+
+
+void towerOfHanoi(int disk, char from, char by, char to)
+{
+	if (disk == 1) // If the number of disks to move is one
+	{
+		printf("Move disk 1 from %c to %c \n", from, to);
+	}
+	else
+	{
+		towerOfHanoi(disk - 1, from, to, by);
+		printf("Move disk %d from %c to %c \n", disk, from, to);
+		towerOfHanoi(disk - 1, by, from, to);
+	}
+
+}
+
+int main()
+{
+	int disk;
+	
+	printf("Enter the number of disks you want : ");
+	scanf("%d", &disk);
+
+	// Move N disks of Tower A to Tower C via Tower B
+	towerOfHanoi(disk, 'A', 'B', 'C');
+	
+	return 0;
+}
+
+/*
+                                Sample
+
+                input             |                     output
+                                  |
+              disk : 3            |             Move disk 1 from A to C
+                                  |             Move disk 2 from A to B
+                                  |             Move disk 1 from C to B
+                                  |             Move disk 3 from A to C
+                                  |             Move disk 1 from B to A
+                                  |             Move disk 2 from B to C
+                                  |             Move disk 1 from A to C
+
+
+---------------------------------------------------------------------------
+
+
+                   **Image illustration for 3 disks**
+
+
+        standby                                         step 1
+
+    A      B      C                             A         B        C
+
+    |      |      |                             |         |        |
+    |      |      |                             |         |        |
+   ###(1)  |      |                             |         |        |
+  #####(2) |      |                           #####       |        |
+_#######(3)|______|__                       _#######______|_______###_
+
+
+
+         step 2                  step 3	                 step 4
+
+    A      B      C        A       B      C        A       B       C
+
+    |      |      |        |       |      |        |       |       |
+    |      |      |        |       |      |        |       |       |
+    |      |      |        |       |      |        |       |       |
+    |      |      |        |      ###     |        |      ###      |
+_#######_#####___###__  #######__#####____|___   __|_____#####__#######__
+
+
+
+         step 5                  step 6	                    step 7
+
+    A      B      C         A      B      C          A        B	       C
+
+    |      |      |         |      |      |          |	      |	       |
+    |      |      |         |      |      |          |        |        |
+    |      |      |         |      |      |          |        |	      ###
+    |      |      |         |      |    #####        |        |	     #####
+___###___#####_#######_	___###_____|___#######_    __|________|_____#######__
+
+
+*/

algorithms/C/sorting/bogo-sort.c

@@ -0,0 +1,83 @@
+/*
+[ALGORITHM]: Bogo sort - one of the most inefficient sorting algorithm 
+
+[PROBLEM]: Given an array, of size n, sort it.
+
+[TIME COMPLEXITY]: O(N * N!)
+
+[SAMPLE OF OUTPUT]:
+
+Before sorting:
+8 3 7 4 6 2 1 9 5 10 
+After sorting:
+1 2 3 4 5 6 7 8 9 10
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <time.h>
+
+void swap(int *a, int *b) // Swap values between *a and *b
+{
+    int tmp = *a;
+    *a = *b;
+    *b = tmp;
+}
+
+void shuffle(int *array, int size) // Randomly shuffles given array for further info check DSA/algorithms/C/arrays/shuffle_array.c
+{
+    for (int i = 0; i < size; i++) {
+        swap(array + i, array + (rand() % size));
+    }
+}
+
+bool is_sorted(int *array, int size) // If array is sorted (by non-reduction) return true, else false
+{
+    for (int i = 1; i < size; i++) {
+        if (array[i] < array[i - 1])
+            return false;
+    }
+    return true;
+}
+
+void bogo_sort(int *array, int size) // Until array is sorted randomly shuffles an array.
+{
+    while (!is_sorted(array, size))
+        shuffle(array, size);
+}
+
+void print_array(int *array, int size) // Printing array
+{
+    for (int i = 0; i < size; i++) {
+        printf("%d ", array[i]);
+    }
+    putchar('\n');
+}
+
+int main()
+{
+    srand(time(NULL)); // Setup of random seed for random generation
+    int array[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+    /*
+    Be accurate with size of array, sorting an array with 15 (for example) elements could
+    take unexpected amount of time.
+
+    For example:
+    Sorting 15 elements is 36036 times longer than sorting 10 elements.
+    So, if sorting 10 elements take half a second,
+    then sorting 15 elements approximately take 5 hours (in real could longer).
+    */
+
+    shuffle(array, 10); // Shuffling an array before sorting
+
+    printf("Before sorting:\n");
+    print_array(array, 10);
+
+    bogo_sort(array, 10);
+    printf("After sorting:\n");
+    print_array(array, 10);
+
+    return 0;
+}
+

algorithms/C/sorting/radix-sort.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+
+
+int get_max( int arr[], int n){
+
+    int myMax = -1 ;
+    for(int i=0; i<n; i++){
+        if(arr[i] > myMax)myMax = arr[i] ;
+    }
+
+    return myMax ;
+}
+
+void count_sort(int arr[], int n, int digit){
+    int count[10] = {0} ;
+    int *sorted ;
+    sorted = (int*)malloc(n * sizeof(int));
+
+    for(int i=0; i<n; i++){
+        count[(arr[i]/digit)%10]++ ;
+    }
+    for(int i=1; i<10; i++){
+        count[i] += count[i-1] ;
+    }
+
+    for(int i=n-1; i>=0; i--){
+        sorted[--count[(arr[i]/digit)%10]] = arr[i] ;
+    }
+
+    for(int i=0; i<n; i++){
+        arr[i] = sorted[i] ;
+    }
+}
+
+void radix_sort(int arr[], int n){
+
+    int myMax = get_max(arr,n) ;
+
+    for(int digit=1; myMax/digit; digit*=10){
+        count_sort(arr,n,digit) ;
+    }
+}
+
+int main() {
+    //                  :  The best :  The avg : The worst  : Space 
+    //       complexity :    O(kn)  :   O(kn)  :  O(kn)     :  O(d+n)
+
+	//         Stability :   Inplace    :      Comparison Sort 
+        //          Yes      :     Yes      :       No 
+
+    int arr[] = {374, 42, 6, 920,825} ;
+    int n = sizeof(arr)/sizeof(int) ;
+
+    printf("Before sorting : ") ;
+    for(int i=0; i<n; i++){
+        printf("%d ",arr[i] );
+    }
+
+    radix_sort(arr, n) ;
+
+    printf("\n\nAfter sorting : ") ;
+    for(int i=0; i<n; i++){
+        printf("%d ",arr[i] );
+    }
+    return 0;
+}

algorithms/C/sorting/shell-sort.c

@@ -0,0 +1,51 @@
+#include <stdio.h>
+
+// Shell Sort
+void ShellSort(int a[], int n)
+{
+    int i, j, k, temp;
+    // Rearrange elements at each n/2, n/4, n/8, ... intervals
+    for (i = n / 2; i > 0; i /= 2)
+    {
+        for (j = i; j < n; j++)
+        {
+            temp = a[j];
+            for (k = j; k >= i && a[k - i] > temp; k -= i)
+            {
+                a[k] = a[k - i];
+            }
+            a[k] = temp;
+        }
+    }
+}
+
+// Prints the array
+void printArray(int a[], int size)
+{
+    for (int i = 0; i < size; ++i)
+    {
+        printf("%d ", a[i]);
+    }
+}
+
+int main()
+{
+    int a[] = {64, 25, 12, 22, 11, 90};
+    int n = sizeof(a) / sizeof(a[0]);
+    printf("Array before sorting:\n");
+    printArray(a, n);
+    ShellSort(a, n);
+    printf("\nArray after sorting:\n");
+    printArray(a, n);
+    return 0;
+}
+
+/*
+Output:
+Array before sorting:
+64 25 12 22 11 90
+Array after sorting:
+11 12 22 25 64 90
+
+Time Complexity: O(n log n)
+*/

algorithms/CPlusPlus/Arrays/sparse_matrix.cpp

@@ -0,0 +1,96 @@
+/*Description :c++ solution to check if a given matrix is sparse matrix.
+If the count of zeroes present in the mmatrix is more than half the elements of the matrix, 
+it is flagged as a sparse matrix.
+Also the tuple form of the matrix(if the said matrix is sparse) is displayed.*/
+
+
+#include<iostream>
+using namespace std;
+
+int compactMatrix(int sparseMatrix[4][5])
+{
+	int size = 0;
+	for (int i = 0; i < 4; i++)
+		for (int j = 0; j < 5; j++)
+			if (sparseMatrix[i][j] != 0)
+				size++;
+
+	/* number of columns in compactMatrix (size) must be
+	   equal to number of non - zero elements in sparseMatrix */
+	int compactMatrix[size][3];
+
+	// Making of new matrix
+	int k = 0;
+	for (int i = 0; i < 4; i++)
+		for (int j = 0; j < 5; j++)
+			if (sparseMatrix[i][j] != 0)
+			{
+				compactMatrix[k][0] = i;
+				compactMatrix[k][1] = j;
+				compactMatrix[k][2] = sparseMatrix[i][j];
+				k++;
+			}
+  cout<<"The tuple form is:"<<endl;
+	for (int i=0; i<size; i++)
+	{
+		for (int j=0; j<3; j++)
+			cout <<" "<< compactMatrix[i][j];
+
+		cout <<"\n";
+	}
+	return 0;
+}
+
+int main () {
+   int sparseMatrix[4][5] =
+	{
+		{0 , 0 , 3 , 0 , 4 },
+		{0 , 0 , 5 , 7 , 0 },
+		{0 , 0 , 0 , 0 , 0 },
+		{0 , 2 , 6 , 0 , 0 }
+	};
+   int i, j, count = 0;
+   int row = 4, col = 5;
+   for (i = 0; i < row; ++i) {
+      for (j = 0; j < col; ++j){
+         if (sparseMatrix[i][j] == 0)
+         count++;
+      }
+   }
+   cout<<"The matrix is:"<<endl;
+   for (i = 0; i < row; ++i) {
+      for (j = 0; j < col; ++j) {
+         cout<<sparseMatrix[i][j]<<" ";
+      }
+      cout<<endl;
+   }
+   cout<<"The number of zeros in the matrix are "<< count <<endl;
+   if (count > ((row * col)/ 2))
+      {
+         cout<<"This is a sparse matrix"<<endl;
+         compactMatrix(sparseMatrix);
+      }
+   else
+   cout<<"This is not a sparse matrix"<<endl;
+   return 0;
+}
+
+
+
+
+/*output
+The matrix is:
+0 0 3 0 4 
+0 0 5 7 0 
+0 0 0 0 0 
+0 2 6 0 0 
+The number of zeros in the matrix are 14
+This is a sparse matrix
+The tuple form is:
+ 0 2 3
+ 0 4 4
+ 1 2 5
+ 1 3 7
+ 3 1 2
+ 3 2 6
+*/

algorithms/CPlusPlus/Dynamic-Programming/fibonacci.cpp

@@ -0,0 +1,34 @@
+/*
+Fibonacci series- 0,1,1,2,3,5,...
+Given a number n, we have to print the nth term of the fibonacci series
+Example- if n=0, the answer will be 0
+         if n=1, the answer will be 1
+         if n=1, the answer will be 1 (sum of 0 and 1)
+         if n=2, the answer will be 2 (sum of 1 and 1)
+         and so on..
+
+Time Complexity - O(n)
+Space Complexity - O(1)
+*/
+
+class Solution {
+public:
+    int fib(int n) {
+        
+        if(n<2)        // if n<2, i.e, if n is 0 or 1 return n because 0th term is 0 and 1th term is 1
+            return n;
+        
+        int prev1=1;  
+        int prev2=0;
+        
+        for(int i=2; i<=n; i++)
+        {
+            int curr = prev1+prev2;  // the current term is sum of the two terms before it, here prev1 is (i-1)th term and prev2 is (i-2)th term
+            prev2=prev1;
+            prev1=curr;
+        }
+        
+        return prev1;  //at the end prev1 will have the value of the nth term, so we will return it
+        
+    }
+};

algorithms/CPlusPlus/Graphs/cycle-detection.cpp

@@ -0,0 +1,87 @@
+// Program to detect whether a graph contains a cycle. The vertices of the graph are
+// placed in disjoint sets. As each edge is iterated through, the subset of the two
+// vertices is determined. If the subsets are the same, then a cycle is found.
+// Otherwise, the algorithm will join the two subsets together and repeat the process
+// until each edge is iterated through or a cycle is found.
+#include <algorithm>
+#include <iostream>
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+// Edge list implementation of unweighted, undirected graph
+class Graph
+{
+    private:
+    std::vector<std::pair<int, int>> edgeList;
+    std::unordered_set<int> uniqueVertices;  // Keep track of the number of unique vertices
+    
+    public:                                                                                
+    void insertEdge(int from, int to);
+    bool isCycle();
+    int findSet(std::vector<int>& parent, int i);
+    void unionSet(std::vector<int>& parent, int x, int y);                                          
+};
+
+void Graph::insertEdge(int from, int to)
+{
+    edgeList.push_back(std::make_pair(from, to));
+    uniqueVertices.insert(from);
+    uniqueVertices.insert(to);
+}
+
+bool Graph::isCycle()
+{
+    // Initialize parent vector as disjoint sets
+    std::vector<int> parent(uniqueVertices.size(), -1);
+    
+    // Iterate through all graph edges
+    for (auto i : edgeList)
+    {
+        // Find the subset of both vertices of an edge
+        int x = findSet(parent, i.first);
+        int y = findSet(parent, i.second);
+
+        // If the subsets are the same, then there is a cycle in the graph
+        if (x == y)
+        {
+            return true;
+        }
+
+        unionSet(parent, x, y);
+    }
+
+    return false;
+}
+
+int Graph::findSet(std::vector<int>& parent, int i)
+{
+    if (parent[i] == -1)
+    {
+        return i;
+    }
+    return findSet(parent, parent[i]);
+}
+
+void Graph::unionSet(std::vector<int>& parent, int x, int y)
+{
+    parent[x] = y;
+}
+
+// Sample test case
+// Time complexity is O(E) where E is the number of edges
+int main()
+{
+    Graph graph;
+    graph.insertEdge(0, 1);
+    graph.insertEdge(0, 2);
+    graph.insertEdge(1, 2);
+    if (graph.isCycle())
+    {
+        std::cout << "Graph contains a cycle" << std::endl;
+    }
+    else{
+        std::cout << "Graph does not contain a cycle" << std::endl;
+    }
+    return 0;
+}

algorithms/CPlusPlus/Graphs/floyd-warshall.cpp

@@ -0,0 +1,106 @@
+#include <bits/stdc++.h>
+
+using namespace std;
+const int N = 500, OO = 1e9;
+
+int dist[N][N];
+
+//Initialize the distance matrix with infinities to indicate that there is no edge between nodes
+void initialize_dist(int n) {
+    for (int i = 0; i < n; i++) {
+        for (int j = 0; j < n; j++) {
+            dist[i][j] = OO;
+            if (i == j) {
+                dist[i][j] = 0;
+            }
+        }
+    }
+}
+
+//Take Edge input and update the distance matrix
+void input(int m) {
+    for (int i = 0; i < m; i++) {
+        int a, b, c;
+        cin >> a >> b >> c;
+        dist[a][b] = c;
+        dist[b][a] = c;
+    }
+}
+
+//Perform Floyd-Warshall algorithm to calculate all shortest paths
+int floyd(int n) {
+    for (int k = 0; k < n; k++) {
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (dist[i][j] > dist[i][k] + dist[k][j]) {
+                    dist[i][j] = dist[i][k] + dist[k][j];
+                }
+            }
+        }
+    }
+}
+
+//Take queries and output the shortest distance for each query
+void output(int q) {
+    for (int i = 0; i < q; i++) {
+        int x, y;
+        cin >> x >> y;
+        cout << dist[x][y] << endl;
+    }
+}
+
+int main() {
+    int n, m, q;
+    cin >> n; // Number of nodes
+    initialize_dist(n);
+    cin >> m; // Number of edges
+    input(m);
+    floyd(n);
+    cin >> q; // Number of queries
+    output(q);
+    return 0;
+}
+
+/*
+Time Complexity: O(n^3)
+Memory Complexity: O(n^2)
+*/
+
+/*
+Example:
+    5 // Number of nodes
+    10 // Number of edges
+    0 1 5 // Edge from Node 0 to Node 1 with Weight 5
+    0 2 3
+    0 3 4
+    0 4 1
+    1 2 4
+    1 3 1
+    1 4 1
+    2 3 1
+    2 4 2
+    3 4 4
+    10 // Number of Queries
+    0 1 // Print Minimum Path between Nodes 0 and 1
+    0 2
+    0 3
+    0 4
+    1 2
+    1 3
+    1 4
+    2 3
+    2 4
+    3 4
+
+Output:
+    2 //Minimum path from 0 to 1
+    3 //Minimum path from 0 to 2
+    3 //Minimum path from 0 to 3
+    1 //Minimum path from 0 to 4
+    2 //Minimum path from 1 to 2
+    1 //Minimum path from 1 to 3
+    1 //Minimum path from 1 to 4
+    1 //Minimum path from 2 to 3
+    2 //Minimum path from 2 to 4
+    2 //Minimum path from 3 to 4
+ */

algorithms/CPlusPlus/Graphs/kruskal-algorithm.cpp

@@ -129,6 +129,14 @@ void KruskalMST(Graph* graph)
 		<< endl;
 }
 
+// Helper function which takes in src, dest, weight, index, address of graph as an argument 
+// to update the value of graph for respective index
+void updateGraph(int s, int d, int w, int idx, Graph** graph){
+	graph->edge[idx].src = s;
+	graph->edge[idx].dest = d;
+	graph->edge[idx].weight = w;
+}
+
 // Driver code
 int main()
 {
@@ -139,29 +147,19 @@ int main()
 	Graph* graph = createGraph(V, E);
 
 	// add edge 0-1
-	graph->edge[0].src = 0;
-	graph->edge[0].dest = 1;
-	graph->edge[0].weight = 10;
+	updateGraph(0, 1, 10, 0, &graph);
 
 	// add edge 0-2
-	graph->edge[1].src = 0;
-	graph->edge[1].dest = 2;
-	graph->edge[1].weight = 6;
+	updateGraph(0, 2, 6, 1, &graph);
 
 	// add edge 0-3
-	graph->edge[2].src = 0;
-	graph->edge[2].dest = 3;
-	graph->edge[2].weight = 5;
+	updateGraph(0, 3, 5, 2, &graph);
 
 	// add edge 1-3
-	graph->edge[3].src = 1;
-	graph->edge[3].dest = 3;
-	graph->edge[3].weight = 15;
+	updateGraph(1, 3, 15, 3, &graph);
 
 	// add edge 2-3
-	graph->edge[4].src = 2;
-	graph->edge[4].dest = 3;
-	graph->edge[4].weight = 4;
+	updateGraph(2, 3, 4, 4, &graph);
 
 
 

algorithms/CPlusPlus/Graphs/prim's_algorithm.cpp

@@ -0,0 +1,96 @@
+/*
+  PREREQUISITE --> 
+    1. GRAPH
+    2. PRIORITY QUEUE
+*/
+
+#include<bits/stdc++.h>
+using namespace std;
+
+vector<vector<pair<int,int>>> graph;
+vector<bool> vis;
+
+int primAlgorithm(){
+  int totalCost = 0;
+  // totalCost will store the minimum spanning tree 
+  set<pair<int,int>> pq; 
+  /*
+    here pq -> priority queue ( it sorts all elements )
+    it takes two value 
+      1. weight 
+      2. vertex
+
+    Here, priority queue will be sorted according to weight     
+  */
+
+
+  pq.insert({0,1});
+  /*
+    initialising the priority queue with {0,1}
+    Since, vertex 1 is the first vertex so we don't have to travel through a
+    edge to reach vertex 1
+  */
+
+  while( !pq.empty() ){
+    // taking the values of first elements from priority queue
+    int wt = (*pq.begin()).first; // weight of first vertex in priority queue
+    int v = (*pq.begin()).second; // first vertex
+    pq.erase(pq.begin());
+
+    if( vis[v] ) continue;
+    // if the vertex 'v' is visited then continue and don't proceed
+    vis[v] = true;
+    totalCost += wt;
+    // if the vertex is not visited then mark it visited
+    // and add the weight to total cost
+
+
+    // traverse all the child of vertex 'v'
+    for( auto elem : graph[v] ){
+      
+      if( vis[elem.first] ) continue;
+
+      // if child is visited then don't insert in priority queue
+      // else insert in priority queue
+      pq.insert({elem.second,elem.first});
+    }
+  }
+
+  graph.clear(); // clearing all values in graph
+  return totalCost;
+}
+
+int main()
+{
+  int n,e; cin>>n>>e;
+  // n -> number of vertex in graph
+  // e -> number of edges in graph
+
+  // initialising the graph
+  graph = vector<vector<pair<int,int>>> (n+1);
+
+  // initialising the visited vector to false 
+  // it represent if the vertex is visited or not
+  vis = vector<bool>(n+1,false);
+
+
+  // taking the input of 'e' edges
+  for(int i=0; i<e; i++)
+  {
+    int a,b,wt; cin>>a>>b>>wt;
+    /*
+      a,b -> vertexs of graph
+      wt -> weight of edge between vertex 'a' and 'b'
+    */
+
+    graph[a].push_back({b,wt});
+    graph[b].push_back({a,wt});
+    // it creates adjcency list by pushing all
+    // the vertexs(with weight) which are directly connected by edges.
+    
+  }
+
+  cout<<primAlgorithm();
+    
+  return 0;
+}

algorithms/CPlusPlus/Maths/binary-power.cpp

@@ -0,0 +1,56 @@
+#include<iostream>
+using namespace std;
+
+/*
+The idea is to half the power on every iteration
+Computes the power in log(n) operations
+
+On every iteration:
+Square the base, half the power
+
+Special case - if power is odd:
+Multiply the ans with a
+Because the ODD-NUMBER % 2 == 1
+
+Note: There will always be one iteration where power is odd
+*/
+
+long binpow(long a, long b){
+	long ans=1;
+	// while b is greater than zero, we continue the binary exponentiation
+	while(b>0){
+		// if b is odd, multiply result with base 
+		if(b&1)
+			ans *= a;
+		// square the base
+		a *= a;
+		// half the power
+		b /= 2;
+	}
+	return ans;
+}
+
+// source: @angshudas
+long binpow_rec(long a, long b){
+	// a^0 = 1 [for any a]
+	if(b==0)
+		return 1;
+	// recursive call for a^(b/2)
+	long ans = binpow_rec(a, b/2);
+	// square the result
+	ans *= ans;
+	// if b is odd, times by a
+	// to cover for 
+	if(b&1)
+		ans *= a;
+	
+	return ans;
+}
+
+int main(){
+	long base, power;
+	cout<<"Enter the base and power: "<<endl;
+	cin>>base>>power;
+	cout<<base<<" ^ "<<power<<" = "<<binpow(base, power)<<endl;
+	return 0;
+}

algorithms/CPlusPlus/Maths/factorial.cpp

@@ -4,8 +4,8 @@ A factorial of number 4 is calculated as:
 4 X 3 X 2 X 1 = 24
 
 Approach: Calculating factorial using for loop.
-Declaring the f varialbe to 1 (not initialising it to zero because any number multiplied by 0 will be 0)
-Multiplying the f variable to 1,2,3...n and storing it in the f varialbe.
+Declaring the f variable to 1 (not initialising it to zero because any number multiplied by 0 will be 0)
+Multiplying the f variable to 1,2,3...n and storing it in the f variable.
 The same factorial can be calculated using while loop, recursion.
 
 Time Complexity: O(number)

algorithms/CPlusPlus/Number-system/binary_addition.cpp

@@ -0,0 +1,85 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int reverse(int n){
+    int ans=0,d;
+    while(n>0){
+        d=n%10;
+        ans=ans*10 + d;
+        n=n/10;
+    }
+    return ans;
+}
+
+int binary_addition(int a,int b){
+    int add=0,carry=0;
+    while(a>0 && b>0){
+
+        if(a%2==1 && b%2==1){
+            add=add*10 + carry;
+            carry=1;
+        }
+        else if((a%2==1 && b%2==0) || (a%2==0 && b%2==1)){
+            if(carry==1){
+                add=add*10 + 0;
+                carry=1;
+            }
+            else{
+                add=add*10 + 1;
+                carry=0;
+            }
+        }
+        else{
+            add = add*10 + carry;
+            carry=0;
+        }
+        a=a/10;
+        b=b/10;
+    }
+    while(a>0){
+        if(a%2==1){
+            if(carry==1){
+                carry=1;
+                add=add*10+0;
+            }
+            else{
+                carry=0;
+                add=add*10 + 1;
+            }
+        }
+        else{
+            add=add*10 +carry;
+            carry=0;
+        }
+        a=a/10;
+    }
+    while(b>0){
+        if(b%2==1){
+            if(carry==1){
+                carry=1;
+                add=add*10+0;
+            }
+            else{
+                carry=0;
+                add=add*10 + 1;
+            }
+        }
+        else{
+            add=add*10 +carry;
+            carry=0;
+        }
+        b=b/10;
+    }
+    if(carry==1){
+        add=add*10 +1;
+    }
+    add=reverse(add);
+    return add;
+}
+
+int main(){
+    int a,b;
+    cin>>a>>b;
+    int add=binary_addition(a,b);
+    cout<<add;
+}

algorithms/CPlusPlus/Number-system/binary_to_decimal.cpp

@@ -0,0 +1,18 @@
+#include<bits/stdc++.h>
+using namespace std;
+int binarytodecimal(int n){
+    int two=1,r,num=0;
+    while(n>0){
+        r=n%10;
+        num=num + two*r;
+        two*=2;
+        n/=10;
+    }
+    return num;
+}
+int main(){
+    int n;
+    cin>>n;
+    int decimal=binarytodecimal(n);
+    cout<<decimal;
+}

algorithms/CPlusPlus/Number-system/decimal_to_binary.cpp

@@ -0,0 +1,24 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int decimaltobinary(int n){
+    int max=1;
+    while(max<=n){
+        max=max*2;
+    }
+    max/=2;             
+    int num=0;
+    while(max>=1){
+        num=num*10 + n/max;
+        n-=max*(n/max);
+        max=max/2;        
+    }
+    return num;
+}
+
+int main(){
+    int n;
+    cin>>n;
+    int binary=decimaltobinary(n);
+    cout<<binary;
+}

algorithms/CPlusPlus/Number-system/decimal_to_hexa.cpp

@@ -0,0 +1,29 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+string decimal_to_hexa(int n){
+    int multiplier=1;
+    while(multiplier<=n)
+        multiplier*=16;
+    multiplier/=16;
+    string num="";
+    int d;
+    while(multiplier>=1){
+        d=n/multiplier;
+        if(d>9){
+            char c='A'+(d-10);
+            num= num + c;
+        }
+        else
+        num=num + to_string(d);
+        n=n-(d*multiplier);
+        multiplier/=16;
+    }
+    return num;
+}
+int main(){
+    int n;
+    cin>>n;
+    string hexa=decimal_to_hexa(n);
+    cout<<hexa;
+}

algorithms/CPlusPlus/Number-system/decimal_to_octal.cpp

@@ -0,0 +1,24 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int decimal_to_octal(int n){
+    int multiplier=1;
+    while(multiplier<=n){
+        multiplier*=8;
+    }
+    
+    multiplier/=8;
+    int num=0;
+    while(multiplier>=1){
+        num=num*10 + n/multiplier;
+        n=n - multiplier*(n/multiplier);
+        multiplier/=8;        
+    }
+    return num;
+}
+int main(){
+    int n;
+    cin>>n;
+    int octal=decimal_to_octal(n);
+    cout<<octal;
+}

algorithms/CPlusPlus/Number-system/hexa_to_decimal.cpp

@@ -0,0 +1,24 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int hexa_to_decimal(string n){
+    int l=n.size();
+    l=l-1;
+    int ans=0,x=1;
+    while(l>=0){
+        if(n[l]>='0' && n[l]<='9')
+            ans+=(n[l]-'0')*x;
+        else   
+            ans+=x*(n[l]-'A'+10);
+        x*=16;
+        l--;     
+    }
+    return ans;
+}
+
+int main(){
+    string s;
+    cin>>s;
+    int decimal=hexa_to_decimal(s);
+    cout<<decimal;
+}

algorithms/CPlusPlus/Number-system/octal_to_decimal.cpp

@@ -0,0 +1,20 @@
+#include<bits/stdc++.h>
+using namespace std;
+
+int octal_to_decimal(int n){
+    int num=0,r,multiplier=1;
+    while(n>0){
+        r=n%10;
+        num=num + (r*multiplier);
+        n=n/10;
+        multiplier=multiplier*8;  
+    }
+    return num;
+}
+
+int main(){
+    int n;
+    cin>>n;
+    int decimal=octal_to_decimal(n);
+    cout<<decimal;
+}

algorithms/CPlusPlus/README.md

@@ -30,6 +30,8 @@
 - [All unique triplet that sum up to given value](Arrays/three-sum.cpp)
 - [Next permutation](Arrays/next-permutation.cpp)
 - [Maximum Minimum Average of numbers](Arrays/max-min-avg.cpp)
+- [Sparse Matrix](Arrays/sparse_matrix.cpp)
+
 
 ## Dynamic-Programming
 
@@ -38,7 +40,7 @@
 - [0/1-knapsack](Dynamic-Programming/01-knapsack.cpp)
 - [Matrix chain Multiplication](Dynamic-Programming/matrix-chain-multiplication.cpp)
 - [Edit Distance](Dynamic-Programming/edit-distance.cpp)
-- [Rod Cutting problem](Dynamic-Programming/rod-cutting.cpp)
+
 
 ## Graphs
 
@@ -50,6 +52,9 @@
 - [Dfs traversal with recursion](Graphs/dfs-traversal.cpp)
 - [Connected Components](Graphs/total-connected-components.cpp)
 - [Dijkstra's Algorithm](Graphs/dijkstra.cpp)
+- [Cycle Detection](Graphs/cycle-detection.cpp)
+- [Prim's Algorithm](Graphs/prim's_algorithm.cpp)
+- [Floyd Warshall](Graphs/floyd-warshall.cpp)
 
 ## Multiplication
 
@@ -89,6 +94,7 @@
 - [Stack using Array](Stacks/stack-using-array.cpp)
 - [Infix to postfix expression conversion](Stacks/infix-to-postfix.cpp)
 - [Stock Span Problem using Stacks](Stacks/stock-span-problem.cpp)
+- [Prefix to Postfix expression conversion](Stacks/prefix_to_postfix.cpp)
 
 ## Sorting
 
@@ -138,6 +144,8 @@
 - [Finding the elements of a tree visible from top view](Trees/Top-View-Of-A-Tree.cpp)
 - [Binary Tree Implementation](Trees/binary-tree-implementation.cpp)
 - [Iterative Segment Tree](Trees/IterativeSegmentTree.cpp)
+- [Print all nodes at level k](Trees/print-all-nodes-at-a-level.cpp)
+- [Sum of right leaves](Trees/sum-of-right-leaves.cpp)
 
 ## Trie
 
@@ -161,6 +169,7 @@
 - [Power of two](Maths/power-of-two.cpp)
 - [Small numbers](Maths/small-numbers.cpp)
 - [Segmented Sieve](Maths/segmented-sieve-range.cpp)
+- [Binary Power](Maths/binary-power.cpp)
 
 # Recursion
 
@@ -183,6 +192,11 @@
 - [Product of digits in a number](Recursion\product-of-digits.cpp)
 - [Linear search using recursion](Recursion/linear-search.cpp)
 
-# Geometry
+
+## Geometry
 
 - [Convex hull Problem](Geometry/convex-hull.cpp)
+
+
+
+

algorithms/CPlusPlus/Recursion/first-uppercase-letter.cpp

@@ -1,7 +1,7 @@
 /*
 Description: Program to print the first uppercase letter in a string
 
-Approach: Use a varialbe to iterate over the string
+Approach: Use a variable to iterate over the string
 Increment the iterator by 1 at every recursive call
 If the value of iterator reaches till the length of the string, return '\0
 

algorithms/CPlusPlus/Recursion/reverse-a-number.cpp

@@ -0,0 +1,34 @@
+/*
+Description: Program to reverse integer using recursion
+Time complexity: O(n) where n is the number of digits in the integer
+*/
+
+#include <cmath>
+#include <iostream>
+using namespace std;
+
+int Helper(int n ,int base , int ans)
+{
+    if(n < 1)
+        return ans;
+    ans = ans * base + (n % 10);    // Update the ans for every digit
+    return Helper(n / 10, base , ans);    
+}
+
+int Rev(int n)
+{
+    return Helper(n , 10, 0);
+}
+
+
+int main(int argc, char const *argv[])
+{   
+    cout << Rev(13579);
+
+    return 0;
+}
+/*
+Input: 13579
+Output: 97531
+*/
+

algorithms/CPlusPlus/Searching/binary-search.cpp

@@ -7,12 +7,15 @@ int binarySearch(int arr[], int l, int r, int x)
 {
     if (r >= l) {
         int mid = l + (r - l) / 2;
+        //We use (l + (r - l)) rather than using (l + r) to avoid arithmetic overflow. 
+        //Arithmetic overflow is the situation when the value of a variable increases
+        //beyond the maximum value of the memory location, and wraps around.
 
         // 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 mid is greater than element, then it can only be present in left subarray
         if (arr[mid] > x)
             return binarySearch(arr, l, mid - 1, x);
 

algorithms/CPlusPlus/Stacks/prefix_to_postfix.cpp

@@ -0,0 +1,64 @@
+// Program to convert a prefix expression to postfix expression
+// Prefix expression : An expression in which the operator appears before the operands. 
+// Postfix expression : An expression in which the operator appears after the operands. 
+
+
+
+// Alogorithm
+// To convert prefix to postfix expression we follow steps given below:
+// Step 1. If the symbol is an operand, push it to the stack
+// Step 2. If symbol is an operator then pop top two elements from stack
+// Step 3. Then push an expression by concatenating (+op1+op2+symbol)
+// Step 4. At last return the top element of stack as postfix expression
+
+
+
+// CODE:
+#include<bits/stdc++.h>
+using namespace std;
+
+// Function to convert prefix to postfix expression
+string prefix_to_postfix(string prefix)
+{
+    stack<string> s;
+    // length of prefix expression
+    int l=prefix.length();
+  
+    // Iterating through the Prefix expression from right to left
+    for(int i=l-1;i>=0;i--){
+        // if the symbol is an operand, push it to the stack
+        if(prefix[i]>='a' && prefix[i]<='z'||prefix[i]>='A' && prefix[i]<='Z'){
+            s.push(string(1,prefix[i]));
+        }
+
+        // if symbol is an operator
+        else
+        { 
+            string op1=s.top();
+            s.pop();
+            string op2=s.top();
+            s.pop();
+            string temp=(op1+op2+prefix[i]);
+            s.push(temp);
+        }
+    }
+    // returning element at top of stack
+    return s.top();
+}
+
+// MAIN FUNCTION
+int main()
+{
+  string exp;
+  cout<<"Enter expression: ";
+  cin>>exp;
+  cout<<"Prefix to Postfix expression is: "<<prefix_to_postfix(exp);
+}
+
+
+// OUTPUT:
+// Enter expression: *-a/bc-/akl
+// Prefix to Postfix expression is: abc/-ak/l-*
+
+
+

algorithms/CPlusPlus/Trees/print-all-nodes-at-a-level.cpp

@@ -0,0 +1,83 @@
+/* Description - We have to print all nodes at a level 'k' of the tree.
+
+For example- If we are given the following tree, the nodes at level 1 are 1, nodes at level 2 are 2,3, nodes at level 3 are 7, 9 and nodes at level 4 are 21 and 11.
+(Note- The level starts from 1, i.e root is at level 1)
+
+            1          level 1
+          /   \
+         2     3       level 2
+      	      /  \    
+             7    9    level 3
+	    /      \
+	   21      11  level 4
+*/
+
+#include<bits/stdc++.h>
+using namespace std;
+
+typedef struct Node
+{
+	int data;
+	struct Node* left;
+	struct Node* right;
+	
+	Node(int val)
+	{
+		data= val;
+		left=right=NULL;
+	}
+}node;
+
+//function for level order traversal
+void levelorder(Node* root, int k)
+{
+	if(root==NULL)
+		return;
+		
+	queue<Node*> q;
+	
+	q.push(root);
+	int count=0;  //for calculating at which level we are.
+	
+	while(!q.empty())
+	{
+		count++;  //increment the value of count as level is incremented
+		int n=q.size();
+		
+		for(int i=0; i<n; i++)
+		{
+			Node* temp=q.front();
+			q.pop();
+			if(count==k) { //if level is equal to the required level, then print its nodes
+				cout<<temp->data<<" ";
+			}
+			if(temp->left!=NULL){
+				q.push(temp->left);
+			}
+			if(temp->right!=NULL){
+				q.push(temp->right);
+			}
+		}	
+	}
+}
+
+//main function
+int main()
+{
+	node*root=new node(1);
+	root->left=new node(2);
+	root->right=new node(3);
+	root->right->left=new node(7);
+	root->right->right=new node(9);
+	root->right->left->left=new node(21);
+	root->right->right->right=new node(11);
+
+	int k = 3;  // here we have taken k=3 (third level of tree)
+	
+	levelorder(root,k);   //calling level order function
+}
+
+// The output of the above program will be 7 9. Since k=3 and nodes at level 3 are 7 and 9.
+
+// Time Complexity: O(n) where n is the number of nodes in the binary tree 
+// Space Complexity: O(n) where n is the number of nodes in the binary tree

algorithms/CPlusPlus/Trees/sum-of-right-leaves.cpp

@@ -0,0 +1,81 @@
+// The sum of right leaves algorithm uses a queue to navigate through a binary tree
+// Worst Case Time Complexity: O(n)
+// Average Time Complexity: O(n)
+
+#include <iostream>
+#include <queue>
+
+using namespace std;
+
+// Node structure for tree
+struct Node {
+    int val;
+    Node *left;
+    Node *right;
+
+    Node(int val) {
+        this->val = val;
+        left = nullptr;
+        right = nullptr;
+    }
+};
+
+int sumRightLeaves(Node* root) {
+    queue<Node*> q;
+    int rightSum = 0;
+
+    // Checking if the root is nullptr push to queue if it exists
+    if(root)
+    {
+        q.push(root);
+    }
+
+    while(!q.empty())
+    {
+        // Check if there exists a right node
+        if(q.front()->right)
+        {
+            // Check if this is a leaf node
+            if(q.front()->right->right == nullptr && q.front()->right->left == nullptr)
+            {
+                rightSum += q.front()->right->val;
+            }
+            else
+            {
+                q.push(q.front()->right);
+            }
+        }
+        if(q.front()->left) // Check down left side of tree
+        {
+            q.push(q.front()->left);
+        }
+
+        q.pop();
+    }
+
+    return rightSum;
+}
+
+int main()
+{
+    Node* root = new Node(3);
+    root->left = new Node(5);
+    root->right = new Node(7);
+    root->left->left = new Node(8);
+    root->left->right = new Node(10);
+    root->right->right = new Node(13);
+
+//                     3
+//                    / \
+//                   5   7
+//                  / \   \
+//                 8   10  13
+//
+//          Sample Output
+//          Sum of the right leaves: 23
+
+// Outputting sum of right leaves
+    cout << "Sum of right leaves: " << sumRightLeaves(root);
+
+    return 0;
+}

algorithms/CSharp/README.md

@@ -1,43 +1,57 @@
 # C#
-For running the `.cs` file please using [.Net Finddle](https://dotnetfiddle.net/)
+
+To run the `.cs` file, kindly use [.Net Finddle](https://dotnetfiddle.net/)
 
 ## Arrays
+
 - [Single Number](src/Arrays/single-number.cs)
 
 ## Dynamic Programming
+
 - [Longest Common Subsequence](src/Dynamic-Programming/longest-common-subsequence.cs)
 
 ## Number Theory
+
 - [Big Mod Algorithm](src/Number-Theory/big-mod.cs)
 - [Sieve of Eratosthenes](src/Number-Theory/sieve-of-eratosthenes.cs)
 - [Bitwise Sieve of Eratosthenes](src/Number-Theory/bitwise-sieve-of-eratosthenes.cs)
 
 ## Sorts
+
 - [Bubble Sort](src/Sorts/bubble-sort.cs)
 - [Insertion Sort](src/Sorts/insertion-sort.cs)
 - [Selection Sort](src/Sorts/selection-sort.cs)
 - [Counting Sort](src/Sorts/counting-sort.cs)
 - [Merge Sort](src/Sorts/merge-sort.cs)
+- [Quick Sort](src/Sorts/quick-sort.cs)
 
 ## Strings
+
 - [Palindrome](src/Strings/palindrome.cs)
 - [Trie](src/Strings/trie.cs)
+- [Character Limit](src/Strings/character-limit.cs)
 
 ## Search
+
 - [Binary Search](src/Search/binary-search.cs)
 - [Linear Search](src/Search/linear-search.cs)
+- [Minima Maxima](src/Search/minima-maxima.cs)
 
 ## Maths
+
 - [Abundant Number](src/Maths/abundant-number.cs)
 - [Naismith's Rule](src/Maths/naismith-rule.cs)
 
 ## Queues
+
 - [Queue Implementation Using Two Stacks](src/Queues/queue-implementation-using-two-stacks.cs)
 
 ## Recursion
+
 - [Factorial](src/Recursion/factorial.cs)
 
 ## Graph
+
 - [Breadth First Search](src/Graph/breadth-first-search.cs)
 - [Depth First Search](src/Graph/depth-first-search.cs)
 - [Kruskals Algorithm to Find Minimum Spanning Tree](src/Graph/kruskals-algorithm.cs)

algorithms/CSharp/src/Search/minima-maxima.cs

@@ -0,0 +1,100 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Algorithms.Search
+{
+    public class MinimaMaxima
+    {
+        public static void Main()
+        {
+            var numbers = new List<int>
+            {
+                3,1,2,5,6,7,4,6,9,10
+            };
+
+            var minimas = FindMinimas(numbers);
+            var maximas = FindMaximas(numbers);
+
+            foreach (var minima in minimas)
+            {
+                Console.WriteLine($"Local Minima: {minima}");
+            }
+
+            foreach (var maxima in maximas)
+            {
+                Console.WriteLine($"Local Maxima: {maxima}");
+            }
+        }
+
+        public static List<int> FindMinimas(List<int> numbers)
+        {
+            var result = new List<int>();
+
+            if (numbers.Count < 3)
+            {
+                result.Add(numbers.Min());
+            }
+            else
+            {
+                // Check first element
+                if (numbers[0] < numbers[1])
+                {
+                    result.Add(numbers[0]);
+                }
+
+                //Loop middle elements
+                for (int i = 1; i < numbers.Count - 1; i++)
+                {
+                    if (numbers[i - 1] >= numbers[i] && numbers[i] <= numbers[i + 1])
+                    {
+                        result.Add(numbers[i]);
+                    }
+                }
+
+                //Check last elements
+                if (numbers[^1] < numbers[^2])
+                {
+                    result.Add(numbers[^1]);
+                }
+            }
+
+            return result;
+        }
+
+        public static List<int> FindMaximas(List<int> numbers)
+        {
+            var result = new List<int>();
+
+            if (numbers.Count < 3)
+            {
+                result.Add(numbers.Max());
+            }
+            else
+            {
+                // Check first element
+                if (numbers[0] > numbers[1])
+                {
+                    result.Add(numbers[0]);
+                }
+                    
+                //Loop middle elements
+                for (int i = 1; i < numbers.Count - 1; i++)
+                {
+                    if (numbers[i - 1] <= numbers[i] && numbers[i] >= numbers[i + 1])
+                    {
+                        result.Add(numbers[i]);
+                    }
+                }
+
+                //Check last elements
+                if (numbers[^1] > numbers[^2])
+                {
+                    result.Add(numbers[^1]);
+                }
+            }
+
+            return result;
+        }
+    }
+}

algorithms/CSharp/src/Sorts/quick-sort.cs

@@ -0,0 +1,93 @@
+using System;
+
+namespace Algorithms.Sorts
+{
+    public class QuickSort
+    {
+        public static void Main()
+        {
+            int[] array = { 10, 7, 8, 9, 1, 5 };
+
+            Sort(array, 0, array.Length - 1);
+            PrintArray(array);
+        }
+
+        /// <summary>
+        /// Sorts an array.
+        /// </summary>
+        /// <param name="array">Array to be sorted.</param>
+        /// <param name="low">Starting index.</param>
+        /// <param name="high">Ending index.</param>
+        public static int[] Sort(int[] array, int low, int high)
+        {
+            if (low < high)
+            {
+                // Select a pivot
+                int pivot = Partition(array, low, high);
+
+                // Sort each subarray
+                Sort(array, low, pivot - 1);
+                Sort(array, pivot + 1, high);
+            }
+
+            return array;
+        }
+
+        /// <summary>
+        /// This method takes the last element as pivot, places
+        /// it at its correct position in sorted array, and
+        /// places all smaller (smaller than pivot)
+        /// to left of it and all greater elements to its right.
+        /// </summary>
+        /// <param name="array">Array to be sorted.</param>
+        /// <param name="low">Starting index.</param>
+        /// <param name="high">Ending index.</param>
+        /// <returns></returns>
+        private static int Partition(int[] array, int low, int high)
+        {
+            int pivot = array[high];
+            int i = low - 1;
+
+            for (int j = low; j <= high - 1; j++)
+            {
+                // If current element is smaller than the pivot
+                if (array[j] < pivot)
+                {
+                    // Increment index of smaller element and swap them
+                    i++;
+                    Swap(array, i, j);
+                }
+            }
+
+            Swap(array, i + 1, high);
+
+            return (i + 1);
+        }
+
+        /// <summary>
+        /// Swaps two elements.
+        /// </summary>
+        /// <param name="array">Array to be sorted.</param>
+        /// <param name="i">An index.</param>
+        /// <param name="j">Another index.</param>
+        private static void Swap(int[] array, int i, int j)
+        {
+            int temp = array[i];
+            array[i] = array[j];
+            array[j] = temp;
+        }
+
+        static void PrintArray(int[] array)
+        {
+            Console.Write("Sorted array: ");
+
+            for (int i = 0; i < array.Length; i++)
+            {
+                Console.Write($"{array[i]} ");
+            }
+                
+            Console.WriteLine();
+        }
+    }
+}
+

algorithms/CSharp/src/Strings/character-limit.cs

@@ -0,0 +1,50 @@
+using System;
+using System.Linq;
+
+//Time Complexity: O(N)
+namespace Algorithms.Strings
+{
+    public class TextHelper
+    {
+        public static void Main()
+        {
+            Console.WriteLine("Please enter a string");
+            string input = Console.ReadLine();
+
+            while (input == "")
+            {
+                Console.WriteLine("Please enter a string");
+                input = Console.ReadLine();
+            }
+
+            Console.WriteLine("Please enter the number of characters you want to show");
+            string input2 = Console.ReadLine();
+
+            while (!input2.All(char.IsDigit) || input2.All(char.IsWhiteSpace))
+            {
+                Console.WriteLine("The number you have entered is invalid. Please try again:");
+                input2 = Console.ReadLine();
+            }
+
+            int num = Convert.ToInt32(input2);
+            Console.WriteLine(CharacterLimit(input, num));
+        }
+
+        //Limits the the amount of characters shown in a string.
+        public static string CharacterLimit(string input, int num)
+        {
+            //converts a string to a character array
+            char[] ch = input.ToCharArray();
+
+            //loops through the array from the last element to the first, and replaces each element with a "."
+            for (int i = ch.Count(); i > num; i--)
+            {
+                ch[i - 1] = '.';
+            }
+
+            //converts character array back to string to be returned by the method
+            string output = new string(ch);
+            return output;
+        }
+    }
+}

algorithms/CSharp/test/Search/minima-maxima.cs

@@ -0,0 +1,25 @@
+using Algorithms.Search;
+using NUnit.Framework;
+using System.Linq;
+
+namespace Algorithms.Tests.Search
+{
+    [TestFixture]
+    public class MinimaMaximaTest
+    {
+
+        [TestCase(new int[] { 3, 1, 2, 5, 6, 7, 4, 6, 9, 10 }, new int[] { 1, 4 })]
+        public void PassIntegerList_ShouldGetExpectedMinimas(int[] input, int[] result)
+        {
+            var expected1 = MinimaMaxima.FindMinimas(input.ToList());
+            Assert.AreEqual(expected1, result);
+        }
+
+        [TestCase(new int[] { 3, 1, 2, 5, 6, 7, 4, 6, 9, 10 }, new int[] { 3, 7, 10 })]
+        public void PassIntegerList_ShouldGetExpectedMaximas(int[] input, int[] result)
+        {
+            var expected1 = MinimaMaxima.FindMaximas(input.ToList());
+            Assert.AreEqual(expected1, result);
+        }
+    }
+}

algorithms/CSharp/test/Sorts/quick-sort.cs

@@ -0,0 +1,39 @@
+using NUnit.Framework;
+
+namespace Algorithms.Tests.Sorts
+{
+    [TestFixture]
+    public class QuickSort
+    {
+        static readonly object[] TestCasesForQuickSort =
+        {
+            new object[] {
+                new int[] { 0, 19, 12, 22, 107, 118, 0, 1, 2},
+                "0, 0, 1, 2, 12, 19, 22, 107, 118"
+            },
+
+            new object[] {
+                new int[] { 10, 11, 19, 0, -1, -19, -12, 1, 2, 1, 16, -100},
+                "-100, -19, -12, -1, 0, 1, 1, 2, 10, 11, 16, 19"
+            },
+
+            new object[] {
+                new int[] { -1, -2, -3, -4, -5, -10},
+                "-10, -5, -4, -3, -2, -1"
+            },
+
+            new object[] {
+                new int[] { -1 },
+                "-1"
+            }
+        };
+
+        [TestCaseSource(nameof(TestCasesForQuickSort))]
+        public void TestQuickSort_ShouldGetExpected(int[] array, string expected)
+        {
+            var results = Algorithms.Sorts.QuickSort.Sort(array, 0, array.Length - 1);
+
+            Assert.That(expected, Is.EqualTo(string.Join(", ", results)));
+        }
+    }
+}

algorithms/CSharp/test/Strings/character-limit.cs

@@ -0,0 +1,18 @@
+using NUnit.Framework;
+
+namespace Algorithms.CSharp.Test.Strings
+{
+    [TestFixture]
+    internal class Character_Limit
+    {
+        [TestCase("Hello", "Hel..")]
+        [TestCase("World", "Wor..")]
+        [TestCase("How Ya", "How...")]
+        [TestCase("Doin", "Doi.")]
+        public void PassString_ShouldGetExpectedResult(string text, string expected)
+        {
+            string result = Algorithms.Strings.TextHelper.CharacterLimit(text, 3);
+            Assert.AreEqual(expected, result);
+        }
+    }
+}

algorithms/Go/README.md

@@ -19,11 +19,13 @@
 ## Sorting
 - [Bubble Sort](sorting/bubble-sort.go)
 - [Insertion Sort](sorting/insertion-sort.go)
-- [Quicksort](sorting/quicksort.go)
+- [Quick Sort](sorting/quicksort.go)
+- [Selection Sort](sorting/selection-sort.go)
 
 ## Recursion
 - [Fibonacci](recursion/fibonacci.go)
 
 ## String
 - [Palindrome Permutation](strings/palindrome-permutation.go)
+- [Anagram](strings/anagram.go)
 

algorithms/Go/sorting/selection-sort.go

@@ -0,0 +1,62 @@
+/*
+	Selection sort algorithm sorts an array by repeatedly finding the minimum element (considering ascending order) from unsorted part and putting it at the beginning.
+	The algorithm maintains two subarrays in a given array:
+		The subarray which is already sorted.
+		Remaining subarray which is unsorted.
+	Average Time Complexity: O(n^2)
+
+	Link for reference: https://www.geeksforgeeks.org/selection-sort/
+
+*/
+
+package sorting
+
+import "fmt"
+
+func RunSelectionSortRec() {
+	arr := []int{7, 4, 7, 3, 2}
+	selSortRec(arr, len(arr)-1) //using recursion
+	fmt.Println(arr)            // 2, 3, 4, 7, 7
+}
+func RunSelectionSortIter() {
+	arr := []int{7, 4, 7, 3, 1}
+	selSort(arr)     //using iteration
+	fmt.Println(arr) // 1, 3, 4, 7, 7
+}
+
+//sort using iterative method
+func selSort(arr []int) {
+	for arrIndex := range arr {
+		minVal := arr[arrIndex]
+		minIndex := arrIndex
+		for subIndex := arrIndex + 1; subIndex < len(arr); subIndex++ {
+			if arr[subIndex] < minVal {
+				minVal = arr[subIndex]
+				minIndex = subIndex
+			}
+		}
+		arr[minIndex], arr[arrIndex] = arr[arrIndex], arr[minIndex]
+	}
+}
+
+//sort using recursive method
+func selSortRec(arr []int, i int) {
+	if i < 0 {
+		return
+	}
+	maxIn := maxSel(arr, i)
+	//i = len(arr)-1
+	if i != maxIn {
+		arr[i], arr[maxIn] = arr[maxIn], arr[i]
+	}
+	selSortRec(arr, i-1)
+}
+func maxSel(arr []int, i int) int {
+	if i > 0 {
+		maxIn := maxSel(arr, i-1)
+		if arr[i] < arr[maxIn] {
+			return maxIn
+		}
+	}
+	return i
+}

algorithms/Go/strings/anagram.go

@@ -0,0 +1,50 @@
+/**
+Problem Statement: Given two strings s and t, find they are anagrams or not
+An Anagram is a word or phrase formed by rearranging the letters of a different word or phrase, typically using all the original letters exactly once.
+
+Example 1: Input: s="anagram" t="nagaram"
+		   Output: true
+
+Example 2: Input: s="rat" t="car"
+		   Output: false
+
+Time complexity: O(n), n=length of string s
+Space complexity: O(1)
+
+**/
+
+package strings
+
+import "fmt"
+
+func RunIsAnagram() {
+	fmt.Println("Enter first string")
+	var first string
+	fmt.Scanln(&first)
+	fmt.Println("Enter second string")
+	var second string
+	fmt.Scanln(&second)
+	ans := isAnagram(first, second)
+	if ans == true {
+		fmt.Println("They are anagrams")
+	} else {
+		fmt.Println("They are not anagrams")
+	}
+}
+
+func isAnagram(s string, t string) bool {
+	var count [256]int
+
+	for i := 0; i < len(s); i++ {
+		count[s[i]]++
+	}
+	for i := 0; i < len(t); i++ {
+		count[t[i]]--
+	}
+	for i := 0; i < len(count); i++ {
+		if count[i] != 0 {
+			return false
+		}
+	}
+	return true
+}

algorithms/Go/strings/palindrome-permutation.go

@@ -1,3 +1,10 @@
+/*
+Given a string s, return true if we can have a palindrome from the permutation of the input
+A palindrome is a word, number, phrase, or other sequence of characters which reads the same backward as forward, such as madam or racecar.
+
+	Time: O(n)
+	Space: O(n)
+*/
 package strings
 
 import( 
@@ -5,12 +12,7 @@ import(
 	"fmt"
 )
 
-/*
-Given a string s, return true if we can have a palindrome from the permutation of the input
 
-	Time: O(n)
-	Space: O(n)
-*/
 func canPermutePalindrome(s string) bool {
     a := strings.Split(s,"")
     dictionary := make(map[string] int)
@@ -29,7 +31,7 @@ func canPermutePalindrome(s string) bool {
 
 
 //You are welcome to play around with the test cases
-func runPermutationCheck(){
+func RunPermutationCheck(){
 	input1 := "carerac"
 
 	fmt.Printf("%t for input %s \n", canPermutePalindrome(input1), input1)	//should print true

algorithms/Java/Maths/square-root.java

@@ -0,0 +1,49 @@
+// Calculating Square root of a number which is not necessarily perfect square
+// using Binary Search i.e. is using decrease and conquer approach
+// Time: O(log(n))
+public class BinarySearchSQRT {
+    public static void main(String[] args) {
+        int n = 40; // number whose square root is to be calculated
+        int p = 3; // decimal precision required
+
+        System.out.printf("%.3f", sqrt(n, p));
+    }
+    static double sqrt(int n, int p) {
+        int s = 0;
+        int e = n;
+
+        double root = 0.0;
+
+        while (s <= e) {
+            int m = s + (e - s) / 2; //this method of calculating middle element avoids integer overflow
+
+            if (m * m == n) { //the middle element is the required sqrt
+                return m;
+            }
+            else if (m * m > n) { //sqrt lies on the left part
+                e = m - 1;
+            }
+            else { // sqrt lies in the right part
+                s = m + 1;
+                root = m;
+            }
+        }
+        //now the root contains the nearest integer to the required square root
+        //now we need to add decimal precision to the root so that we can get as close to the exact sqrt
+        double incr = 0.1; //initialise
+        for (int i = 0; i < p; i++) {
+            while (root * root <= n) { //if the square of the root we have is less than the number
+                root += incr; //we will add incr decimal point each time
+            }
+            root -= incr;
+            incr /= 10; //here we increase the decimal point
+        }
+
+        return root; //here we have root up to p decimal point
+    }
+}
+
+/*
+Output -
+6.324
+*/

algorithms/Java/README.md

@@ -33,6 +33,7 @@
 - [Catalan Numbers](Maths/catalan-numbers.java)
 - [Nth Geek Onacci Number](Maths/nth-geek-onacci-number.java)
 - [Random Node in Linked List](Maths/algorithms_random_node.java)
+- [Square Root using BinarySearch](Maths/square-root.java)
 
 ## Queues
 
@@ -74,6 +75,7 @@
 - [Celebrity Problem](stacks/celebrity-problem.java)
 - [Sliding Window Maximum](stacks/sliding-window-maximum.java)
 - [Min Stack](stacks/Min-Stack.java)
+- [Next Greater Element](stacks/Next_Greater_Element.java)
 
 ## Strings
 
@@ -88,6 +90,7 @@
 - [Boyer Moore Search](strings/Boyer_Moore.java)
 - [Reverse String](strings/reverse-string.java)
 - [First Non Repeating Character](strings/first-non-repeating-char.java)
+- [Isomorphic Strings](strings/isomorphic_strings.java)
 
 ## Trees
 
@@ -97,7 +100,8 @@
 - [Zig-Zag Traversal of a Tree](trees/zig-zag-traversal.java)
 - [Min Heap](trees/MinHeap.java)
 - [Check Tree Traversal](trees/check-tree-traversal.java)
-- [Random Node of a binary tree](tree-random-node.java)
+- [Random Node of a binary tree](trees/tree-random-node.java)
+- [Left Leaf Sum of a Binary tree](trees/Left-Leaf-Sum.java)
 
 ## Backtracking
 

algorithms/Java/backtracking/target-sum-subsets.java

@@ -0,0 +1,49 @@
+// Target sum subsets is a program to print all subsets of an array (given by user) such that sum of all elements in subset equal to a target sum given by user
+
+// Algorithm Type: Backtracking
+// Time Complexity: O(2^N)
+
+import java.io.*;
+import java.util.*;
+
+public class targetSumSubsets {
+
+    public static void main(String[] args) throws Exception {
+        Scanner scn = new Scanner(System.in);
+
+        // input size of array
+        int n = scn.nextInt();
+
+        // input elements of array
+        int[] arr = new int[n];
+        for(int i=0; i<n; i++){
+            arr[i] = scn.nextInt();
+        }
+
+        // input target sum
+        int tar = scn.nextInt();
+
+        // calling our function - printTargetSumSubsets
+        printTargetSumSubsets(arr, 0, "", 0, tar);
+        scn.close();
+    }
+
+    // set is the subset, sum is the sum so far for that subset
+    public static void printTargetSumSubsets(int[] arr, int idx, String set, int sum, int tar){   
+        if (idx == arr.length){
+            if (sum == tar){
+                System.out.println(set + " ");
+            }
+            return;
+        }
+
+        // pick
+        printTargetSumSubsets(arr, idx + 1, set + arr[idx] + " ", sum + arr[idx], tar);
+       
+        //not pick
+        printTargetSumSubsets(arr, idx + 1, set, sum, tar);    
+    }
+
+    
+
+}

algorithms/Java/searching/binary-search.java

@@ -1,47 +1,64 @@
-// Java implementation of recursive Binary Search 
-class BinarySearch { 
-    // Returns index of x if it is present in arr[l..r], 
-    //  else return -1 
-    int binarySearch(int arr[], int l, int r, int x) 
-    { 
-        if (r >= l) { 
-            int mid = l + (r - l) / 2; 
+// Algorithm BinarySearch Iterative method
+/*binarySearch(arr, x, low, high)
+        repeat till low = high
+               mid = (low + high)/2
+                   if (x == arr[mid])
+                   return mid
    
-            // If the element is present at the 
-            // middle itself 
-            if (arr[mid] == x) 
+                   else if (x > arr[mid]) // x is on the right side
+                       low = mid + 1
+   
+                   else                  // x is on the left side
+                       high = mid - 1
+ */
+// Time Complexity : O(log(n)) 
+
+public class BinarySearch {
+
+    static int binarySearch(int arr[], int key) 
+    {
+        int start = 0;
+        int end = arr.length - 1;
+        
+        while (start <= end) {
+            // We use (start + (end - start)/2) rather than using (start + end)/2 to avoid
+            // arithmetic overflow.
+            // Arithmetic overflow is the situation when the value of a variable increases
+            // beyond the maximum value of the memory location, and wraps around.
+            int mid = start + (end - start) / 2; // optimised way
+
+            if (arr[mid] == key)// key element is found at the middle of the array
                 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); 
+            else if (arr[mid] < key) {// so the key lies in the right hand side of array
+                start = mid + 1;
             }
 
-        // We reach here when element is not present 
-        // in array 
+            else {// so the key lies in the left subarray
+                end = mid - 1;
+            }
+        }
+        // we reach here when the key element is not present
         return -1;
     }
 
-    // Driver method to test above 
-    public static void main(String args[]) 
+    public static void main(String[] args) 
     {
-        BinarySearch ob = new BinarySearch(); 
-        int arr[] = { 2, 3, 4, 10, 40 }; 
-        int n = arr.length; 
-        int x = 10; 
-        int result = ob.binarySearch(arr, 0, n - 1, x); 
-        if (result == -1) 
-            System.out.println("Element not present"); 
-        else
-            System.out.println("Element found at index " + result); 
+
+        int arr[] = { 1, 3, 4, 5, 6 };
+
+        /*
+         * List<ArrayList<Integer>> arr = new ArrayList<>();
+         * arr.add(new ArrayList<Integer>(Arrays.asList( 1, 3, 4, 5, 6 )));
+         */
+        int key = 4; // element to search
+        int index = binarySearch(arr, key);
+        if (index == -1) {
+            System.out.println("key element not found");
         }
+        else {
+            System.out.println("key element found at index :" + index);
         }
 
-// For running in terminal rename this file to BinarySearch.java
-//then run the commands <javac BinarySearch.java> followed by <java BinarySearch>
-//It will generate and a BinarySearch.class file which is a file containing java bytecode that is executed by JVM.
+    }
+}

algorithms/Java/stacks/Next_Greater_Element.java

@@ -0,0 +1,79 @@
+/***
+ * Problem Statement:
+ * Given an array arr[] of size N having distinct elements, the task is to find the next greater element for each element of the array in order of their appearance in the array.
+ * Next greater element means nearest element on right side which is greater than current element, 
+ * if there is no suxh element, then put -1 for that.
+ *
+ */
+
+
+ /***
+  * Example 1: Input: arr=[1,3,2,4] n=4
+               Output: 3 4 4 -1
+    
+    Example 2: Input: arr=[6 8 0 1 3] n=5
+               Output: 8 -1 1 3 -1
+  */
+
+  /***
+   * Time Complexity: O(N)
+   * Space Complexity: O(N)
+   */
+  import java.util.Scanner;
+import java.util.Stack;
+  
+  public class Next_Greater_Element {
+      public static void main(String[] args){
+          Scanner input=new Scanner(System.in);
+          int n=input.nextInt();
+          long arr[]=new long[n];
+          for (int i=0;i<n;i++){
+              arr[i]=input.nextLong();
+          }
+          long ans[]=nextLargerElement(arr,n);  // functions that print array for calculating next greater element
+          for (int i=0;i<ans.length;i++){
+            System.out.print(ans[i]+" ")
+          }
+    }
+      public static long[] nextLargerElement(long[] arr, int n)
+      { 
+          // Your code here
+
+        /****
+         * Approach: for element at index i,
+         * there were two posiibilities that there is greater element than this
+         * at right side of array or not.
+         * if there is no greater element in right side is indicated by Empty stack
+         * if there is greater ekement in right side is indicated by stack peek element.
+         */
+
+
+          long ans[]=new long[n];
+          ans[n-1]=-1;
+          Stack<Long> st=new Stack<>();
+          st.push(arr[n-1]);
+          for (int i=n-2;i>=0;i--)
+          {
+              if(st.isEmpty())
+              {
+                  st.push(arr[i]);
+                  ans[i]=-1;
+              }
+              else
+              {
+                  while(st.isEmpty()==false && arr[i]>=st.peek())
+                  {
+                      st.pop();
+                  }
+                  if(st.size()==0){
+                      ans[i]=-1;
+                  }else{
+                      ans[i]=st.peek();
+                  }
+                  st.push(arr[i]);
+              }
+          }
+          return ans;
+      } 
+  }
+  

algorithms/Java/strings/isomorphic_strings.java

@@ -0,0 +1,61 @@
+/** 
+    problem statement:
+    Given two strings- str1 and str2, check both are isomorphic or not
+    Isomorphic strings: Two strings are called isomorphic,
+    if there is a one to one mapping possible for every character of str1 to every character of str2 while preserving the order. 
+ */
+
+ /***
+    Example 1 => Input: str1="aab", str2="xxy"
+                 Output: 1
+    Example 2 => Input: str1="aab", str2="xyz"
+                 Output: 0
+  */
+/** 
+ * 
+ * Time Complexity: O(N)
+  Space Complexity: O(1)
+*/
+  
+  import java.util.Arrays;
+import java.util.Scanner;
+  public class isomorphic_strings{
+    public static void main(String[] args){
+        Scanner input=new Scanner(System.in);
+        String str1=input.next();
+        String str2=input.next();
+        if(strings_are_isomorphic(str1,str2)){
+            System.out.println("1");
+        }else{
+            System.out.println("0");
+        }
+    }
+    public static boolean strings_are_isomorphic(String s1,String s2){
+        int n=s1.length();
+        int m=s2.length();
+        //check length of both strings
+        if(n!=m){
+            return false;
+        }
+        // array, make for mark visited characters of s2.
+        boolean visited[]=new boolean[256];
+        //array, store mapping of every character from s1 to s2
+        int map[]=new int[256];
+        Arrays.fill(map,-1);
+        for (int i=0;i<n;i++)
+        {
+            char c1=s1.charAt(i);
+            char c2=s2.charAt(i);
+            if(map[c1]==-1){
+                if(visited[c2]==true){
+                    return false;
+                }
+                visited[c2]=true;
+                map[c1]=c2;
+            }else if(map[c1]!=c2){
+                return false;
+            }
+        }
+        return true;
+    }
+  }

algorithms/Java/trees/Left-Leaf-Sum.java

@@ -0,0 +1,95 @@
+package Trees.Left_Leaf_Sum;
+/* Problem Statement: Given the root of a binary tree, return the sum of all left leaves. */
+
+//class to create Tree
+class TreeNode{
+	  int data;
+	  TreeNode left,right;
+
+	  TreeNode(int data){
+	    this.data = data;
+	    this.left = this.right = null;
+	  }
+	}
+class Tree{
+	TreeNode root;
+	
+	public Tree() {
+		root=null;
+	}
+}
+public class LeftLeafSum {
+	
+	 //method to check if a node is leaf or not
+	static boolean isLeaf(TreeNode root)
+    {
+        if (root == null)   return false;
+        if (root.left == null && root.right == null)    
+        return true;
+        
+        return false;
+    }
+	
+	//returns the sum of left leaves
+        public static int leftsum(TreeNode root){
+        
+        int leftLeavesSum=0;
+        
+        //to avoid null pointer exception
+        if(root!=null)
+        {
+        
+        //if a node's left is a leaf then add its value	
+        if( isLeaf(root.left) )
+        leftLeavesSum+=root.left.data;
+        
+        //else go to left
+        else
+        leftLeavesSum+=leftsum(root.left);
+        
+        //and finally go to right
+        leftLeavesSum+=leftsum(root.right);
+        }
+        
+        return leftLeavesSum;
+        
+        
+        
+        
+  }
+	
+public static void main(String[] args) {
+	Tree tree = new Tree();
+    tree.root = new TreeNode(1);
+    tree.root.left = new TreeNode(2);
+    tree.root.right = new TreeNode(3);
+    tree.root.left.left = new TreeNode(7);
+    tree.root.left.right = new TreeNode(8);
+    tree.root.right.left = new TreeNode(81);
+    tree.root.right.right= new TreeNode(75);
+    
+    
+    int sumOfLeftLeaves = leftsum(tree.root);
+    System.out.println("sum of left leaves is "+sumOfLeftLeaves);   
+}
+}
+
+/*
+
+Eg. Input:-
+                                1
+		              /   \
+		            2      3
+		           / \    / \		
+                          7   8  81  75  
+Output:- 88
+
+Explanation:-there are two left leaves(nodes which have no child) 7 and 81 respectively in the tree and their sum is 88
+
+Time Complexity:- O(N), where n is number of nodes in Binary Tree.
+
+
+Code Description:- A method isLeaf() which returns a boolean, is created to check if a node is leaf or not, is yes then add its
+left.data, if not then recursively go to its left and then its right.
+
+*/

algorithms/JavaScript/README.md

@@ -1,18 +1,22 @@
 # JavaScript
 
 ## Arrays
+
 - [Counting Inversions](src/arrays/counting-inversions.js)
 
 ## Linked Lists
+
 - [Singly](src/linked-lists/singly.js)
 - [Doubly](src/linked-lists/doubly.js)
 
 ## Searching
+
 - [Binary Search Recursive](src/searching/binary-search-recursive.js)
 - [Binary Search](src/searching/binary-search.js)
 - [Linear Search](src/searching/linear-search.js)
 
 ## Sorting
+
 - [Bubble Sort](src/sorting/bubble-sort.js)
 - [Insertion Sort](src/sorting/insertion-sort.js)
 - [Merge Sort](src/sorting/merge-sort.js)
@@ -20,12 +24,27 @@
 - [Selection Sort](src/sorting/selection-sort.js)
 
 ## Strings
+
 - [Palindrome](src/strings/palindrome.js)
 - [Sequence](src/strings/sequence.js)
 
 ## Stacks
+
 - [Stacks](src/stacks/stack.js)
 - [Two Stack](src/stacks/two-stack.js)
 
 ## Queues
+
 - [Queue](src/queues/queue.js)
+
+## Maths
+
+- [Fibonacci Series](src/maths/fibonacci-series.js)
+
+## Recursion
+
+- [Factorial](src/recursion/factorial.js)
+
+## Heaps
+
+- [Max Heap](src/heaps/max-heap.js)

algorithms/JavaScript/src/heaps/max-heap.js

@@ -0,0 +1,155 @@
+
+// A binary heap is a partially ordered binary tree
+// that satisfies the heap property.
+// The heap property specifies a relationship between parent and child nodes.
+// In a max heap, all parent nodes are greater than
+// or equal to their child nodes.
+// Heaps are represented using arrays because
+// it is faster to determine elements position and it needs
+// less memory space as we don't need to maintain references to child nodes.
+// An example:
+// consider this max heap: [null, 47, 15, 35, 10, 3, 0, 25, 1].
+// The root node is the first element 47. its children are 15 and 35.
+// The general indexes formula for an element of index i are:
+// the parent is at: Math.floor(i / 2)
+// the left child is at:  i * 2
+// the right child is at:  i * 2  + 1
+
+const isDefined = (value) => value !== undefined && value !== null;
+
+class MaxHeap {
+  constructor() {
+    this.heap = [null];
+  }
+
+  // Insert a new element  method
+  // this is a recursive method, the algorithm is:
+  //  1. Add the new element to the end of the array.
+  //  2. If the element is larger than its parent, switch them.
+  //  3. Continue switching until the new element is either
+  // smaller than its parent or you reach the root of the tree.
+
+  insert(value) {
+    // add the new element to the end of the array
+    this.heap.push(value);
+    const place = (index) => {
+      const parentIndex = Math.floor(index / 2);
+      if (parentIndex <= 0) return;
+      if (this.heap[index] > this.heap[parentIndex]) {
+        // the switch is made here
+        [this.heap[parentIndex], this.heap[index]] = [
+          this.heap[index],
+          this.heap[parentIndex],
+        ];
+        place(parentIndex);
+      }
+    };
+    // we begin the tests from the new element we added
+    place(this.heap.length - 1);
+  };
+
+  // Print heap content method
+  print() {
+    return this.heap;
+  };
+
+  // Remove an element from the heap
+  // it's also a recursive method, the algorithm will reestablish
+  // the heap property after removing the root:
+  // 1. Move the last element in the heap into the root position.
+  // 2. If either child of the root is greater than it,
+  // swap the root with the child of greater value.
+  // 3. Continue swapping until the parent is greater than both
+  // children or you reach the last level in the tree.
+
+  remove() {
+    // save the root value element because this method will return it
+    const removed = this.heap[1];
+    // the last element of the array is moved to the root position
+    this.heap[1] = this.heap[this.heap.length - 1];
+    // the last element is removed from the array
+    this.heap.splice(this.heap.length - 1, 1);
+
+    const place = (index) => {
+      if (index === this.heap.length - 1) return;
+      const child1Index = 2 * index;
+      const child2Index = child1Index + 1;
+      const child1 = this.heap[child1Index];
+      const child2 = this.heap[child2Index];
+      let newIndex = index;
+      // if the parent is greater than its two children
+      // then the heap property is respected
+      if (
+        (!isDefined(child1) || this.heap[newIndex] >= child1) &&
+        (!isDefined(child2) || this.heap[newIndex] >= child2)
+      ) {
+        return;
+      }
+      // test if the parent is less than its left child
+      if (isDefined(child1) && this.heap[newIndex] < child1) {
+        newIndex = child1Index;
+      }
+      // test if the parent is less than its right child
+      if (isDefined(child2) && this.heap[newIndex] < child2) {
+        newIndex = child2Index;
+      }
+      // the parent is switched with the child of the biggest value
+      if (index !== newIndex) {
+        [this.heap[index], this.heap[newIndex]] = [
+          this.heap[newIndex],
+          this.heap[index],
+        ];
+        place(newIndex);
+      }
+    };
+    // start tests from the beginning of the array
+    place(1);
+    return removed;
+  };
+
+  // Sort an array using a max heap
+  // the elements of the array to sort were previously added one by one
+  // to the heap using the insert method
+  // the sorted array is the result of removing the heap's elements one by one
+  // using the remove method until it is empty
+  sort() {
+    const arr = [];
+    while (this.heap.length > 1) {
+      arr.push(this.remove());
+    }
+    return arr;
+  };
+  // Verify the heap property of a given max heap
+  verifyHeap() {
+    const explore = (index) => {
+      if (index === this.heap.length - 1) return true;
+      const child1Index = 2 * index;
+      const child2Index = 2 * index + 1;
+      const child1 = this.heap[child1Index];
+      const child2 = this.heap[child2Index];
+      return (
+        (!isDefined(child1) ||
+          (this.heap[index] >= child1 && explore(child1Index))) &&
+        (!isDefined(child2) ||
+          (this.heap[index] >= child2 && explore(child2Index)))
+      );
+    };
+    return explore(1);
+  };
+}
+
+const test = new MaxHeap();
+test.insert(1);
+test.insert(3);
+test.insert(0);
+test.insert(10);
+test.insert(35);
+test.insert(25);
+test.insert(47);
+test.insert(15);
+// display heap elements
+console.log(test.print());
+// verify heap property
+console.log(test.verifyHeap());
+// display the sorted array
+console.log(test.sort());

algorithms/JavaScript/src/index.js

@@ -4,6 +4,12 @@ require('./arrays/counting-inversions');
 // Linked Lists
 require('./linked-lists/singly');
 
+// Maths
+require('./maths/fibonacci-series');
+
+// Recursion
+require('./recursion/factorial');
+
 // Searching
 require('./searching/binary-search-recursive');
 require('./searching/binary-search');
@@ -22,7 +28,7 @@ require('./strings/sequence');
 
 // Stack
 require('./stacks/stack');
-require('./stacks/two-stack')
+require('./stacks/two-stack');
 
 // Queue
 require('./queues/queue');

algorithms/JavaScript/src/maths/fibonacci-series.js

@@ -0,0 +1,24 @@
+// algorithm to generate first n numbers of fibonacci series
+// Time complexity: O(n)
+
+function fibonacci(n) {
+  // Initialize array 'series'
+  // with the first two numbers of the fibonacci series [0, 1]
+  const series = [0, 1];
+  for (let i = 3; i <= n; i++) {
+    // starting from the third number, and stopping at number n
+    const num1 = series[series.length - 1];
+    // num1 is the last number of the series
+    const num2 = series[series.length - 2];
+    // num2 is the second-to-last number of the series
+    const next = num1 + num2;
+    // next number is the sum of the last two
+    series.push(next);
+    // add number to list
+  }
+  // return list
+  return series;
+}
+
+console.log(fibonacci(10));
+// output: [0, 1,  1,  2,  3, 5, 8, 13, 21, 34]

algorithms/JavaScript/src/recursion/factorial.js

@@ -0,0 +1,17 @@
+// algorithm to calculate factorial of positive integer n
+// Time complexity: O(n)
+
+function factorial(n) {
+  // Error handling
+  // if n is negative or not an integer return string with error message
+  if (n < 0) return 'Only positive numbers allowed';
+  if (!Number.isInteger(n)) return 'Only integers allowed';
+  // if n is a positive integer
+  // base case: we reach 0, return 1
+  if (n === 0) return 1;
+  // until we reach 0 we keep multiplying n by the factorial of n - 1
+  return n * factorial(n - 1);
+}
+
+console.log(factorial(5));
+// output: 120

algorithms/Python/README.md

@@ -5,11 +5,15 @@
 - [Majority Element](arrays/majority_element.py)
 - [Rotate Array](arrays/rotate_array.py)
 - [Missing Number](arrays/missing_number.py)
+- [Remove duplicate items](arrays/remove_duplicates_list.py)
+- [Dutch National Flag Algorithm](arrays/dutch_national_flag_algo.py)
 
 ## Linked Lists
 - [Doubly](linked_lists/doubly.py)
 - [Singly](linked_lists/singly.py)
 - [Reverse List](linked_lists/reverse-linkedlist.py)
+- [Middle Node](linked_lists/middle-node-linkedlist.py)
+
 
 ## Dictionaries
 - [Two Sum](dictionaries/two-sum.py)
@@ -21,6 +25,9 @@
 - [Factorial](recursion/factorial.py)
 - [n-th Fibonacci number](recursion/nth_fibonacci_number.py)
 - [Recursive Insertion Sort](recursion/recursive_insertion_sort.py)
+- [Recursive Sum of n numbers](recursion/recursive-sum-of-n-numbers.py)
+- [GCD by Euclid's Algorithm](recursion/gcd_using_recursion.py)
+
 
 ## Scheduling
 - [Interval Scheduling](scheduling/interval_scheduling.py)
@@ -31,6 +38,8 @@
 - [Linear Search](searching/linear_search.py)
 - [Ternary Search](searching/ternary_search.py)
 - [Interpolation Search](searching/interpolation_search.py)
+- [Uniform Cost Search](searching/uniform_cost_search.py)
+- [Breath First Search](searching/breadth-first-search.py)
 
 ## Sorting
 - [Bubble Sort](sorting/bubble_sort.py)
@@ -53,6 +62,8 @@
 - [Longest Common Subsequence](strings/longest_common_subsequence.py)
 - [Unique Character](strings/unique_character.py)
 - [Add String](strings/add_string.py)
+- [Rabin Karp algorithm](strings/rabin-karp-algorithm.py)
+- [Find all permutations](strings/find_all_permutations.py)
 
 ## Dynamic Programming
 - [Print Fibonacci Series Up To N-th Term](dynamic_programming/fibonacci_series.py)
@@ -60,11 +71,19 @@
 - [N-th Term Of Fibonacci Series](dynamic_programming/fibonacci_series_nth_term.py)
 - [Catalan Sequence](dynamic_programming/catalan_sequence.py)
 - [0/1 Knapsack Problem](dynamic_programming/knapsack.py)
+- [Levenshtein distance](dynamic_programming/levenshtein_distance.py)
 
 ## Graphs
 - [Simple Graph](graphs/graph.py)
+- [BFS SEQUENCE](graphs/bfs-sequence.py)
+- [Depth First Search](graphs/depth-first-search.py)
 
 ## Trees
 - [Binary Tree](trees/binary_tree.py)
 - [Binary Search Tree](trees/binary_search_tree.py)
 
+## Queues
+- [First in First out Queue](queues/fifo-queue.py)
+
+## Number Theory
+- [Prime Number Checker](number_theory/prime_number.py)

algorithms/Python/arrays/dutch_national_flag_algo.py

@@ -0,0 +1,39 @@
+"""
+Algorithm Type: Array sorting with 0s,1s and 2s in a single pass
+Explain: To separate three different groups
+Time Complexity: O(n)
+Space Complexity: O(1)
+
+    0 0 1 1 1 ? ? ? ? 2 2
+        |     |     |
+        v     v     v
+       Low   Mid   High
+
+   To goal of the algo is to shrink this '?' region
+   wrapped by Mid and High
+
+   > Low starts at 1
+"""
+
+numbers = [2, 0, 1, 1, 2, 0, 1, 2]
+
+
+def DNFS(numbers: list) -> list:
+    length = len(numbers)
+    low = 0
+    high = length - 1
+    mid = 0
+    while mid <= high:
+        if numbers[mid] == 0:
+            numbers[low], numbers[mid] = numbers[mid], numbers[low]
+            low = low + 1
+            mid = mid + 1
+        elif numbers[mid] == 1:
+            mid = mid + 1
+        else:
+            numbers[mid], numbers[high] = numbers[high], numbers[mid]
+            high = high - 1
+    return numbers
+
+if __name__ == "__main__":
+    print(DNFS(numbers))

algorithms/Python/arrays/remove_duplicates_list.py

@@ -0,0 +1,33 @@
+"""
+Algorithm Type : Array Traversal
+Time Complexity : O(n)
+Space Complexity : O(1)
+"""
+
+sample_case = [0, 0, 1, 1, 1, 2, 2, 3, 3, 4]
+
+
+def make_distinct(values: list) -> list:
+    """
+    Remove duplicate elements in an array inplace without creating new array.
+
+    Here, we are iterating the list backwards instead of forward because if we
+    remove elements in an array it will cause some issues.
+
+    Note : Wrapped with * are sample.
+    """
+    # *length = 10*
+    length = len(values)
+    for index in range(len(values)):
+        # *index_position = 0 - 10*
+        # *index_position = -10*
+        index_position = index - length
+        if values[index_position] in values[0:index_position]:
+            values.remove(values[index_position])
+
+    return values
+
+
+if __name__ == "__main__":
+    print(make_distinct(sample_case))
+

algorithms/Python/dynamic_programming/levenshtein_distance.py

@@ -0,0 +1,41 @@
+# The Levenshtein distance (Edit distance) Problem
+
+# Informally, the Levenshtein distance between two words is
+# the minimum number of single-character edits (insertions, deletions or substitutions)
+# required to change one word into the other.
+
+# For example, the Levenshtein distance between kitten and sitting is 3.
+# The minimal edit script that transforms the former into the latter is:
+
+# kitten —> sitten (substitution of s for k)
+# sitten —> sittin (substitution of i for e)
+# sittin —> sitting (insertion of g at the end)
+
+def levenshtein_distance(word_1, chars_1, word_2, chars_2):
+    # base case if the strings are empty
+    if chars_1 == 0:
+        return chars_2
+    if chars_2 == 0:
+        return chars_1
+
+    # if last characters of the string match, the cost of
+    # operations is 0, i.e. no changes are made
+    if word_1[chars_1 - 1] == word_2[chars_2 - 1]:
+        cost = 0
+    else:
+        cost = 1
+
+    # calculating the numbers of operations recursively
+    deletion =  levenshtein_distance(word_1, chars_1 - 1, word_2, chars_2) + 1
+    insertion = levenshtein_distance(word_1, chars_1, word_2, chars_2 - 1) + 1
+    substitution = levenshtein_distance(word_1, chars_1 - 1, word_2, chars_2 - 1) + cost
+
+    return min(deletion, insertion, substitution)
+
+# driving script
+if __name__ == '__main__':
+    word_1 = 'plain'
+    word_2 = 'plane'
+
+    print('The Levenshtein distance is:')
+    print(levenshtein_distance(word_1, len(word_1), word_2, len(word_2)))

algorithms/Python/graphs/bfs-sequence.py

@@ -0,0 +1,78 @@
+"""
+BFS graph using Adjecency List
+-----------------------------------------------------------------------------------------
+-In Breadth First Search Sequence of any graph all children of a parent node 
+ is visited first and the children are stored in the QUEUE array and 
+ VISITED array.
+-Children of nodes in QUEUE are visited one by one and stored in the QUEUE and 
+ VISITED as well.
+-When all children of a node is visited that node is removed from the QUEUE.
+-These steps are repeated till all nodes in QUEUE are exhausted.
+-----------------------------------------------------------------------------------------
+-VISITED array is required to check if a node is already in BFS sequence or not.
+-QUEUE array is important for ensuring that all nodes and edges are visited.
+------------------------------------------------------------------------------------------
+The sequence of nodes printed in every recursion is the BFS-SEQUENCE
+------------------------------------------------------------------------------------------
+"""
+def ShowGraph(Adj_Dict: dict[int, list[int]])->None :  #displays graph
+   for i in Adj_Dict:
+       print(i,"->",Adj_Dict[i])
+   return
+def Display_BFS(curr:int ,Adj_Dict: dict[int, list[int]]) -> None: # displays BFS sequence
+   global rear
+   global front
+   print(curr,end=" ")
+   if curr in Adj_Dict :
+       if curr not in visited: 
+           visited.append(curr) 
+           queue.append(curr) 
+           rear+=1
+       for i in Adj_Dict[curr]: # iterate over all neighbours of curr
+           if i not in visited: 
+               queue.append(i)
+               visited.append(i)
+               rear+=1            
+   queue[front]=-1 # all nodes adjecent to curr are visited
+   front+=1
+   if front==rear: # no new node to visit
+       return
+   else:
+       Display_BFS(queue[front],Adj_Dict) # go to next node
+   return
+
+#__main__
+#Dry Run
+queue: list[int]=[]#: list[int]=[] #keeps order of BFS tree
+visited: list[int]=[] #: list[int]=[] #keeps visited node 
+# front and rear for accessing queue
+front=0
+rear=0
+#g is an adjecency list in form of dictionary
+g={1:[2,4],2:[4,5],4:[7,5],5:[1,3,6],6:[3,8],8:[7]} # this is directed graph
+# for undirected graph each edge has to be given twice
+# Eg:- edge from 1-2 input as {1:[2]}
+print("Display Graph")
+ShowGraph(g)
+print("BFS Sequence")
+Display_BFS(1,g) #passing start node
+'''
+---------------------------------
+OUTPUT:-
+Display Graph
+1 -> [2, 4]
+2 -> [4, 5]
+4 -> [7, 5]
+5 -> [3, 1, 6]
+6 -> [8, 3]
+8 -> [7]
+BFS Sequence
+1 2 4 5 7 3 6 8 
+----------------------------------
+TIME COMPLEXITY:
+-O(V+E) where V and E are number
+ of vertices and edges in graph 
+ respectively.
+-For Adjecency List Only!
+----------------------------------
+'''

algorithms/Python/graphs/depth-first-search.py

@@ -0,0 +1,62 @@
+# A dfs algorithm in Python
+# This is an algorithm for traversing a graph in depth first search manner
+# It is commonly used in tree/graph traversals
+# Time Complexity: O(V+E)
+# Space Complexity: O(V)
+# V is number of vertices and E is number of edges
+
+"""
+Refer the following example for output
+Graph 1: https://cdn.programiz.com/sites/tutorial2program/files/graph-dfs-step-0.png
+Graph 2: https://static.javatpoint.com/ds/images/depth-first-search-algorithm2.png
+
+"""
+
+def dfs(edges, vis, node):
+	if(vis[node]!=1):
+		vis[node] = 1
+		print(node, end = " ")
+	
+	for i in edges[node]:
+		if(vis[i]!=1):
+			dfs(edges, vis, i)
+
+
+def main():
+	""" Main Function """
+
+	#First example
+
+	graph1 = []
+	graph1.append([1,2,3])
+	graph1.append([0,2])
+	graph1.append([0,1,4])
+	graph1.append([0])
+	graph1.append([2])	
+
+	vis = []
+	for i in range(0,10):
+		vis.append(0)
+
+	print("DFS for Graph 1 is:")
+	dfs(graph1, vis, 0)
+
+	#Making visited list elements 0 for second graph
+	for i in range(0,10):
+		vis[i] = 0
+
+	graph2 = []
+	graph2.append([1, 2, 3])
+	graph2.append([3])
+	graph2.append([4])
+	graph2.append([5, 6])
+	graph2.append([5, 7])
+	graph2.append([2])
+	graph2.append([])
+	graph2.append([])
+
+	print("\n\nDFS for Graph 2 is:")
+	dfs(graph2, vis, 0)
+
+if __name__=="__main__":
+	main()

algorithms/Python/linked_lists/middle-node-linkedlist.py

@@ -0,0 +1,43 @@
+#printing middle node element of linked list
+#we are using two pointer method to get the solution
+
+class Node:
+    #Constructor to build node
+    def __init__(self, data):
+        self.data = data
+        self.next = None
+
+class LinkedList:
+    #Constructor to create head node
+    def __init__(self):
+        self.head = None
+
+    #Function to push element at head (at beginning)
+    def push(self, data):
+        new_node = Node(data)
+        new_node.next = self.head
+        self.head = new_node
+    
+    #Function returns data of middle node
+    def middle_element(self):
+        if self.head is None:
+            return None
+        slow = self.head
+        fast = self.head
+        while fast and fast.next:
+            slow = slow.next
+            fast = fast.next.next
+        return slow.data
+
+if __name__=='__main__':
+    ob = LinkedList()
+    ob.push(5)
+    ob.push(4)
+    ob.push(3)
+    ob.push(2)
+    ob.push(1)
+    print(ob.middle_element())
+    
+    #list: 1->2->3->4->5 Hence middle element is 3
+
+

algorithms/Python/linked_lists/singly.py

@@ -79,6 +79,58 @@ class LinkedList:
         self.head = node.next
         return node.data
     
+    def insertEnd(self, data):
+        '''
+        Insert node at the end of linked list
+        '''
+        node = Node(data)
+        if self.head is None:
+            self.head = node
+            return
+
+        # Linked list traversal
+        temp = self.head
+        while(temp.next is not None):
+            temp = temp.next
+
+        temp.next = node
+        return
+    
+    def deleteData(self, data):
+        '''
+        Delete first occurrence of given data
+        '''
+        temp = self.head
+        
+        # raise exception if linked list is empty
+        if temp is None:
+            raise Exception("Linked List is empty")
+
+        # if head node is deleted
+        if temp.data == data:
+            self.head = temp.next
+            temp = None
+            return
+
+        # search for data
+        # previous node data is stored
+        while(temp):
+            found = False
+            if temp.data == data:
+                found = True
+                break
+            prev = temp
+            temp = temp.next
+            
+        # raise exception if data not found
+        if not found:
+            raise Exception("Data not present")
+
+        # delete the link
+        prev.next = temp.next
+        temp = None
+        return
+
 
 if __name__ == '__main__':
     ll = LinkedList()
@@ -86,5 +138,8 @@ if __name__ == '__main__':
     ll.push('xyz')
     ll.push(1.1)
     ll.pop()
+    ll.insertEnd('END')
+    print(ll)
+    ll.deleteData(1)
     print(ll)
     print(list(ll))

algorithms/Python/number_theory/prime_number.py

@@ -0,0 +1,22 @@
+#TO CHECK WHETHER A NUMBER IS PRIME OR NOT
+
+
+def isPrime(N):
+        if N<=1:
+                return False
+        
+        for i in range(2, int(N**0.5) + 1):
+                if N%i==0:
+                        return False
+
+        return True
+
+# TIME COMPLEXITY - O(sqrt(N))
+
+# EXAMPLES
+# print(isPrime(3)) -> True
+# print(isPrime(15)) -> False
+
+# We are just checking till sqrt(N) as if their is any factor of a number
+# greater than sqrt(N) then it's partner will be less than sqrt(N) as if a*b>N
+# and a>=sqrt(N) then b<=sqrt(N) as if b>sqrt(N) then a*b>N.

algorithms/Python/queues/fifo-queue.py

@@ -0,0 +1,65 @@
+class FIFOqueue:
+
+    def __init__(self, item = 0) -> None:
+        """
+        creates the FIFOqueue object given an item,
+        will default to 0 if no item is passed.
+
+        firstNum: any
+        """
+        self.arr = [item]
+        
+
+    def enqueue(self, n) -> None:
+        """
+        adds n to the end of the queue in O(1) time
+
+        n: Any
+        """
+        self.arr.append(n)
+
+    def dequeue(self):
+        """
+        removes the first element from the queue and returns it in O(1) time
+        """
+        return self.arr.pop(0)
+    
+    def front(self):
+        """
+        returns the first element of the queue in O(1) time
+        """
+        return self.arr[0]
+    
+    def rear(self):
+        """
+        returns the last element of the queue in O(1) time
+        """
+        return self.arr[-1]
+
+# main
+if __name__ == '__main__':
+    exampleFIFO = FIFOqueue(1)
+    # now our queue should look like [1] after initialization
+    print(f"queue after initialization: {exampleFIFO.arr}")
+
+    exampleFIFO.enqueue(5)
+    # now our queue should look like [1, 5]
+    print(f"queue after enqueueing 5: {exampleFIFO.arr}")
+
+    print(f"If we dequeue, we are removing {exampleFIFO.dequeue()} from the queue")
+    # now our queue should look like [5]
+    print(f"queue after dequeue: {exampleFIFO.arr}")
+
+    exampleFIFO.enqueue(7)
+    # now our queue should look like [5, 7]
+    print(f"queue after enqueueing 7: {exampleFIFO.arr}")
+
+    exampleFIFO.enqueue(8)
+    # now our queue should look like [5, 7, 8]
+    print(f"queue after enqueueing 8: {exampleFIFO.arr}")
+
+    # front
+    print(f"If we try looking at the front of the queue we get: {exampleFIFO.front()}")
+
+    #rear
+    print(f"If we try looking at the rear of the queue we get: {exampleFIFO.rear()}")

algorithms/Python/recursion/gcd_using_recursion.py

@@ -0,0 +1,23 @@
+#EUCLIDS ALGORITHM 
+
+def gcd(a, b):
+	if a<0:
+		a = -a  
+	if b<0:
+		b = -b
+	if b==0:
+		return a  
+	else:
+		return gcd(b, a%b)
+
+
+#TIME COMPLEXITY - O(log(min(a, b)))
+#EXAMPLES
+#print(gcd(10, 2)) -> 2
+#print(gcd(30, 15)) -> 3
+#print(gcd(-30, 15)) -> 3
+#WORKING
+#We are using the Euclidean Algorithm to calculate the GCD of a number
+#it states that if a and b are two positive integers then GCD or greatest common
+#divisors of these two numbers will be equal to the GCD of b and a%b or
+#gcd(a, b) = gcd(b, a%b) till b reaches 0

algorithms/Python/searching/breadth-first-search.py

@@ -0,0 +1,32 @@
+# this graph to check the algorithm
+graph={
+    'S':['B','D','A'],
+    'A':['C'],
+    'B':['D'],
+    'C':['G','D'],
+    'S':['G'],
+}
+#function of BFS
+def BFS(graph,start,goal):
+    Visited=[]
+    queue=[[start]]
+    while queue:
+        path=queue.pop(0)
+        node=path[-1]
+        if node in Visited:
+            continue
+        Visited.append(node)
+        if node==goal:
+            return path
+        else:
+            adjecent_nodes=graph.get(node,[])
+            for node2 in adjecent_nodes:
+                new_path=path.copy()
+                new_path.append(node2)
+                queue.append(new_path)
+
+
+
+
+Solution=BFS(graph,'S','G')
+print('Solution is ',Solution)                

algorithms/Python/searching/uniform_cost_search.py

@@ -0,0 +1,44 @@
+# this graph to check the algorithm
+graph={
+  'S':[('A',2),('B',3),('D',5)],
+  'A':[('C',4)],
+  'B':[('D',4)],
+  'C':[('D',1),('G',2)],
+  'D':[('G',5)],
+  'G':[],
+    }
+
+#to calculate the total cost of path
+def path_cost(path):
+    total_cost=0
+    for (node, cost) in path:
+        total_cost+=cost
+    return total_cost , path[-1][0]
+# well sort queue items based on total path
+#if two items have the same total_cost then sort by node name (alphabetically)
+
+# uniform cost search
+def UCS(graph, start, goal):
+    visited=[]
+    queue=[[(start,0)]]
+    while queue:
+        queue.sort(key=path_cost)#sorting by cost
+        path=queue.pop(0)#choosing least cost
+        node=path[-1][0]
+        if node in visited:
+            continue
+        visited.append(node)
+        if node==goal:
+            return path
+        else:
+            adjacent_nodes=graph.get(node,[])
+            for(node2,cost)in adjacent_nodes:
+                new_path=path.copy()
+                new_path.append((node2,cost))
+                queue.append(new_path)
+
+
+solution= UCS(graph,'S','G')
+print('solution is ' , solution)
+print ('cost of solution is ',path_cost(solution)[0])
+                

algorithms/Python/strings/find_all_permutations.py

@@ -0,0 +1,28 @@
+"""
+Find all the permutations of a given string
+Sample input: 'ABC'
+Expected output: ['ABC', 'ACB', 'BAC', 'BCA', 'CAB', 'CBA']
+Description: The algorithm is recursive. In each recursion, each element of the string (left) is removed and added to the beginning (head). This process is repeated until left is empty.
+Time complexity: (n!)
+"""
+
+def permutation(head, left, permutations):
+    if len(left) == 0:
+        permutations.append(head)
+    else:
+        for i in range(len(left)):
+            permutation(head+left[i], left[:i]+left[i+1:], permutations)
+
+def find_all_permutations(string):
+    permutations = []
+    permutation('', string, permutations)
+    return permutations
+
+if __name__ == "__main__": 
+    input = 'ABC'
+    output = find_all_permutations(input)
+
+    expected = ['ABC', 'ACB', 'BAC', 'BCA', 'CAB', 'CBA']
+    assert len(output) == len(expected), f"Expected 6 permutations, got: {len(expected)}"
+    for perm in expected:
+        assert perm in output, f"Expected permutation {perm} to be in output, missing"

algorithms/Python/strings/rabin-karp-algorithm.py

@@ -0,0 +1,98 @@
+'''
+String pattern matching algorithm which performs efficiently for large text and patterns
+
+Algorithm: 
+Rabin Karp works on the concept of hashing. If the substring of the given text 
+is same as the pattern then the corresponding hash value should also be same. Exploiting this idea 
+and designing a hash function which can be computed in O(m) time for both pattern and initial window 
+of text. The subsequent  window each will require only O(1) time. And we slide the window n-m times 
+after the initial window. Therefore the overall complexity of calculating hash function for text is O(n-m+1)
+Once the hash value matches, the underlying string is again checked with pattern for matching
+
+
+Complexity:
+    Best case:  O(n-m+1)
+    Worst case: O(nm)
+
+
+'''
+
+def rabin_karp(T: str, P: str, q: int ,d: int = 256) -> None :
+    '''
+    Parameters:
+    
+            T: string
+               The string where the pattern needs to be searched
+
+            P: string 
+               The pattern to be searched
+
+            q: int
+               An appropriately chosen prime number based on length of input strings
+               The higher the prime number, the lower the collisions and spurious hits
+               
+            d: int, default value 256
+               Denotes the no of unique character that is used for encoding
+    
+    
+
+    
+    
+    
+    Example:
+    
+    >>> pos = rabin_karp("AAEXCRTDDEAAFT","AA",101)
+    Pattern found at pos: 0
+    Pattern found at pos: 10
+    
+    '''
+    
+    n = len(T)   # length of text
+    m = len(P)   # length of pattern
+    p=0          # Hash value of pattern
+    t=0          # Hash value of text
+    
+    #Computing h: (h=d^m-1 mod q)
+    h=1
+    for i in range(1,m):
+        h = (h*d)%q
+    
+    #Computing hash value of pattern and initial window (of size m) of text
+    for j in range(m):
+        p = (d*p + ord(P[j])) % q
+        t = (d*t + ord(T[j])) % q
+    
+    
+    found = False
+    pos=[] # To store positions
+    
+    #Sliding window and matching
+    for s in range(n-m+1):
+        if p==t: # if hash value matches
+            if P == T[s:s+m]: # check for string match
+                pos.append(s)
+                if not found:
+                    found = True
+    
+        if s<n-m:
+            t = (d*(t-ord(T[s])*h) + ord(T[s+m])) % q # updating hash value of t for next window
+            if t<0:
+                t = t+q # To make sure t is positive integer
+    
+    if not found: # If pattern not found in text
+        pos.append(-1)
+        
+    #Printing results
+    if pos[0]==-1:
+        print("Pattern not found")
+    else:
+        for i in pos:
+            print(f"Pattern found at pos: {i}")
+
+
+
+if __name__ == "__main__":
+    T = "AAEXCRTDDEAAFT"
+    P = "AA"
+
+    rabin_karp(T,P,101)

docs/en/Lists/doubly-linked-list.md

@@ -0,0 +1,71 @@
+# Doubly Linked List
+
+A doubly linked list is a type of linked data structure that allows traversal in both directions (forward and backward directions). 
+It differs from singly linked list in that, singly linked list does not support backward traversal. 
+Every node in a doubly linked list contains a **data** part and two pointers; **next pointer** that points to the next node and the **prev pointer** that points to the previous node in the list. 
+A doubly linked list also has two dummy nodes (head and tail) known as **sentinels** (guard nodes) that contains no data of the sequence. 
+The first element of a doubly linked list has its prev pointer pointing to head and the last element has its next node pointing to tail. 
+
+Without a tail pointer, you cannot directly access the last element without having to first traverse the entire list all the way from the beginning. 
+
+## Steps to create a doubly linked list
+To create an empty list,
+- create head and tail nodes (nodes without data) first
+- let the **next pointer** of the head point to the tail node
+- let the **prev pointer** of the tail point to the head node.
+
+For a non-empty list,
+- let the next pointer of the head point to the first real element of the sequence
+- let the prev pointer of the tail point to the last real element of the sequence
+
+## Key operations
+- Insertion (insert at the beginning, at the end or anywhere in the middle)
+- deletion (delete from beginning, end or anywhere in the middle)
+
+To add an element(node) at the beginning of the list, let the;
+- *next pointer* of the new element (node) point to the first element (the one the *head* currently points to)
+- *next pointer* of the *head* point to this new element you want to add
+- *prev pointer* of the element (node) you want to add point to *head*.
+
+To add an alement (node) to the end of the list, let the;
+- *prev pointer* of the new element you want to add point to the last element (the one before the *tail*)
+- *next pointer* of the last element (the one before the *tail*) point to the new element you want to add
+- *prev pointer* of the *tail* point to the new element.
+
+To delete an element from the beginning, let the;
+- *next pointer* of the *head* point to the second element in the list (node after the one *head* pointers to). 
+- *prev pointer* of the second element point to the *head*
+ 
+
+To delete from the end of the list, let the;
+- *prev pointer* of the *tail* point to the element before the last node
+- *next pointer* of the element before the last node point to the *tail*
+
+Note: If there is only one element in the list, deletion from both directions happens by pointing the *next pointer* of *head* to *tail* and *prev pointer* of *tail* to *head*. 
+
+Deletion anywhere in the middle happens by letting the *prev pointer* and the *next pointer* of the node after and before the one you want to delete point to each other respectively.
+
+To insert anywhere in the middle, let the;
+- *next pointer* of the element you want to insert point to the node at the position you want to insert it
+- *prev pointer* of the element you want to insert point to node before the position you want to insert it
+- *prev pointer* of the node at the position you want to insert point to the new element
+- *next pointer* of the node before the position you want to insert point to the new element.
+
+Deletion and insertion at the beginning or end of the list is a constant operation and has a O(1) runtime. Deletion or insertion anywhere in the middle however has a O(n) runtime. 
+
+
+## Implementation
+
+- [C++](../../../algorithms/C/linked-lists/doubly-linked-list.c)
+- [Java](../../../algorithms/CPlusPlus/Linked-Lists/doubly.cpp)
+- [JavaScript](../../../algorithms/Java/linked-lists/doubly.java)
+- [Python](../../../algorithms/Python/linked_lists/doubly.py)
+
+## Video URL
+
+[Doubly linked list](https://www.youtube.com/watch?v=nquQ_fYGGA4)
+
+
+## References
+
+[Goodrich, T. M., Tamassia, R., Goldwasser, M.H.(2014). *Data Structures & Algorithms in Java* (6th ed.). Wiley](https://www.wiley.com/en-us/Data+Structures+and+Algorithms+in+Java,+6th+Edition-p-9781118771334)

docs/en/Lists/singly-linked-list.md

@@ -0,0 +1,89 @@
+# Singly Linked List
+
+A linked structure is a collection of nodes storing data and links to other nodes. In this way, nodes can be located anywhere in memory, 
+and passing from one node of the linked structure to another is accomplished by storing the addresses of other nodes in the linked structure.
+
+If a node contains a data member that is a pointer to another node, then many nodes can be strung together using only one variable to access 
+the entire sequence of nodes. Such a sequence of nodes is the most frequently used implementation of a linked list, which is a data structure 
+composed of nodes, each node holding some information and a pointer to another node in the list. If a node has a link only to its successor 
+in this sequence, the list is called a singly linked list.
+
+A node includes two data members: **info** and **next**. The info member is used to store information, and this member is important to the user. 
+The next member is used to link nodes to form a linked list. It is an auxiliary data member used to maintain the linked list. It is indispensable 
+for implementation of the linked list, but less important (if at all) from the user’s perspective.
+
+
+## Steps
+
+- New node is created.
+- The number(data) is assigned to the info member of this node.
+- null is assigned to next member of this node.
+- The new node is included in the list by making the next member of the first node a pointer to the new node.
+
+
+## Example
+
+Now, let us create the three-nod linked list as an example. One way to create this three-node linked list is to first  generate the node for number 
+8(our first data), then the node for 5(our second data), and finally the node for 2(our last data).
+
+*pointer is represents our successor.
+
+- In the first step, a new Node is created
+
+  Pointer : pointer to first node. 
+  
+  pointer->info :		
+  
+  pointer->next :
+  
+- in the second step, the info member of this node is set to 8, and, the node’s next member is set to null. 
+
+  pointer : pointer to first node.
+
+  pointer->info : 8	
+
+  pointer->next : null
+
+- in the third step, new node is created and the info member of this node is set to 5, and, the node’s next member is set to null. 
+
+  pointer : pointer to first node. 	
+
+  pointer->info : 8	
+
+  pointer->next : pointer to next node.
+
+  Pointer->next->info : 5
+
+  Pointer->next->next : null
+
+- in the fourth step, new node is created and the info member of this node is set to 2, and, the node’s next member is set to null. 
+
+  pointer : pointer to first node. 	
+
+  pointer->info : 8	
+
+  pointer->next : pointer to next node.
+
+  Pointer->next->info : 5
+
+  pointer->next->next : pointer to next node.
+
+  pointer->next->next->info : 2
+
+  pointer->next->next->next : null
+
+## Implementation
+
+- [C++](../../../algorithms/CPlusPlus/Linked-Lists/singly.cpp)
+- [Java](../../../algorithms/Java/linked-lists/singly.java)
+- [JavaScript](../../../algorithms/JavaScript/src/linked-lists/singly.js)
+- [Python](../../../algorithms/Python/linked_lists/singly.py)
+
+## Video URL
+
+[Watch Linear Search Implementation](https://www.youtube.com/watch?v=HB7TcYklBHY)
+
+
+## References
+
+["Adam Drozdek", "Data Structures and Algorithms in C++", "Fourth Edition".](https://www.ebay.com/itm/Data-Structures-and-Algorithms-in-C-by-Adam-Drozdek-Fourth-Edition-/254763347609)

docs/en/README.md

@@ -1,5 +1,9 @@
 # Algorithms
 
+## Lists
+- [Singly linked list](./Lists/singly-linked-list.md)
+- [Doubly linked list](./Lists/doubly-linked-list.md)
+
 ## Sorting
 
 - [Bubble Sort](./Sorting/Bubble-Sort.md)
@@ -8,6 +12,7 @@
 - [Insertion Sort](./Sorting/Insertion-Sort.md)
 - [Heap Sort](./Sorting/Heap-Sort.md)
 - [Quick Sort](./Sorting/Quick-Sort.md)
+- [Cycle Sort](./Sorting/Cycle-Sort.md)
 
 ## Strings
 

docs/en/Sorting/Cycle-Sort.md

@@ -0,0 +1,91 @@
+# Cycle Sort
+
+Cycle sort is a comparison sorting algorithm that forces array to be factored into the number of cycles where each of them can be rotated to produce a sorted array. It is theoretically optimal in the sense that it reduces the number of writes to the original array.
+It is an in-place and unstable sorting algorithm.
+
+Time Complexity : O(n^2) 
+- Worst Case : O(n^2) 
+- Average Case: O(n^2) 
+- Best Case : O(n^2)
+
+Space complexity :
+The space complexity is constant cause this algorithm is in place so it does not use any extra memory to sort.
+Auxiliary space: O(1)
+
+## Steps
+
+Suppose there is an array **arr** with **n** distinct elements. Given an element **A**, we can find its index by counting the number of elements smaller than **A**.
+
+1. If the element is at its correct position, simply leave it as it is.
+2. Else, we have to find the correct position of **A** by counting the number of elements smaller than it. Another element **B** is replaced to be moved to its correct position. This process continues until we get an element at the original position of **A**.
+
+The above-illustrated process constitutes a cycle. Repeat this cycle for every element of the list until the list is sorted.
+
+## Example
+
+arr[] = {10, 5, 2, 3}
+
+ index =  0   1   2   3
+
+cycle_start = 0 
+
+item = 10 = arr[0]
+
+Find position where we put the item  
+
+pos = cycle_start
+
+i=pos+1
+
+while(i < n)
+
+if (arr[i] < item) 
+
+    pos++;
+
+We put 10 at arr[3] and change item to 
+old value of arr[3].
+
+arr[] = {10, 5, 2, 10} 
+
+item = 3 
+
+Again rotate rest cycle that start with index '0' 
+
+Find position where we put the item = 3 
+
+we swap item with element at arr[1] now 
+
+arr[] = {10, 3, 2, 10} 
+
+item = 5
+
+Again rotate rest cycle that start with index '0' and item = 5 
+
+we swap item with element at arr[2].
+
+arr[] = {10, 3, 5, 10 } 
+
+item = 2
+
+Again rotate rest cycle that start with index '0' and item = 2
+
+arr[] = {2, 3,  5, 10}  
+
+Above is one iteration for cycle_stat = 0.
+
+Repeat above steps for cycle_start = 1, 2, ..n-2
+
+## Implementation
+
+- [C++](../../../algorithms/CPlusPlus/Sorting/cycle-sort.cpp)
+- [Java](../../../algorithms/Java/sorting/cyclic-sort.java)
+- [Python](../../../algorithms/Python/sorting/count-sort.py)
+
+## Video URL
+
+[Youtube Video about Cycle Sort](https://youtu.be/gZNOM_yMdSQ)
+
+## Other
+
+[Wikipedia](https://en.wikipedia.org/wiki/Cycle_sort)

docs/en/Sorting/Radix-Sort.md

@@ -0,0 +1,75 @@
+# Radix Sort
+
+Radix sort is a sorting algorithm that sorts the elements by first grouping the individual digits of the same place value. Then, sort the elements according to their increasing/decreasing order.
+
+Radix Sort's time complexity is O(n * x), where n is the size of the array and 'x' is the number of digits in the largest number.
+
+## Steps
+
+1. Finds the largest element in the array and calculates the number of digits in it. Number of digits in the largest element are calculated as it is required to go through all the significant places of all elements.
+
+2. Goes through each significant place one by one. 
+
+3. Uses Counting Sort to sort the digits at each significant place. 
+ 
+4. Repeats "Step-3" until it sorts the elements based on the digits at last place.
+
+## Example
+
+Given array is
+```
+[ 121, 432, 564, 23, 1, 45, 788 ]
+```
+
+Sorted array is
+```
+[ 1, 23, 45, 121, 432, 564, 788 ]
+```
+
+
+**FIRST PASS**
+
+- Sorts the elements based on the unit place digits.
+
+![image](https://user-images.githubusercontent.com/93431609/161891635-8edf89ec-2ca7-43b5-95ca-23b75f5846bb.png)
+
+After first pass array looks like..
+```
+[ 121, 1, 432, 23, 564, 45, 788 ]
+```
+
+**SECOND PASS**
+
+- Sorts the elements based on digits at tens place.
+
+![image](https://user-images.githubusercontent.com/93431609/161892564-64b20349-4064-4125-836d-adbdfb517bbd.png)
+
+After second pass array looks like..
+```
+[ 1, 121, 23, 432, 45, 564, 788 ]
+```
+
+**THIRD PASS**
+
+- Finally, sorts the elements based on the digits at hundreds place.
+
+![image](https://user-images.githubusercontent.com/93431609/161893373-3915ae95-28e9-4b02-bc35-5921b5280f84.png)
+
+After third pass array looks like..
+```
+[ 1, 23, 45, 121, 432, 564, 788 ]
+```
+
+## Implementation
+
+- [C](algorithms/C/sorting/radix-sort.c)
+- [C++](algorithms/CPlusPlus/Sorting/radix-sort.cpp)
+- [Python](algorithms/Python/sorting/radix_sort.py)
+
+## Video URL
+
+[Youtube Video about Radix Sort](https://www.youtube.com/watch?v=XiuSW_mEn7g)
+
+## Others
+
+[Wikipedia](https://en.wikipedia.org/wiki/Radix_sort)

docs/es/CONTRIBUTING.md

@@ -0,0 +1,30 @@
+# Nombre del algoritmo
+
+Escribe una breve descripción del algoritmo como:
+
+1. Complejidad temporal
+2. Complejidad espacial
+3. Aplicaciones
+4. Nombre del creador
+5. etc...
+
+## Pasos
+
+Describe el algoritmo como pasos simples, claros y entendibles.
+
+## Ejemplo
+
+Provee al algoritmo de datos de entrada de muestra.
+
+## Implementación
+
+Enlaces a sus implementaciones en lenguajes de programación.
+NOTA: El enlace debe estar solo dentro de la carpeta algorithms.
+
+## URL del video
+
+Adjunta una URL a un video que explique el algoritmo.
+
+## Otro
+
+Cualquier otra información es siempre bienvenida y debería ser incluida en esta sección.

docs/es/Ordenamiento/Bubble-Sort.md

@@ -0,0 +1,60 @@
+# Ordenamiento de Burbuja
+
+Bubble Sort, también conocido como Sinking Sort, es el algoritmo de clasificación más simple. Intercambia los números si no están en el orden correcto. La complejidad del tiempo en el peor de los casos es O(n^2)
+
+## Pasos
+
+1. Compara el primer elemento con el siguiente elemento.
+2. Si el primer elemento es más grande que el siguiente, los elementos se intercambian.
+3. Se realiza el paso 2 hasta que el número seleccionado se coloca en su posición correcta y luego se compara el siguiente elemento.
+4. Se realizan varias pasadas hasta que se completa la clasificación.
+
+## Ejemplo
+
+Dado el arreglo:
+**5 1 4 2 8**
+
+La arreglo ordenado es
+**1 2 4 5 8**
+
+Pasos
+**Primer vuelta**
+
+- ( **5 1** 4 2 8 ) → ( **1 5** 4 2 8 ), Aquí, el algoritmo compara los dos primeros elementos y los intercambia desde 5 > 1.
+- ( 1 **5 4** 2 8 ) → ( 1 **4 5** 2 8 ), Intercambia desde 5 > 4
+- ( 1 4 **5 2** 8 ) → ( 1 4 **2 5** 8 ), Intercambia desde 5 > 2
+- ( 1 4 2 **5 8** ) → ( 1 4 2 **5 8** ), Ahora, dado que estos elementos ya están en orden (8 > 5), el algoritmo no los intercambia.
+
+**Segunda vuelta**
+
+- ( **1 4** 2 5 8 ) → ( **1 4** 2 5 8 )
+- ( 1 **4 2** 5 8 ) → ( 1 **2 4** 5 8 ), Intercambia desde 4 > 2
+- ( 1 2 **4 5** 8 ) → ( 1 2 **4 5** 8 )
+- ( 1 2 4 **5 8** ) → ( 1 2 4 **5 8** )
+
+Ahora, el arreglo ya está ordenado, pero el algoritmo no sabe si está completo. El algoritmo necesita una vuelta completa adicional sin ningún intercambio para saber que está ordenado.
+
+**Tercera vuelta**
+
+- ( **1 2** 4 5 8 ) → ( **1 2** 4 5 8 )
+- ( 1 **2 4** 5 8 ) → ( 1 **2 4** 5 8 )
+- ( 1 2 **4 5** 8 ) → ( 1 2 **4 5** 8 )
+- ( 1 2 4 **5 8** ) → ( 1 2 4 **5 8** )
+
+## Implementación
+
+- [C](../../../algorithms/C/sorting/bubble-sort.c)
+- [C++](../../../algorithms/CPlusPlus/Sorting/bubble-sort.cpp)
+- [CSharp](../../../algorithms/CSharp/src/Sorts/bubble-sort.cs)
+- [Go](../../../algorithms/Go/sorting/bubble-sort.go)
+- [Java](../../../algorithms/Java/sorting/bubble-sort.java)
+- [JavaScript](../../../algorithms/JavaScript/src/sorting/bubble-sort.js)
+- [Python](../../../algorithms/Python/sorting/bubble_sort.py)
+
+## URL del video
+
+[Video de Youtube acerca de Bubble Sort](https://www.youtube.com/watch?v=vnnL17I7pIY)
+
+## Otros
+
+[Wikipedia](https://es.wikipedia.org/wiki/Ordenamiento_de_burbuja)

docs/es/Ordenamiento/Merge-Sort.md

@@ -0,0 +1,35 @@
+# Merge Sort
+
+Merge Sort es un algoritmo "Divide y venceras". Divide la matriz de entrada en dos mitades, se llama a sí mismo para cada una de ellas y luego fusiona las dos mitades ordenadas.
+
+## Pasos
+
+1. Encuentra el punto medio para dividir la matriz en dos mitades.
+2. Llama a mergeSort para la primera mitad.
+3. Llama a mergeSort para la segunda mitad.
+4. Combina las dos mitades ordenadas en los pasos 2 y 3.
+
+## Ejemplo
+
+Dado el arreglo:
+**12 11 13 5 6 7**
+
+El arreglo ordenado es
+**5 6 7 11 12 13**
+
+## Implementación
+
+- [Java](../../../algorithms/Java/sorting/merge-sort.java)
+- [C](../../../algorithms/C/sorting/merge-sort.c)
+- [C++](../../../algorithms/CPlusPlus/Sorting/merge-sort.cpp)
+- [JavaScript](../../../algorithms/JavaScript/src/sorting/merge-sort.js)
+- [Python](../../../algorithms/Python/sorting/merge_sort.py)
+- [C#](../../../algorithms/CSharp/src/Sorts/merge-sort.cs)
+
+## URL del video
+
+[Video de Youtube acerca de Merge Sort](https://www.youtube.com/watch?v=jlHkDBEumP0)
+
+## Otros
+
+[Wikipedia](https://en.wikipedia.org/wiki/Merge_sort)

docs/es/Ordenamiento/Quick-Sort.md

@@ -0,0 +1,58 @@
+# Quick Sort
+
+1. **Complejidad temporal:** O(n^2) ocurre cuando el pivote elegido es siempre un elemento extremo (el más pequeño o el más grande).
+2. **Complejidad espacial:** O(n).
+3. **Aplicaciones:** Computación comercial, búsqueda de información, investigación de operaciones, simulación dirigida por eventos, cómputos numéricos, búsqueda combinatoria.
+4. **Nombre del creador:** Tony Hoare
+
+## Pasos
+
+1. Considera el último elemento de la lista como pivote.
+2. Define dos variables i y j. Asigna i y j al primer y último elemento de la lista.
+3. Incrementa i hasta que lista[i] > pivote y luego detente.
+4. Disminuye j hasta que lista[j] < pivote y luego detente.
+5. Si i < j, entonces intercambia lista[i] y lista[j].
+6. Repite los pasos 3, 4 y 5 hasta que i > j.
+7. Intercambia el elemento pivote con el elemento lista[j].
+
+## Ejemplo
+
+**Dado el vector: [10, 80, 30, 90, 40, 50, 70]**
+
+**Pivote (último elemento) : 70**
+
+**1. 10 < 70 entonces i++ e intercambia(lista[i], lista[j]):** [10, 80, 30, 90, 40, 50, 70]
+
+**2. 80 < 70, entonces no es necesario hacer nada:** [10, 80, 30, 90, 40, 50, 70]
+
+**3. 30 < 70 entonces i++ e intercambia(lista[i], lista[j]):** [10, 30, 80, 90, 40, 50, 70]
+
+**4. 90 < 70, entonces no es necesario hacer nada:** [10, 30, 80, 90, 40, 50, 70]
+
+**5. 40 < 70 entonces i++ e intercambia(lista[i], lista[j]):** [10, 30, 40, 90, 80, 50, 70]
+
+**6. 50 < 70 entonces i++ e intercambia(lista[i], lista[j]):** [10, 30, 40, 50, 80, 90, 70]
+
+**7. Intercambia lista[i+1] y el pivote:** [10, 30, 40, 50, 70, 90, 80]
+
+**8. Aplica Quick Sort a la parte izquierda del pivote:** [10, 30, 40, 50]
+
+**9. Aplica Quick Sort a la parte derecha del pivote:** [70, 80, 90]
+
+**10. Vector ordenado:** [10, 30, 40, 50, 70, 80, 90]
+
+## Implementación
+
+- [Java](../../../algorithms/Java/sorting/quick-sort.java)
+- [JavaScript](../../../algorithms/JavaScript/src/sorting/quick-sort.js)
+- [Go](../../../algorithms/Go/sorting/quicksort.go)
+- [C++](../../../algorithms/CPlusPlus/Sorting/quick-sort.cpp)
+- [Python](../../../algorithms/Python/sorting/quicksort.py)
+- [C](../../../algorithms/C/sorting/quick-sort.c)
+## URL del video
+
+[Video de Youtube sobre Quick Sort](https://www.youtube.com/watch?v=DYmTpUfcyT8)
+
+## Otro
+
+[Wikipedia](https://es.wikipedia.org/wiki/Quicksort)

docs/es/README.md

@@ -0,0 +1,10 @@
+# Algoritmos
+
+## Ordenamiento
+- [Ordenamiento de burbuja](./Ordenamiento/Bubble-Sort.md)
+- [Ordenar por fusión](./Ordenamiento/Merge-Sort.md)
+- [Ordenación rápida](./Ordenamiento/Quick-Sort.md)
+
+## Otro
+
+[Cómo agregar nueva documentación a un algoritmo?](./CONTRIBUTING.md)

docs/ja/README.md

@@ -1,4 +1,10 @@
 # アルゴリズム
+
+## ソート
+
+- [バブルソート](./Sorting/Bubble-Sort.md)
+- [挿入ソート](./Sorting/Insertion-Sort.md)
+
 ## 文字列
 - [回文](./Strings/Palindrome.md)
 

docs/ja/Sorting/Bubble-Sort.md

@@ -0,0 +1,60 @@
+# バブルソート
+
+シンキングソートとも呼ばれるバブルソートは、最もシンプルなソートアルゴリズムである。数値の順序が正しくない場合に、数値を入れ替える。最悪計算量はO(n^2)だ。
+
+## ステップ
+
+1. 最初の要素と次の要素を比較する。
+2. 最初の要素が次の要素より大きい場合、要素を入れ替える。
+3. 選択された数字が正しい位置に来るまで2.を実行し、次の要素を比較する。
+4. ソートが完了するまで何度も繰り返されます。
+
+## 例
+
+初期配列
+**5 1 4 2 8**
+
+ソート後配列
+**1 2 4 5 8**
+
+ステップ
+**1回目**
+
+- ( **5 1** 4 2 8 ) → ( **1 5** 4 2 8 ), ここで、アルゴリズムは最初の2つの要素を比較し、5 > 1なので入れ替える。
+- ( 1 **5 4** 2 8 ) → ( 1 **4 5** 2 8 ), 5 > 4なので入れ替える。
+- ( 1 4 **5 2** 8 ) → ( 1 4 **2 5** 8 ), 5 > 2なので入れ替える。
+- ( 1 4 2 **5 8** ) → ( 1 4 2 **5 8** ), これらの要素は順番通りのため(8 > 5)、アルゴリズムは入れ替えをしない。
+
+**2回目**
+
+- ( **1 4** 2 5 8 ) → ( **1 4** 2 5 8 )
+- ( 1 **4 2** 5 8 ) → ( 1 **2 4** 5 8 ), 4 > 2なので入れ替える。
+- ( 1 2 **4 5** 8 ) → ( 1 2 **4 5** 8 )
+- ( 1 2 4 **5 8** ) → ( 1 2 4 **5 8** )
+
+さて、配列はすでにソートされたが、アルゴリズムにはソートが完了したかわからない。アルゴリズムはソートが完了したことを知るために、入れ替えなしでさらにもう1回全体のチェックを必要とする。
+
+**3回目**
+
+- ( **1 2** 4 5 8 ) → ( **1 2** 4 5 8 )
+- ( 1 **2 4** 5 8 ) → ( 1 **2 4** 5 8 )
+- ( 1 2 **4 5** 8 ) → ( 1 2 **4 5** 8 )
+- ( 1 2 4 **5 8** ) → ( 1 2 4 **5 8** )
+
+## 実装
+
+- [C](../../../algorithms/C/sorting/bubble-sort.c)
+- [C++](../../../algorithms/CPlusPlus/Sorting/bubble-sort.cpp)
+- [CSharp](../../../algorithms/CSharp/src/Sorts/bubble-sort.cs)
+- [Go](../../../algorithms/Go/sorting/bubble-sort.go)
+- [Java](../../../algorithms/Java/sorting/bubble-sort.java)
+- [JavaScript](../../../algorithms/JavaScript/src/sorting/bubble-sort.js)
+- [Python](../../../algorithms/Python/sorting/bubble_sort.py)
+
+## 動画のURL
+
+[Youtube Video about Bubble Sort](https://www.youtube.com/watch?v=Jdtq5uKz-w4&ab_channel=mycodeschool)
+
+## その他
+
+[Wikipedia](https://en.wikipedia.org/wiki/Bubble_sort)

docs/ja/Sorting/Insertion-Sort.md

@@ -0,0 +1,66 @@
+# 挿入ソート　
+
+基本挿入法とも呼ばれる挿入ソートは、シンプルで実装が容易であり、最も安定しているソートアルゴリズムである。数値が正しい場所にない場合に、その数値を正しい位置に挿入する。平均、最悪計算量は共にO(n^2)である。
+
+挿入ソートを高速化したものとしてシェルソートがある。
+
+## ステップ
+
+1. 0番目の要素と1番目の要素を比較する。
+2. 0番目の要素が1番目の要素より大きい場合、要素を入れ替える。
+3. 2番目の要素と1つ前の要素を比較する。
+4. 2番目の要素が1つ前の要素より大きい場合、要素を入れ替える。
+5. 2番目の要素が正しい位置に来るまで2.と4.を実行する。
+6. ソートが完了するまで3.から5.を何度も繰り返す。
+
+## 例
+
+初期配列
+**1 4 3 9 5**
+
+ソート後配列
+**1 3 4 5 9**
+
+ステップ
+**1回目**
+
+- ( **1 4** 3 9 5 ) → ( **1 4** 3 9 5 ), ここでアルゴリズムは最初の２つの要素を比較し、順番通りのため(4 > 1), アルゴリズムは入れ替えをしない。
+
+**2回目**
+
+- ( 1 **4 3** 9 5 ) → ( 1 **3 4** 9 5 ), 4 > 3なので入れ替える。
+- ( **1 3** 4 9 5 ) →　( **1 3** 4 9 5 )
+
+ここで選択した要素が1つ前の要素よりも大きいため、アルゴリズムは選択した要素の次の要素に移る。(この配列の場合は3の次である4)
+
+**3回目**
+- ( 1 **3 4** 9 5 ) → ( 1 **3 4** 9 5 )
+
+**4回目**
+- ( 1 3 **4 9** 5 ) → ( 1 3 **4 9** 5 )
+
+**5回目**
+- ( 1 3 4 **9 5** ) → ( 1 3 4 **5 9** )
+- ( 1 3 **4 5** 9) → ( 1 3 **4 5** 9 )
+
+さて、この時点で配列はすでにソートされたが、まだ配列の最後の要素にたどり着いていない。アルゴリズムは配列の最後の要素を選択するまで続く。
+
+**6回目**
+- ( 1 3 4 **5 9** ) → ( 1 3 4 **5 9** )
+
+## 実装
+
+- [C](../../../algorithms/C/sorting/insertion-sort.c)
+- [C++](../../../algorithms/CPlusPlus/Sorting/insertion-sort.cpp)
+- [CSharp](../../../algorithms/CSharp/src/Sorts/insertion-sort.cs)
+- [Go](../../../algorithms/Go/sorting/insertion-sort.go)
+- [Java](../../../algorithms/Java/sorting/insertion-sort.java)
+- [JavaScript](../../../algorithms/JavaScript/src/sorting/insertion-sort.js)
+
+## 動画のURL
+
+[Youtube Video about Insertion Sort](https://www.youtube.com/watch?v=i-SKeOcBwko)
+
+## その他
+
+[Wikipedia](https://en.wikipedia.org/wiki/Insertion_sort)

docs/pt/CONTRIBUTING.md

@@ -0,0 +1,29 @@
+# Nome do Algoritmo
+
+Escrever uma breve descrição de características do algoritmo assim como:
+1. Complexidade de tempo
+2. Complexidade de espaço
+3. Aplicações
+4. Nome dos fundadores/criadores
+5. etc...
+
+## Passos
+
+Descreve o algoritmo de forma clara, simples e de modo que os passos sejam compreendidos por toda a gente.
+
+## Exemplos
+
+Ao dar exemplos, identifica o algoritmo com uma amostra de dados iniciais. E continua com eles ao fazer os passos.
+
+## Implementação
+
+A ligação(links) para a sua implementação na respetiva linguagem de programação.
+NOTA: A ligação(link) deve estar apenas dentro da pasta do algoritmo.
+
+## Video URL
+
+Anexa o URL de um vídeo que explica o algoritmo, deve ser em português. 
+
+## Outros
+
+Qualquer informação é sempre bem-vinda e deve ser incluída nesta secção.

docs/pt/Procura/Pesquisa-Binaria.md

@@ -0,0 +1,54 @@
+# Pesquisa Binária
+
+A **Pesquisa Binária**(em inglês Binary Search) é um algoritmo de pesquisa que encontra a posição de um valor dentro da matriz.
+
+1. Complexidade temporal: O(log n)
+2. Complexidade de espaço: O(1)
+3. Aplicações: Uma melhor aplicação quando os dados já estão organizados e temos bastantes
+4. Nome do fundador: P.F. Windley, A.D. Booth, A.J.T. Colin, e T.N. Hibbard
+5. É um dos algoritmos de pesquisa mais populares e usado diariamente.
+ 
+## Passos
+
+1. Encontrar o elemento do meio da matriz
+2. Verificar se o elemento que estamos a procurar é igual ao elemento do meio e se sim, retornar o índice e acabar o programa/função.
+3. Se o 2º passo não foi verificado, testamos se o elemento a procurar é menor que o elemento do meio, se sim voltamos para o passo 1 e usamos entre o início do matriz e o índice do elemento do meio -1.
+4. Se o 3º passo não foi verificado, testamos se o elemento a procurar é maior que o elemento do meio, se sim voltamos para o passo 1 e usamos entre o índice do elemento do meio +1 até ao último índice da matriz.
+5. Percorrer o ciclo até o índice inicial ser menor do que o índice final
+6. Se o ciclo acabar e nenhum dado for encontrado retornar -1, que significa que o elemento a procurar não existe na matriz dada.
+> **Nota:** A matriz deve estar organizada de forma crescente.
+
+## Exemplos
+
+Dados de Entrada: **10,20,30,40,50**
+
+Elemento para procurar: **20**
+
+Procedimento:
+
+Elemento do meio: **30** e o elemento a procurar é menor do que 30, logo a pesquisa vai passar a ser do início do matriz até ao índice do meio -1
+
+Logo em seguida o elemento do meio é o **20** e o elemento do meio é o elemento que estamos a procurar, logo retornar o índice **1**
+
+Dados de Saída: **1**
+
+## Implementações
+
+- [C](https://github.com/MakeContributions/DSA/blob/main/algorithms/C/searching/Binary-search.c)
+- [C++](https://github.com/MakeContributions/DSA/blob/main/algorithms/CPlusPlus/Searching/binary-search.cpp)
+- [CSharp](https://github.com/MakeContributions/DSA/blob/main/algorithms/CSharp/src/Search/binary-search.cs)
+- [Go](https://github.com/MakeContributions/DSA/blob/main/algorithms/Go/searching/binary-search.go)
+- [Java](https://github.com/MakeContributions/DSA/blob/main/algorithms/Java/searching/binary-search.java)
+- [JavaScript](https://github.com/MakeContributions/DSA/blob/main/algorithms/JavaScript/src/searching/binary-search.js)
+- [JavaScript](https://github.com/MakeContributions/DSA/blob/main/algorithms/JavaScript/src/searching/binary-search-recursive.js)
+- [Python](https://github.com/MakeContributions/DSA/blob/main/algorithms/Python/searching/binary_search.py)
+
+## Video URL
+
+[Video a explicar pesquisa binária](https://www.youtube.com/watch?v=5T1SDEZzCLo)
+
+## Outros
+
+[Wikipédia](https://pt.wikipedia.org/wiki/Pesquisa_bin%C3%A1ria)
+
+[Exercícios e uma explicação mais detalhada](https://www2.unifap.br/furtado/files/2013/10/Algoritmos-busca-bin%c3%a1ria-vers%c3%a3o-simplificada1.pdf)

docs/pt/README.md

@@ -0,0 +1,13 @@
+# Algoritmos
+
+## Strings
+
+- [Palíndromo](./Strings/Palindrome.md)
+
+## Procura
+
+- [Pesquisa Binária](./Procura/Pesquisa-Binaria.md)
+
+## Others
+
+[Como adicionar documentação para um algoritmo?](./CONTRIBUTING.md)

docs/pt/Strings/Palindrome.md

@@ -0,0 +1,43 @@
+## Palíndromo
+
+Um palíndromo é uma palavra, frase, número ou sequência de palavras que são lidas igualmente na forma normal e de trás para frente.
+
+## Passos
+
+1. Limpa a string removendo toda a pontuação e espaços em branco e converte todas as letras para minúsculas.
+2. Inverte a string limpa (passo anterior).
+3. Se a string limpa for igual à string limpa invertida temos um palíndromo.
+
+## Exemplos
+
+### Palíndromo de uma palavra
+- Coco
+- Ovo
+- Osso
+- Reler
+- Salas
+
+## Frases palíndromas
+- Socorram-me, subi no ônibus em Marrocos.
+- A base do teto desaba.
+- A mãe te ama.
+- Arara rara.
+- O céu sueco.
+
+## Implementações
+- [C](../../../algorithms/C/strings/palindrome.c)
+- [C++](../../../algorithms/CPlusPlus/Maths/palindrome.cpp)
+- [C#](../../../algorithms/CSharp/src/Strings/palindrome.cs)
+- [Haskell](../../../algorithms/Haskell/strings/palindrome.hs)
+- [Java](../../../algorithms/Java/strings/palindrome.java)
+- [JavaScript](../../../algorithms/JavaScript/src/strings/palindrome.js)
+- [Python](../../../algorithms/Python/strings/palindrome.py)
+- [Rust](../../../algorithms/Rust/strings/palindrome/src/main.rs)
+
+## Video URL
+[Video no youtube a explicar o palíndromo](https://www.youtube.com/watch?v=j3yTHI8uSCg)
+
+## Outros
+
+[Wikipédia](https://pt.wikipedia.org/wiki/Pal%C3%ADndromo)
+[Mais exemplos de palíndromos](https://www.todamateria.com.br/palindromo/)

docs/tr/CONTRIBUTING.md

@@ -0,0 +1,28 @@
+# Algoritma Adı
+
+Algoritmanın kısa bir açıklamasını aşağıdaki gibi yazın:
+1. Zaman Karmaşıklığı
+2. Uzay Karmaşıklığı
+3. Uygulamalar
+4. Kurucunun Adı
+5. vb...
+
+## Adımlar
+Algoritmayı açık, basit ve anlaşılır adımlarla tanımlayın.
+
+## Örnek
+Algoritmayı örnek giriş verileriyle izleyin.
+
+## Uygulama
+
+Programlama dillerindeki uygulamalarına bağlantıları ekleyin.
+NOT: Bağlantılar yalnızca algoritmalar klasöründe olmalıdır.
+
+## Video Linkleri
+
+Algoritmayı açıklayan bir videonun URL'sini ekleyin.
+
+## Diğer
+
+Diğer bilgileri bu kısımda verebilirsiniz.
+

docs/tr/README.md

@@ -0,0 +1,9 @@
+# Algoritmalar
+
+## Dizme Algoritmaları
+
+- [Palindrom](./Strings/Palindrom.md)
+
+## Diğer
+
+[Yeni algoritma dökümantasyonunu nasıl eklerim?](./CONTRIBUTING.md)

docs/tr/Strings/Palindrom.md

@@ -0,0 +1,38 @@
+# Palindrom
+Palindrom, ileriye ve geriye doğru okunduğunda aynı bir kelime, deyim, sayı veya kelimeyi oluşturan özel bir kelime dizisidir. Palindrom oluşturulurken sözcükler veya harfler arasında noktalama ve boşluklar olabilir.
+
+## Adımlar
+1. Tüm noktalama işaretlerini ve boşlukları kaldırarak ve tüm harfleri küçük harfe dönüştürerek kelimeyi düzenleyin.
+2. Düzenleme sırasını tersine çevirin.
+3. Düzenlenmiş kelime dizisi, ters çevrilmiş diziyle aynıysa, o zaman bir palindrom oluşturmuş olursunuz.
+
+## Örnekler
+
+### Tek Kelimeden Oluşan Palindromlar
+- Ulu
+- Ütü
+- Velev
+- Verev
+- Yapay
+
+### Çok Kelimeden Oluşan Palindromlar
+- Ah adi demir erimedi daha.
+- Al kazık çak karaya kayarak kaç kızakla.
+- Al yarısını sırayla.
+
+## Uygulamalar
+- [C](../../../algorithms/C/strings/palindrome.c)
+- [C++](../../../algorithms/CPlusPlus/Maths/palindrome.cpp)
+- [C#](../../../algorithms/CSharp/src/Strings/palindrome.cs)
+- [Haskell](../../../algorithms/Haskell/strings/palindrome.hs)
+- [Java](../../../algorithms/Java/strings/palindrome.java)
+- [JavaScript](../../../algorithms/JavaScript/src/strings/palindrome.js)
+- [Python](../../../algorithms/Python/strings/palindrome.py)
+- [Rust](../../../algorithms/Rust/strings/palindrome/src/main.rs)
+
+## Video Linki
+[Palindrom Algoritmasını Açıklayan Coursera videosu](https://www.coursera.org/lecture/program-code/palindrome-algorithm-1-zzQqs) 
+
+## Diğer Linkler
+[Wikipedia](https://tr.wikipedia.org/wiki/Palindrom)
+

recursive-sum-of-n-numbers.py

@@ -0,0 +1,12 @@
+def recsum(n):
+    if n<=1:
+        return(n)
+    else:
+        return(n+recsum(n-1))
+
+n= 15
+
+if n<0:
+    print("Enter a positive integer")
+else:
+    print("Sum =",recsum(n))