Error in removing duplicate in C using pointers

Please fix all the warnings in your code - you can enable the Wall and Wextra flags in GCC for example.

Then one logical error I see is here:

array[j] == array[i]

where you would like to assign, not compare, so change it to:

array[j] = array[i]

Moreover, when you print the array with the duplicate values removed, you iterate until end, but this variable is undeclared.

I think that you need to take a step back and do the operation with using an extra array, which will be the old array with duplicate elements removed. In that case you could modify your code to something like this:

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

void removeDups(int *array, int length)
{
  int array_no_dups[length];
  int unique_n = 0;
  for(int i = 0; i < length; ++i)
  {
    int found = 0; // flag
    //check if element already in the array without duplicates
    for(int j = 0; j < unique_n; j++)
    {
      if(array[i] == array_no_dups[j])
        found = 1;
    }
    // If not found
    if(!found)
      // then append it to the array without duplicates
      array_no_dups[unique_n++] = array[i];
  }
  printf("Number of new elements: %d,", unique_n);
  printf(" new elements: ");
  for(int i = 0; i < unique_n; i++)
  {
    printf("%d ", array_no_dups[i]);
  }
}
void print_array(int *array, int length)
{
    printf("Number of elements: %d,", length);
    printf(" Orginal elements: ");
    for(int i = 0; i < length; i++)
    {
            printf("%d " , array[i]);
    }
}
int main()
{
    int array[10];
    int size = 10;
    for(int i = 0; i < size; i++)
      array[i] = rand() % 10 + 1;
    print_array(array, size);
    printf("\n");
    removeDups(array, size);
    return 0;
}

Output:

Number of elements: 10, Orginal elements: 4 7 8 6 4 6 7 3 10 2 
Number of new elements: 7, new elements: 4 7 8 6 3 10 2 

Now, if you really want to remove duplicates in-place, then every time you'd find a duplicate value, you would need to swap the 2nd occurrence of it with the last element of your array (that would be indexed by the counter you would maintain). Of course you would need to be careful with your indices now.

For example you could it in-place like that (call the method like this: removeDups(array, &size);):

void removeDups(int *array, int *length)
{
  int original_len = *length;
  for(int i = 0; i < original_len - 1; ++i)
  {
    for(int j = i + 1; j < *length; ++j)
    {
      if(array[i] == array[j])
      {
        array[j] = array[*length - 1];
        (*length)--;
        j--;  // since the new `array[j]` element might be also a duplicate of `array[i]`
      }
    }
  }
  printf("Number of new elements: %d,", *length);
  printf(" new elements: ");
  for(int i = 0; i < *length; i++)
  {
    printf("%d ", array[i]);
  }
}

Now the output would be:

Number of new elements: 7, new elements: 4 7 8 6 2 3 10

where the original order of the elements is not preserved.

If you want to do it in-place and preserve the original order, then instead of swapping every time you find a duplicate, you should shift all the subarray from the (j+1)-th element one position to the left.

This is a much more expensive operation in terms of Time Complexity, but that's the trade-off, you are slower, but you preserve order. You should do what your application requires you to do, i.e. if order matters, do the shift-approach, if order does not matter, use the swap-approach.