Remove duplicates from const array in c - c

Question

I have to implement a function in C with the following signature: int *unici(const int *vec, size_t size, size_t *newsize), where vec is a const array of ints, size is the size of the array, and *newsize is the size of the new array without duplicates.
This function has to create a new array on the heap and put the values from vec into the array without duplicates.
Example: If vec is [2, 4, 5, 4, 5, 5, 7, 9], size is 8, then the new array should be [2, 4, 5, 7, 9] with *newsize equal to 5.
I tried to implement it, but I don't know how to remove duplicates and put into new array.
int cmpfunc(const void * a, const void * b)
{
return (*(int*)a - *(int*)b);
}
int *unici(const int *vec, size_t size, size_t *newsize)
{
if (size == 0)
return NULL;
qsort(vec, size, sizeof(int), cmpfunc);
size_t count = 0;
for (size_t i = 0; i < size; i++)
{
//finding for duplicates
if (vec[i] == vec[i + 1])
count++;
}
*newsize = size - count;
int *tmp = malloc(*newsize * sizeof(int));
//now I've to put in tmp values from vec without duplicates
}
EDIT: that's my solution, I figured out, by the way, thank you all!
int *unici(const int *vec, size_t size, size_t *newsize)
{
if (size == 0)
return NULL;
int *tmp = malloc(size * sizeof(int));
for (size_t i = 0; i < size; i++)
{
tmp[i] = vec[i];
}
for (size_t i = 0; i < size; i++)
{
for (size_t j = i + 1; j < size; j++)
{
if (tmp[i] == tmp[j])
{
for (size_t k = j; k<size; k++)
{
tmp[k] = tmp[k + 1];
}
size--;
j--;
}
}
}
*newsize = size;
return tmp;
}

Answer 1

There are two basic approaches.
Duplicate the original array. Sort the elements in the new array, and use a loop to keep only the first one of any runs (more than one same value):
int *result; /* This is the duplicate array; sorted */
size_t i = 0; /* Loop index */
size_t n = 0; /* Unique elements in the duplicate array */
while (i < size) {
const int c = result[i++];
/* Skip if there are more than one consecutive c */
while (i < size && c == result[i])
i++;
/* Copy the unique elements back to the beginning
of the array. */
result[n++] = c;
}
You can, if you want, reallocate result to n * sizeof result[0] bytes.
Store the number of unique elements n to *newsize, and return result.
Allocate the result array, but don't bother copying the values yet. Instead of sorting (to make duplicate values consecutive), use a double loop to check whether each value is unique (already in the result array) or not, and only copy the unique ones to the result array:
int *result; /* Allocated for 'size' elements */
size_t i, j; /* Loop indexes */
size_t n = 0; /* Unique elements in the duplicate array */
for (i = 0; i < size; i++) {
/* Find first duplicate in result. */
for (j = 0; j < n; j++)
if (result[j] == vec[i])
break;
/* If no duplicates found, add to result. */
if (j >= n)
result[n++] = vec[i];
}
You can, if you want, reallocate result to n * sizeof result[0] bytes.
Store the number of unique elements n to *newsize, and return result.
Which one is the better approach, depends on how the result set is used, and whether it is useful for it to be in sorted order. If sorted order is useful, or if speed is important and the order does not matter, the sort approach is likely better.
(The efficiency of the sort approach depends on the efficiency of the sort function. Many sort functions are known that have O(size × log size) time complexity; for a truly huge amount of data, an O(size) radix sort can be used (because the number of values is known beforehand). Note that a radix sort will only beat other sorts for very large sizes, typically in the millions.)
In some cases, it might be important that the result set is in the same order as the vec was, but with the duplicates removed. Then, the second approach is the obvious choice. Its time complexity is O(size × n), which means that it slows down the larger the array and the set of unique elements are.

Answer 2

First of all you don't want const int* in unici it throws the warning
passing argument 1 of ‘qsort’ discards ‘const’ qualifier from pointer target type
And then we go on, to allocating memory for each of the integers that are non-duplicate.
int *unici(int *v, size_t size, size_t *newsize)
{
if (size == 0)
return NULL;
qsort(v, size, sizeof(int), cmpfunc);
int *temp = malloc(sizeof *temp);
if (temp == NULL){
perror("Error ");
exit(EXIT_FAILURE);
}
(*newsize)= 0;
temp[(*newsize)++] = v[0];
for (size_t i = 1; i < size; i++)
{
if (v[i] != v[i-1]){
int *tt = realloc(temp,(*newsize+1)*sizeof *tt);
if (tt == NULL){
perror("Error ");
exit(EXIT_FAILURE);
}
temp = tt;
temp[(*newsize)++] = v[i];
}
}
return temp;
}
There are two points with this code
Here the array is supposed to be constant. So it must do duplicate of the array and then do the sorting and then eliminate duplicates and resize again as per the unique elements present. This is having the benefit that the const removal as mentioned - you don't have to do that.
In my code I have used reallocate for each of the elements - which is an overkill. So what to do then? Well as said earlier we will allocate it to maximum size and then reduce the size to the unique list. That again leaves us to debate should we reduce it every time? (Suppose 1-2 positions left out.) Well then it is not so much needed to resize but well one can do that. It's implementor's choice to some extent.
The idea of this simple shrinking is being implemented here:-
int *unici(const int *vv, size_t size, size_t *newsize)
{
if (size == 0)
return NULL;
int *v = malloc(sizeof *v * size);
if (v == NULL){
perror("Error in malloc");
exit(EXIT_FAILURE);
}
memcpy(v, vv, size*sizeof*v);
qsort(v, size, sizeof(int), cmpfunc);
(*newsize)= 0;
int last = v[0];
for (size_t i = 1; i < size; i++)
{
if (v[i] != last){
v[(*newsize)++] = last;
last = v[i];
}
}
v[(*newsize)++] = v[size-1];
int *temp = realloc(v, (*newsize)*sizeof *v);
if (temp == NULL){
perror("Error in realloc");
exit(EXIT_FAILURE);
}
v = temp;
return v;
}

Answer 3

Since you sorted your vector it should be easy. Iterate over the vector.. and copy values if they don't match with the previous value. Something like this (not verified compilable code):
size_t src;
size_t dst;
for (src = 0, dst = 0; src < size; src++)
{
// skip check for first element; compare with previous and if they are the same just move on
if (src > 0 && vec[src] == vec[src - 1])
continue;
tmp[dst] = vec[src];
dst++;
}