i have added bunch of codes

Author: imdhanish

Diff for: bubble_sort/C/bubble_sort.c

@@ -0,0 +1,47 @@
+#include <stdio.h>
+
+void bubble_sort(int[], int);
+void print_array(int[], int);
+void swap(int*, int*);
+
+int main() {
+    int arr[] = {45, 92, 54, 23, 6, 4, 12};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    bubble_sort(arr, n);
+    printf("Sorted array: \n");
+    print_array(arr, n);
+}
+
+/* Function to swap two numbers */
+void swap(int *a, int *b) {
+    int temp = *a;
+    *a = *b;
+    *b = temp;
+}
+
+/* Bubble Sort algorithm */
+void bubble_sort(int arr[], int n) {
+    int i, j;
+    int swapped;
+    for (i = 0; i < n - 1; ++i) {
+        swapped = 0;
+        for (j = 0; j < n - i - 1; ++j) {
+            if (arr[j] > arr[j+1]) {
+                swap(&arr[j], &arr[j+1]);
+                swapped = 1;
+            }
+        }
+
+        /* If no two elements are swapped by inner loop, then break */
+        if (swapped == 0)
+            break;
+    }
+}
+
+/* Function to print array */
+void print_array(int arr[], int size) {
+    int i;
+    for (i = 0; i < size; i++)
+        printf("%d ", arr[i]);
+    printf("\n");
+}

Diff for: bubble_sort/Cpp/bubble_sort.cpp

@@ -0,0 +1,43 @@
+#include <stdio.h>
+
+void swap(int *xp, int *yp) {
+    int temp = *xp;
+    *xp = *yp;
+    *yp = temp;
+}
+
+void bubble_sort(int arr[], int n) {
+    int i, j;
+    bool swapped;
+    for (i = 0; i < n-1; i++) {
+        swapped = false;
+        for (j = 0; j < n-i-1; j++) {
+            if (arr[j] > arr[j+1]) {
+                swap(&arr[j], &arr[j+1]);
+                swapped = true;
+            }
+        }
+
+        // IF no two elements were swapped by inner loop, then break
+        if (swapped == false)
+            break;
+    }
+}
+
+/* Function to print an array */
+void print_array(int arr[], int size) {
+    int i;
+    for (i = 0; i < size; i++)
+        printf("%d ", arr[i]);
+    printf("\n");
+}
+
+// Driver program to test above functions
+int main() {
+    int arr[] = {64, 34, 25, 12, 22, 11, 90};
+    int n = sizeof(arr) / sizeof(arr[0]);
+    bubble_sort(arr, n);
+    printf("Sorted array: \n");
+    print_array(arr, n);
+    return 0;
+}

Diff for: counting_sort/Python/counting_sort.py

@@ -0,0 +1,41 @@
+def counting_sort(arr, digit: int, radix=10):
+    """
+    Fuction to sort using Counting Sort
+    <https://en.wikipedia.org/wiki/Counting_sort>.
+
+    :param arr:     A list of number to sort
+    :param digit:   The digit we want to sort by
+    :param radix:   The base of the number system
+    :return result: The sorted list of given arr list
+    """
+
+    arr_len = len(arr)
+    count = [0]*radix   # counts the number of occurences of each digit in arr
+    result = [0]*arr_len
+
+    def _digit_find(num, digit, radix):
+        return int((num / radix ** digit) % radix)
+
+    for i in range(arr_len):
+        digit_of_arr_i = _digit_find(arr[i], digit, radix)
+        count[digit_of_arr_i] += 1
+
+    for j in range(1, radix):
+        count[j] += count[j-1]
+
+    for m in range(arr_len-1, -1, -1):
+        digit_of_arr_i = _digit_find(arr[m], digit, radix)
+        count[digit_of_arr_i] -= 1
+        result[count[digit_of_arr_i]] = arr[m]
+
+    return result
+
+
+def main():
+    arr = [6, 5, 4, 3, 2, 1]
+    print('Sorted element using Counting Sort: {}'.format(
+              ' '.join(map(str, counting_sort(arr, 0)))))
+
+
+if __name__ == '__main__':
+    main()

