Find the smallest number in an array that is not in another array

Things get complicated with code tries to maintain multiple indexes into multiple arrays... Things are simplified if you re-use code and break out functions (that can test user input, too)...

#include <stdio.h>

void fill( int arr[], size_t sz ) { // Get user input (with checking)
    printf("Enter integers\n");
    for( size_t i = 0; i < sz; i++ )
        if( scanf( "%d", &arr[i] ) != 1 ) {
            fprintf( stderr, "scanf failure\n" );
            exit(1);
        }
}

// Search for a value in an array. Return index if found, or size if not found
size_t hunt( int val, int arr[], size_t sz ) {
    for( size_t i = 0; i < sz; i++ )
        if( val == arr[i] )
            return i;
    return sz;
}

int main() {
#if 0 // Normal with user entry
    int arr1[5], arr2[5];
    size_t a1sz = sizeof arr1/sizeof arr1[0];
    size_t a2sz = sizeof arr2/sizeof arr2[0];

    fill( arr1, a1sz );
    fill( arr2, a2sz );
#else // less tedious with compile time init of data
    int arr1[] = { 0, 1, 2, 3, 4 };
    int arr2[] = { 0, 2, 3, 4, 5 };
    size_t a1sz = sizeof arr1/sizeof arr1[0];
    size_t a2sz = sizeof arr2/sizeof arr2[0];
#endif

    size_t gotOne = 0;
    for( size_t i = 0; i < a1sz; i++ ) {
        // don't bother testing values if got a candidate and value is larger
        if( gotOne && arr1[i] >= arr1[ gotOne ] ) continue;

        // following is TRUE when not found...
        if( hunt( arr1[i], arr2, a2sz ) == a2sz )
            gotOne = i + 1;
    }

    if( gotOne )
        printf( "Smallest in arr1 not in arr2 = %u\n", arr1[ gotOne - 1 ] );
    else
        puts( "No such value matching criteria" );

    return 0;
}

Smallest in arr1 not in arr2 = 1

Algorithm

The naive approach to this, and one that works very well for small datasets, is to nest a couple of loops. This approach grows in time complexity very fast. O(m*n) where m is the length of the first array and n is the length of the second array.

Fortunately, we can approach this in a way that does not involve nested loops. This assumes both arrays contain only unique values. If they have duplicates, removing those duplicates would be a necessary step before the below can be performed.

Let's start with a couple of simple arrays:

int foo[] = {1, 4, 7, 9, 2};
int bar[] = {4, 1, 6, 7, 3};

Let's combine them into another array. This is a linear operation.

{1, 4, 7, 9, 2, 4, 1, 6, 7, 3}

Let's then use qsort to sort them. This operation is typically O(n*log n).

{1, 1, 2, 3, 4, 4, 6, 7, 7, 9}

Now, we can do a linear loop over these and find the unique elements. These are the ones present in one but not both of the arrays.

{2, 3, 6, 9}

But this doesn't tell us which is in the first array. That sounds like a nested loop issue. Instead, though, let's combine that with the first array.

{1, 4, 7, 9, 2, 2, 3, 6, 9}

And we'll sort this.

{1, 2, 2, 3, 4, 6, 7, 9, 9}

Now we'll scan for the first repeated number.

2

An implementation

Note: Does not check for malloc errors.

#include <stdio.h>
#include <stdlib.h>

int cmp(const void *a, const void *b) {
    int c = *(const int *)a;
    int d = *(const int *)b;

    if (c == d) return 0;
    else if (c < d) return -1;
    else return 1;
}

int min_not_in_2nd_array(int *result, int *arr1, size_t m, int *arr2, size_t n) {
    int *temp = malloc(sizeof(int) * (m + n));
    //if (!temp) return 0;

    for (size_t i = 0; i < m; ++i) temp[i] = arr1[i];
    for (size_t i = 0; i < n; ++i) temp[m+i] = arr2[i];

    qsort(temp, m+n, sizeof(int), cmp);

    int *uniques = malloc(sizeof(int) * (m + n));
    //if (!uniques) return 0;

    size_t n_uniques = 0;
    int cur = temp[0] - 1;
    size_t cur_count = 0;

    for (size_t i = 0; i < m+n; ++i) {
        if (i == m+n-1 && temp[i] != temp[i-1]) {
            uniques[n_uniques++] = temp[i]; 
        }
        else if (temp[i] != cur) {
            if (cur_count == 1) uniques[n_uniques++] = cur; 
            cur = temp[i];
            cur_count = 1;
        }
        else {
            cur_count++;    
        }
    }

    //for (size_t i = 0; i < n_uniques; ++i) printf("%d ", uniques[i]);
    //printf("\n");
    
    int *temp2 = malloc(sizeof(int) * (m + n_uniques));
    // if (!temp2) return 0;
    
    for (size_t i = 0; i < m; ++i) temp2[i] = arr1[i];
    for (size_t i = 0; i < n_uniques; ++i) temp2[m+i] = uniques[i];
    
    qsort(temp2, m+n_uniques, sizeof(int), cmp);
    
    int found = 0;
    
    for (size_t i = 0; i < m+n_uniques-1; ++i) {
        if (temp2[i] == temp2[i+1]) {
            *result = temp2[i];
            found = 1;
            break;
        }
    }

    free(temp);
    free(uniques);
    free(temp2);

    return found;
}

int main(void) {
    int foo[] = {1, 4, 7, 9, 2};
    int bar[] = {4, 1, 6, 7, 3};
    int baz;

    if (min_not_in_2nd_array(&baz, foo, sizeof(foo)/sizeof(*foo), 
                                   bar, sizeof(bar)/sizeof(*bar))) {
        printf("Min not in 2nd array is %d\n", baz);
    }
    else {
        printf("All elements shared.\n");
    }

    return 0;
}