modify sorting implementation

Author: theEmbeddedGeorge

Data_Struct_Implementation/bubbleSort/bubbleSort.md

@@ -1,60 +1,81 @@
 ## Bubble Sort
 
+![Algorithm Animation](https://images2017.cnblogs.com/blog/849589/201710/849589-20171015223238449-2146169197.gif)
+
+#### Complexity
+
+- Worst and Average Case Time Complexity: O(n*n). Worst case occurs when array is reverse sorted.
+- Best Case Time Complexity: O(n). Best case occurs when array is already sorted.
+- Auxiliary Space: O(1)
+
 #### Code
 ```c
-#void swap(int *xp, int *yp) 
-{ 
-    int temp = *xp; 
-    *xp = *yp; 
-    *yp = temp; 
-} 
-  
-// An optimized version of Bubble Sort 
-void bubbleSort(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 */
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+typedef void (*sortAlgorithm)(int *array, int size);
+
+void bubblesort(int *array, int size) {
+    int i, j;
+    int temp;
+
+    for (i = size; i >= 0; i--) {
+        for (j = 0; j < i-1; j++) {
+            if (array[j] > array[j+1]) {
+                temp = array[j];
+                array[j] = array[j+1];
+                array[j+1] = temp;
+            }
+        }
+    }
+}
+
 void printArray(int arr[], int size) 
 { 
     int i; 
     for (i=0; i < size; i++) 
         printf("%d ", arr[i]); 
-    printf("n"); 
+    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]); 
-    bubbleSort(arr, n); 
-    printf("Sorted array: \n"); 
-    printArray(arr, n); 
-    return 0; 
-} 
-```
 
-#### Complexity
+void tests(int *nums, int size) {
+    sortAlgorithm sort_method = bubblesort;
+    clock_t start, end;
+    double cpu_time_used;
 
-- Worst and Average Case Time Complexity: O(n*n). Worst case occurs when array is reverse sorted.
-- Best Case Time Complexity: O(n). Best case occurs when array is already sorted.
-- Auxiliary Space: O(1)
+    start = clock();
+    sort_method(nums, size);
+    end = clock();
+
+    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+
+    printf("==== Sorted array test results ====\n"); 
+    printArray(nums, size); 
+    printf("CPU time used: %f\n\n", cpu_time_used);
+}
+
+int main() {
+    // test 1
+    int nums[] = {10, 7, 8, 9, 1, 5}; 
+    int n = sizeof(nums)/sizeof(nums[0]); 
+    tests(nums, n);
+
+    // test 2
+    int nums2[] = {1, 2, 4, 6, 8, 2, 3, 4, 0, -1, 10, 7, 8, 9, 1, 5}; 
+    n = sizeof(nums2)/sizeof(nums2[0]); 
+    tests(nums2, n);
+    
+    // test 3
+    int nums3[] = {}; 
+    n = sizeof(nums3)/sizeof(nums3[0]); 
+    tests(nums3, n);
+
+    // test 4
+    int nums4[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; 
+    n = sizeof(nums4)/sizeof(nums4[0]); 
+    tests(nums4, n);
+    
+    return 0; 
+}
+```

Data_Struct_Implementation/insertionSort/insertionSort.md

@@ -1,6 +1,96 @@
 ## Insertion Sort
 
-#### Code (Linked List Implementation)
+![Animation](https://images2017.cnblogs.com/blog/849589/201710/849589-20171015225645277-1151100000.gif)
+
+### **Complexity**
+
+- Auxiliary Space: O(1)
+- Best Case: O(n) (reverse sorted)
+- Worst Case: O(n^2)
+
+### Code (Array Implementation)
+```c
+#include <stdlib.h>
+#include <stdio.h>
+#include <time.h>
+
+typedef void (*sortAlgorithm)(int *array, int size);
+
+void insertionSort(int *array, int size) {
+    int i, j;
+    int temp;
+
+    for (i = 0; i < size; i++) {
+        temp = array[i];
+        for (j = i; j >= 1; j--) {
+            if (array[j-1] <= temp) {
+                break;
+            } 
+            array[j] = array[j-1];
+        }
+        array[j] = temp;
+    }
+}
+
+void printArray(int arr[], int size) 
+{ 
+    int i; 
+    for (i=0; i < size; i++) 
+        printf("%d ", arr[i]); 
+    printf("\n"); 
+} 
+
+void tests(int *nums, int size) {
+    sortAlgorithm sort_method = insertionSort;
+    clock_t start, end;
+    double cpu_time_used;
+
+    printf("==== Sorted array test results ====\n");
+    printf("Original:\n");
+    printArray(nums, size); 
+
+    start = clock();
+    sort_method(nums, size);
+    end = clock();
+
+    cpu_time_used = ((double) (end - start)) / CLOCKS_PER_SEC;
+
+    printf("Sorted:\n");
+    printArray(nums, size); 
+    printf("CPU time used: %f\n\n", cpu_time_used);
+}
+
+int main() {
+    // test 1
+    int nums[] = {10, 7, 8, 9, 1, 5}; 
+    int n = sizeof(nums)/sizeof(nums[0]); 
+    tests(nums, n);
+
+    // test 2
+    int nums2[] = {1, 2, 4, 6, 8, 2, 3, 4, 0, -1, 10, 7, 8, 9, 1, 5}; 
+    n = sizeof(nums2)/sizeof(nums2[0]); 
+    tests(nums2, n);
+    
+    // test 3
+    int nums3[] = {}; 
+    n = sizeof(nums3)/sizeof(nums3[0]); 
+    tests(nums3, n);
+
+    // test 4
+    int nums4[] = {10, 9, 8, 7, 6, 5, 4, 3, 2, 1}; 
+    n = sizeof(nums4)/sizeof(nums4[0]); 
+    tests(nums4, n);
+
+    // test 5
+    int nums5[] = {1, 2, -4, 6, -8, 2, 3, -4, 0, -1, 10, -1, 5}; 
+    n = sizeof(nums5)/sizeof(nums5[0]); 
+    tests(nums5, n);
+    
+    return 0; 
+}
+```
+
+### Code (Linked List Implementation)
 [Leetcode 147](https://leetcode.com/problems/insertion-sort-list/)
 ```c
 /**
@@ -11,7 +101,6 @@
  * };
  */
 
-
 struct ListNode* insertionSortList(struct ListNode* head){
     struct ListNode *dummy = (struct ListNode *) calloc (1, sizeof(struct ListNode));
     
@@ -35,8 +124,3 @@ struct ListNode* insertionSortList(struct ListNode* head){
 }
 ```
 
-#### Complexity
-
-- Auxiliary Space: O(1)
-- Best Case: O(n) (reverse sorted)
-- Worst Case: O(n^2)