Diff for: insertion_sort/C/insertion_sort.c

@@ -0,0 +1,32 @@
+#include <stdio.h>
+#include <math.h>
+
+void insertion_sort(int arr_size, int *arr) {
+    // Fuction to do insertion sort.
+    int i;
+    int pivot;
+    int j;
+    for (i = 1; i < arr_size; i++) {
+        pivot = arr[i];
+        j = i-1;
+        /* Move elements of arr[0..i-1], that are
+           greater than pivot, to one position ahead
+           of their current position */
+        while (j >= 0 && arr[j] > pivot) {
+            arr[j+1] = arr[j];
+            j = j-1;
+        }
+        arr[j+1] = pivot;
+    }
+}
+
+int main() {
+    int arr_size = 6, i;
+    int arr[6] = {6, 5, 4, 3, 2, 1};
+    insertion_sort(arr_size, arr);
+
+    for (i=0; i < arr_size; i++) {
+        printf("%d\n", arr[i]);
+    }
+    return 0;
+}

Diff for: insertion_sort/Cpp/insertion_sort.cpp

@@ -0,0 +1,31 @@
+#include<bits/stdc++.h>
+
+using namespace std;
+
+void insertion_sort(int arr[], int n) {
+    // Fuction to do insertion sort.
+    for (int i = 1; i < 10; i++) {
+        int temp;
+        temp = arr[i];
+        int x;
+        for (int j = i; j >= 0; j--) {
+            /* Move elements of arr[0..i-1], that are greater, to one position
+            ahead of their current position */
+            if (temp <= arr[j]) {
+                arr[j] = arr[j-1];
+                x = j;
+            }
+        }
+        arr[x] = temp;
+    }
+}
+
+int main() {
+    int arrsize = 6;
+    int arr[arrsize] = {6, 1, 2, 4, 5, 3};
+    insertion_sort(arr, arrsize);
+    for (int i = 0; i < arrsize; i++) {
+        cout << arr[i] << " ";
+    }
+    return 0;
+}

Diff for: insertion_sort/Python/insertion_sort.py

@@ -0,0 +1,25 @@
+def insertion_sort(arr):
+    """
+    Fuction to do insertion sort.
+
+    :param arr: A list of element to sort.
+    """
+    for slot in range(1, len(arr)):
+        value = arr[slot]
+        test_slot = slot - 1
+        while test_slot > -1 and arr[test_slot] > value:
+            arr[test_slot + 1] = arr[test_slot]
+            test_slot = test_slot - 1
+        arr[test_slot + 1] = value
+
+    return arr
+
+
+def main():
+    arr = [6, 5, 4, 3, 2, 1]
+    print('Sorted element using Insertion Sort: {}'.format(
+              ' '.join(map(str, insertion_sort(arr)))))
+
+
+if __name__ == '__main__':
+    main()

Diff for: merge_sort/Python/merge_sort.py

@@ -0,0 +1,57 @@
+"""
+Merge Sort Algorthm
+- Create an empty list called the result list.
+- Do the following until one of the input lists is empty:
+    - Remove the first element of the list that has a lesser first element
+      and append it to the result list.
+- When one of the lists is empty, append all elements of the other list to
+  the result.
+"""
+
+
+def _merge(left, right):
+    result = []
+    left_idx, right_idx = 0, 0
+    while left_idx < len(left) and right_idx < len(right):
+        # change the direction of this comparison to change
+        # the direction of the sort
+        if left[left_idx] <= right[right_idx]:
+            result.append(left[left_idx])
+            left_idx += 1
+        else:
+            result.append(right[right_idx])
+            right_idx += 1
+
+    if left:
+        result.extend(left[left_idx:])
+    if right:
+        result.extend(right[right_idx:])
+    return result
+
+
+def merge_sort(arr):
+    """
+    Fuction to do merge sort.
+
+    :param arr: A list of element to sort.
+    """
+    if len(arr) <= 1:
+        return arr
+
+    middle = len(arr) // 2
+    left = arr[:middle]
+    right = arr[middle:]
+
+    left = merge_sort(left)
+    right = merge_sort(right)
+    return list(_merge(left, right))
+
+
+def main():
+    arr = [6, 5, 4, 3, 2, 1]
+    print('Sorted element using Merge Sort: {}'.format(
+              ' '.join(map(str, merge_sort(arr)))))
+
+
+if __name__ == '__main__':
+    main()

