Merge pull request #2057 from nobodyn0se/master

Added optimized Fibonacci program in C using array #2020

Author: t2013anurag

fibonacci/c/fibUsingArray.c

@@ -0,0 +1,14 @@
+#include<stdio.h>
+
+int main() {
+    int n, i;
+    printf("Enter total number of terms: ");
+    scanf("%d", &n);
+    char ch;
+    while((ch = getchar()) != '\n' && ch != EOF);
+    int f[n];
+    f[0] = 0, f[1] = 1;
+    for(i=2; i<n; i++)
+        f[i] = f[i-1] + f[i-2];
+    printf("Last term: %d", f[n-1]);
+}

sorting/SortingTimeComplx.cpp

@@ -0,0 +1,205 @@
+#include<iostream>
+#include<string>
+#include<ctime>
+#include<iomanip>
+#include<random>
+using namespace std;
+
+void input(int [], int);
+int binarySearch(int [], int, int, int);
+void insertionSort(int [], int);
+void bubbleSort(int [], int);
+void swap(int*, int*);
+void selectionSort(int [], int);
+void time_it(double, double, string);
+void modified_bubbleSort(int [], int);
+void mergeSort(int [], int, int);
+void merge(int [], int, int, int);
+void cpu_clock_cycles(double, double);
+
+int binarySearch(int a[], int low, int high, int x) {
+    if (high <= low)
+        return (x > a[low])?  (low + 1): low;
+    int mid = (low + high)/2;
+    if(x == a[mid])
+        return mid+1;
+    if(x > a[mid])
+        return binarySearch(a, mid+1, high, x);
+    return binarySearch(a, low, mid-1, x);
+}
+
+void insertionSort(int a[], int n) {
+    int loc, i, j, selected;
+    for(i=1; i<n; i++) {
+        selected = a[i];
+        j = i - 1;
+        loc = binarySearch(a, 0, j, selected);
+        while(j >= loc){
+            a[j+1] = a[j];
+            j--;
+        }
+        a[j+1] = selected;
+    }
+}
+
+void bubbleSort(int b[], int n) {
+    int i, j;
+    for(i=n-1;i>=0;i--) {
+        for(j=0; j<i; j++) {
+            if(b[j+1] < b[j]) {
+                swap(b+j,b+j+1);
+            }
+        }
+    }
+}
+
+void swap(int*a, int*b) {
+    int temp = *a;
+    *a = *b;
+    *b = temp;
+}
+
+void selectionSort(int c[], int n) {
+    int min, i, j;
+    for(i=0; i<n-1; i++) {
+        for(j=i+1; j<n; j++) {
+            if(c[j] < c[i]){
+                swap(c+i,c+j);
+            }
+        }
+    }
+}
+
+void time_it(double strt, double lst, string str) {
+    double time_taken = double(lst - strt)/ double(CLOCKS_PER_SEC);
+    cout <<"Time taken by "<< str <<" Sort is: "<< fixed << time_taken << setprecision(3);
+    cout <<" sec(s)\n";
+}
+
+void cpu_clock_cycles(double _2, double _1) {
+    cout <<"CPU cycles taken: " << _1 - _2 << endl;
+}
+
+void input(int x[], int n) {
+    int i;
+    random_device random_device;
+    mt19937 random_engine(random_device());
+    for(i=0; i<n; i++) {
+        uniform_int_distribution<int> distribution_1_1000(1, 1000);
+        x[i] = distribution_1_1000(random_engine);
+    }
+}
+
+void modified_bubbleSort(int b[], int n) {
+    int i, j;
+    bool swapped;
+    for(i=n-1;i>=0;i--) {
+        swapped = false;
+        for(j=0; j<i; j++) {
+            if(b[j+1] < b[j]) {
+                swap(b+j,b+j+1);
+                swapped = true;
+            }
+        }
+        if(!swapped) break;
+    }
+}
+
+void mergeSort(int a[], int lo, int hi) {
+    int mid;
+    if(lo < hi) {
+        mid = (lo + hi)/2;
+        mergeSort(a, lo, mid);
+        mergeSort(a, mid+1, hi);
+        merge(a, lo, hi, mid);
+    }
+}
+
+void merge(int a[], int l, int h, int m) {
+    int i, j, k, temp[h-l+1];
+    i = l;
+    j = m + 1;
+    k = 0;
+    while(i <= m && j <= h) {
+        if(a[i] < a[j])
+            temp[k++] = a[i++];
+        else
+            temp[k++] = a[j++];
+    }
+
+    while(i <= m)
+        temp[k++] = a[i++];
+
+    while(j <= h)
+        temp[k++] = a[j++];
+
+    for(i=l, j=0; i<=h; i++, j++)
+        a[i] = temp[j];
+
+}
+
+int main() {
+    clock_t start, end;
+    int size, elem, i;
+    cout <<"Enter the size of the array\n";
+    cin >> size;
+    //Dynamic array allocation during runtime to minimize space complexity
+    int*a = new int[size];
+    int*b = new int[size];
+    int*c = new int[size];
+    int*d = new int[size];
+    int*e = new int[size];
+    cout <<"Filling random array elements\n";
+
+    //Array gets automatically filled with random numbers
+    input(a, size);
+    for(i=0; i < size; i++)
+        e[i] = d[i] = c[i] = b[i] = a[i];
+    cout <<"Done\n";
+
+    cout <<"\nSorting the array using Merge Sort...\n";
+    start = clock();
+    mergeSort(e, 0, size-1);
+    end = clock();
+    delete[] e;
+    time_it(start, end, "Merge");
+    cpu_clock_cycles(start, end);
+
+
+    cout <<"\nSorting the array using Binary Insertion Sort...\n";
+    start = clock();
+    insertionSort(a, size);
+    end = clock();
+    delete[] a;
+    //Time function calculates execution time for sorting
+    time_it(start, end, "Binary Insertion");
+    cpu_clock_cycles(start, end);
+
+    cout <<"\nSorting the array using Selection Sort...\n";
+    start = clock();
+    selectionSort(c, size);
+    end = clock();
+    //Array memory is cleared after the array is no longer required
+    delete[] c;
+    time_it(start, end, "Selection");
+    cpu_clock_cycles(start, end);
+
+
+    cout <<"\nSorting the array using Bubble Sort...\n";
+    start = clock();
+    bubbleSort(b, size);
+    end = clock();
+    delete[] b;
+    time_it(start, end, "Bubble");
+    cpu_clock_cycles(start, end);
+
+    cout <<"\nSorting the array using Modified Bubble Sort...\n";
+    start = clock();
+    modified_bubbleSort(d, size);
+    end = clock();
+    delete[] d;
+    time_it(start, end, "Modified Bubble");
+    cpu_clock_cycles(start, end);
+
+    return 0;
+}