add search and basic operations

Author: Code-Recursion

Array ADT/binary_search.cpp

@@ -0,0 +1,70 @@
+// Array as Abstract Data Type
+// ADT has two properties
+// 1.) Declaration (most of the languages has array by default)
+// 2.) Operation - The operation must be defined
+
+#include <stdio.h>
+#include <stdlib.h>
+struct Array
+{
+    int A[100];
+    int size;
+    int length;
+};
+
+void Display(struct Array arr)
+{
+    printf("\nElement in array are : ");
+    for (int i = 0; i < arr.length; i++)
+        printf("%d ", arr.A[i]);
+}
+
+// int BinarySearchIterative(struct Array arr, int key)
+// {
+//     int low, mid, high;
+//     low = 0;
+//     high = arr.length - 1;
+//     while (low <= high)
+//     {
+//         mid = (low + high) / 2;
+//         if (key == arr.A[mid])
+//             return mid;
+//         else if (key > arr.A[mid])
+//             low = mid + 1;
+//         else
+//             high = mid - 1;
+//     }
+//     return -1;
+// }
+
+int BinarySearchRecursive(int a[], int low, int high, int key)
+{
+    int mid;
+    if (low <= high)
+    {
+        mid = (low + high) / 2;
+        if (key == a[mid])
+            return mid;
+        else if (key < a[mid])
+            return BinarySearchRecursive(a, low, mid - 1, key);
+        else
+            return BinarySearchRecursive(a, mid + 1, high, key);
+    }
+    return -1;
+}
+
+int main()
+{
+    struct Array arr = {{2, 3, 4, 5, 6, 7, 8}, 10, 7};
+
+    Display(arr);
+    // printf("\nSearch Successful item found at index : %d", BinarySearchIterative(arr, 6));
+    printf("\nSearch Successful item found at index : %d", BinarySearchRecursive(arr.A, 0, arr.length, 5));
+    return 0;
+}
+
+// Time Complexity Analysis
+// Iterative & Recursive
+// best : O[1]
+// average : O[logn]
+// worst : O[logn]

Array ADT/get_set_max_avg.c

@@ -0,0 +1,83 @@
+// Array as Abstract Data Type
+// ADT has two properties
+// 1.) Declaration (most of the languages has array by default)
+// 2.) Operation - The operation must be defined
+
+#include <stdio.h>
+#include <stdlib.h>
+struct Array
+{
+    int A[100];
+    int size;
+    int length;
+};
+
+void Display(struct Array arr)
+{
+    printf("\nElement in array : ");
+    for (int i = 0; i < arr.length; i++)
+        printf("%d ", arr.A[i]);
+}
+
+int get(struct Array arr, int index)
+{
+    if (index >= 0 && index <= arr.length)
+        return arr.A[index];
+    return -1;
+}
+
+int set(struct Array *arr, int index, int item)
+{
+    if (index >= 0 && index <= arr->length)
+        arr->A[index] = item;
+}
+
+int avg(struct Array arr)
+{
+    int sum = 0;
+    for (int i = 0; i < arr.length; i++)
+        sum += arr.A[i];
+    return sum / arr.length;
+}
+
+int max(struct Array arr)
+{
+    int max = arr.A[0];
+    for (int i = 0; i < arr.length; i++)
+    {
+        if (arr.A[i] > max)
+            max = arr.A[i];
+    }
+    return max;
+}
+
+int main()
+{
+    struct Array arr = {{2, 4, 6, 8, 10}, 10, 5};
+
+    Display(arr);
+    printf("\nElement at given index is : %d ", get(arr, 2));
+    printf("\nafter Set operation ");
+    set(&arr, 2, 9);
+    Display(arr);
+    printf("\nAverage in array : %d", avg(arr));
+    printf("\nMax in array : %d", max(arr));
+
+    return 0;
+}
+
+// output
+
+// Element in array : 2 4 6 8 10
+// Element at given index is : 6
+// after Set operation
+// Element in array : 2 4 9 8 10
+// Average in array : 6
+// Max in array : 10
+
+// Analysis
+
+// get : O(1)  constant for all cases
+// set : O(1)  constant for all cases
+// max : O(n)  all cases
+// avg : O(n)  all cases

Array ADT/linear_search.c

@@ -0,0 +1,80 @@
+//  improved Linear Search
+//  1 - transposition key is moved one position left ,
+//      decrease one step from next search
+
+//  2 - Move to Head/Tail, key is swapped with tail/head,
+//      optimize search to O[1] for next searches
+
+#include <stdio.h>
+#include <stdlib.h>
+
+struct Array
+{
+    int A[100];
+    int size;
+    int length;
+};
+
+void Display(struct Array arr)
+{
+    printf("\nElement in array are : ");
+    for (int i = 0; i < arr.length; i++)
+        printf("%d ", arr.A[i]);
+}
+
+void swap(int *x, int *y)
+{
+    int temp = *x;
+    *x = *y;
+    *y = temp;
+}
+
+int LinearSearchMoveToHead(struct Array *arr, int key)
+{
+    for (int i = 0; i < arr->length; i++)
+    {
+        if (key == arr->A[i])
+        {
+            swap(&arr->A[0], &arr->A[i]);
+            return i;
+        }
+    }
+    return -1;
+}
+
+// int LinearSearchTransposition(struct Array *arr, int key)
+// {
+//     for (int i = 0; i < arr->length; i++)
+//     {
+//         if (key == arr->A[i])
+//         {
+//             swap(&arr->A[i], &arr->A[i - 1]);
+//             return i;
+//         }
+//     }
+//     return -1;
+// }
+
+int main()
+{
+    struct Array arr = {{2, 3, 4, 5, 6}, 10, 5};
+
+    Display(arr);
+
+    // printf("\nElement found at index : %d", LinearSearchTransposition(&arr, 4));
+    printf("\nElement found at index : %d", LinearSearchMoveToHead(&arr, 4));
+
+    Display(arr);
+
+    return 0;
+}
+
+// Output :
+// Element in array are : 2 3 4 5 6
+// Element found at index : 2
+// Element in array are : 4 3 2 5 6
+
+
+// Analysis :
+// worst : O[n]
+// Best : O[1]