Diff for: quicksort/Python/quicksort.py

@@ -0,0 +1,48 @@
+"""
+QuickSort Algorithm
+- If the list is empty, return the list and terminate. - (Base case)
+- Choose a pivot element in the list.
+- Take all of the elements that are less than or equal to the pivot and use
+  quicksort on them.
+- Take all of the elements that are greater than the pivot and use quicksort
+  on them.
+- Return the concatenation of the quicksorted list of elements that are less
+  than or equal to the pivot, the pivot, and the quicksorted list of elements
+  that are greater than the pivot.
+"""
+
+
+def quicksort(arr):
+    """
+    Fuction to do quicksort.
+
+    :param arr: A list of element to sort.
+    """
+    less = []
+    pivotList = []
+    more = []
+
+    if len(arr) <= 1:
+        return arr
+    else:
+        pivot = arr[0]
+        for i in arr:
+            if i < pivot:
+                less.append(i)
+            elif i > pivot:
+                more.append(i)
+            else:
+                pivotList.append(i)
+        less = quicksort(less)
+        more = quicksort(more)
+        return less + pivotList + more
+
+
+def main():
+    arr = [6, 5, 4, 3, 2, 1]
+    print('Sorted element using Quicksort: {}'.format(
+              ' '.join(map(str, quicksort(arr)))))
+
+
+if __name__ == '__main__':
+    main()

Diff for: radix_sort/Python/radix_sort.py

@@ -0,0 +1,28 @@
+def radix_sort(array, base=10):
+    """
+    Fuction to sort using radix sort algorithm
+    <https://en.wikipedia.org/wiki/Radix_sort>.
+
+    :param array:   A list of elements to sort.
+    :param base:    Integer number to represent base number
+    """
+    maxLen = len(str(max(array)))
+
+    for i in range(maxLen):
+        digit_ref = [[] for _ in range(base)]
+        for num in array:
+            digit_ref[(num // base ** i) % base].append(num)
+        array = []
+        for section in digit_ref:
+            array.extend(section)
+    return array
+
+
+def main():
+    array = [6, 5, 4, 3, 2, 1]
+    print('Sorted element using Radix Sort: {}'.format(
+              ' '.join(map(str, radix_sort(array)))))
+
+
+if __name__ == '__main__':
+    main()

Diff for: shell_sort/Python/shell_sort.py

@@ -0,0 +1,33 @@
+def shell_sort(arr):
+    """
+    Fuction to sort using Shell Sort
+    <https://en.wikipedia.org/wiki/Shellsort>.
+    :param arr:     A list of element to sort
+    """
+
+    gap = int((len(arr)/2))
+    while gap > 0:
+        for i in range(gap, len(arr)):
+            temp = arr[i]
+            j = i
+            while j >= gap and arr[j - gap] > temp:
+                arr[j] = arr[j-gap]
+                j -= gap
+
+            arr[j] = temp
+
+        gap /= 2
+        gap = int(gap)
+
+    return arr
+
+
+def main():
+    arr = [15, 12, 36, 63, 96]
+    sorted_arr = shell_sort(arr)
+    print('Sorted element using Shell Sort: {}'.format(
+              ' '.join(map(str, shell_sort(arr)))))
+
+
+if __name__ == '__main__':
+    main()