ArrayADT

#include <stdio.h>
#include <stdlib.h>
#define N 100
struct Array 
{
  int A[N];
  int size = N;
  int length = 0;
};

void Display(struct Array arr)
{
  int i;
  for ( i =0; i < arr.length; ++i) {
    printf("%d ", arr.A[i]);
  }
  printf("\n");
}

void Insert(struct Array *arr, int index, index x)
{
  if ( index >= 0 && index < arr->length ) {
     int j = arr->length;
     while ( j > index ) {
       arr->A[j] = arr->A[j-1];
     }
     arr->A[index] = x;
     arr->length++;
   }
}

void Append(struct Array *arr, int x)
{
  if ( arr->length < arr->size ) {
    arr->A[length++] = x;
  }
}

int BinarySearch(struct Array arr, int key)
{
  int low = 0;
  int high = arr.length-1;
  int mid = 0;
  while (low <= high) {
    mid = (int) ((low+ high)/2);
    if ( arr.A[mid] == key) return mid;
    else if ( arr.A[mid] < key) {
      low = mid+1;
    } else {
      high = mid-1;
    }
    
  } 
  return -1;
}

int BS(struc Array arr, int lo, int hi, int key)
{
  if ( lo > high) return -1;
  int mid = (int) ((lo+hi)/2);
  if ( key == arr.A[mid]) return mid;
  if ( key < arr.A[mid]) {
    return BS(arr, lo, mid-1, key);
  } else {
    return BS(arr, mid+1, high, key);
  }
}

int Get(struct Array arr, int index)
{
  if ( index >= 0 && index < arr.length) {
    return arr.A[index];
  } else {
    //error message
  }
}
void Set(struct Array arr, int index, int key)
{
  if ( index >= 0 && index < arr.length) {
    arr.A[index] = key;
  }
}

int Max(struct Array arr)
{
  if (arr.length == 0 ) return 0;
  int max = arr.A[0];
  for ( int i = 1; i < arr.length, ++i) {
    if ( arr.A[i] > max ) {
      max = arr.A[i];
    }
  }
  return max;
}

void InsertSort(struct Array *arr, int x)
{
  // try to find the location of the x in the sorted list
  // started from the last element
  int i = arr->length-1;
  if ( arr->length == arr->size) return;
  while ( i >= 0 && arr->A[i] > x ) {
    arr->A[i+1] = arr->A[i];
    i--;
  }
  A[i+1] = x;
  arr->length++;
  return;
}

bool isSorted(struct Array arr)
{
  int i;
  for ( i = 0; i < arr.length-1; i++) {
    if ( arr.A[i] > arr.A[i+1]) return false;
  }
  return true;
}
int Min(struct Array arr) 
{
  if ( arr.length == 0 ) return 0;
  
  int min = arr.A[0];
  for ( int i = 1; i < arr.length; ++i) {
    if ( arr.A[i] < min ) {
      min = arr.A[i];
    }
  }
  return min;
}

void ReArrange(struct Array *arr) {
  int i = 0;
  int j = arr->length-1;
  while (i < j ) {
    while ( arr->A[i] < 0 ) i++;
    while ( arr->A[j] >= 0 ) j--;
    if ( i < j ) {
      swap(&arr->A[i], &arr->A[j]);
    }
  }
}

struct Array * Merge(struct Array A, struct Array B)
{
  struct Array *C;
  C = (struct Array *) molloc(sizeof(struct Array));
  C.size = A.size;
  int m = A.length;
  int n = B.length;
  
  int k= 0;
  int i = 0;
  int j= 0;
  while ( i < m && j < n ) 
  {
    if(A.A[i] < B.A[j]) {
      C.A[k++] = A.A[i++];
    } else {
      C.A[k++] = B.A[j++];
    }
  }
  for ( ; i < m; i++) {
    C.A[k++] = A.A[i];
  }
  for ( ; j < n; j++) {
    C.A[k++] = B.A[j];
  }
  C.length = A.length + B.length;
  
}

int Sum(struct Array arr)
{
  int sum = 0;
  for ( int i = 0; i < arr.length; ++i) {
    sum += arr.A[i];
  }
  return sum;
}
double Average(struct Array arr)
{
  if ( arr.length == 0 ) return 0;
  double av = 0
  for ( int i = 0; i < arr.length; ++i) {
    av += arr.A[i];
  }
  av /= arr.length;
  return av;
}
// assume the arrays are sorted
struct Array * Union(struct Array *arr1, struct Array *arr2)
{
  int i = 0;
  int j = 0;
  int k = 0;
  struct Array *arr3;
  arr3 = (struct Array *)molloc(sizeof(struct Array));
  arr3->size = arr1->size;
  while ( i < arr1->length && j < arr2->length ) 
  {
    if ( arr1->A[i] < arr2->A[j] ) {
      arr3->A[k++] = arr1->A[i++];
    } else if (arr1->A[i] > arr2->A[j]) {
      arr3->A[k++] = arr2->A[j++];
    } else {
      arr3->A[k++] = arr1->A[i];
      i++;
      j++;
    }
  }
  for ( ; i < arr1->length; i++){
    arr3->A[k++] = arr1->A[i++];
  }
  for ( ; j < arr1->length; j++) {
    arr3->A[k++] = arr2->A[j++];
  }
  arr3->length = k;
  return arr3;
}
struct Array * Intersection(struct Array *arr1, struct Array *arr2)
{
  int i = 0;
  int j = 0;
  int k = 0;
  struct Array *arr3;
  arr3 = (struct Array *)molloc(sizeof(struct Array));
  arr3->size = arr1->size;
  while ( i < arr1->length && j < arr2->length ) 
  {
    if ( arr1->A[i] < arr2->A[j] ) {
      i++
    } else if (arr1->A[i] > arr2->A[j]) {
      j++
    } else {
      arr3->A[k++] = arr1->A[i];
      i++;
      j++;
    }
  }
  
  arr3->length = k;
  return arr3;
}
struct Array *

int main() 
{
  struct Array arr = { {1, 2, 3, 4, 5}, 10, 5};
  
  Display(arr);
  Insert(&arr, 3, 2);
  Display(arr);
  Append(&arr, 10);
  Display(arr);
  struct Array arr1 = { {1, 2, 3, 4, 5}, 10, 5};
  struct Array arr2 = { {6, 7, 8, 9, 10}, 10, 5};
  struct Array *arr3;
  return 0;
}