Keep one occurrence of all numbers in a linked list - c

Question

I want to find an algorithm to keep only one occurrence of each number in a linked list using recursion
,I know recursion is not at all a good choice to solve this problem ,but I want to try it.
for more calirification:
input : 1->2->1->3->3->2->1->4
output : 1->2->3->4
Here is the program that i've made to keep only one occurrence of a given number using recursion, but i couldn't develop it in order to solve the whole problem. can I get some help? thanks in advance.
list* wipe(list* head,int val)
{
if(head==NULL) return head;
static int occ=1;
if(head->data == val)
{
if(occ-- < 1)
{
list* temp=head;
head=head->next;
free(temp);
return wipe(head,val);
}
}
head->next=wipe(head->next,val);
return head;
}

Answer 1

occ is set to 1 only the very time you execute the function, so from the second time (head->data == val) is true whatever val the test (occ-- < 1) will be true, this is not the right way.
You can do something like that where the list is modified to only contain unique numbers :
#include <stdio.h>
#include <stdlib.h>
typedef struct List {
struct List * next;
int data;
} List;
/* remove from l all the cells having data equals to v */
List * wipe(int v, List * l)
{
if (l == NULL)
return l;
else if (l->data != v) {
l->next = wipe(v, l->next);
return l;
}
else {
List * n = l->next;
free(l);
return wipe(v, n);
}
}
/* modify the argument to not have duplicated numbers */
void simplify(List * l)
{
while (l != NULL) {
l->next = wipe(l->data, l->next);
l = l->next;
}
}
/* helper function to construct a list */
List * mk(int v, List * n) {
List * l = malloc(sizeof(*l));
l->data = v;
l->next = n;
return l;
}
/* print the list */
void pr(List * l)
{
while (l != NULL) {
printf("%d ", l->data);
l = l->next;
}
putchar('\n');
}
int main()
{
List * l = mk(1, mk(2, mk(1, mk(3, mk(3, mk(2, mk(1, mk(4, NULL))))))));
pr(l);
simplify(l);
pr(l);
/* free the rest of the list */
while (l) {
List * n = l->next;
free(l);
l = n;
}
return 0;
}
Compilation and execution :
pi#raspberrypi:/tmp $ gcc -Wall c.c
pi#raspberrypi:/tmp $ ./a.out
1 2 1 3 3 2 1 4
1 2 3 4
pi#raspberrypi:/tmp $ valgrind ./a.out
==3988== Memcheck, a memory error detector
==3988== Copyright (C) 2002-2017, and GNU GPL'd, by Julian Seward et al.
==3988== Using Valgrind-3.15.0 and LibVEX; rerun with -h for copyright info
==3988== Command: ./a.out
==3988==
1 2 1 3 3 2 1 4
1 2 3 4
==3988==
==3988== HEAP SUMMARY:
==3988== in use at exit: 0 bytes in 0 blocks
==3988== total heap usage: 9 allocs, 9 frees, 1,088 bytes allocated
==3988==
==3988== All heap blocks were freed -- no leaks are possible
==3988==
==3988== For lists of detected and suppressed errors, rerun with: -s
==3988== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
pi#raspberrypi:/tmp $
That way have the complexity O(n2)
A faster way is to first sort the elements in the list then remove the duplicates, allowing to have the complexity of the sort so possibly O(n*log(n)) (probably using a temporary array to sort)

Answer 2

If I have understood correctly you need a recursive function that appends a number to a list only in case when the number is not present already in the list.
If so then the recursive function can look for example like
int append( list **head, int val )
{
if ( *head == NULL )
{
*head = malloc( sizeof( **head ) );
int success = *head != NULL;
if ( success )
{
( *head )->data = val;
( *head )->next = NULL;
}
return success;
}
else if ( ( *head )->data != val )
{
return append( &( *head )->next, val );
}
else
{
return 0;
}
}
And if in main you have a declaration like this
list *head = NULL;
then the function can be called for example like
append( &head, val );
Or like
if ( append( &head, val ) )
{
printf( "The value %d is appended to the list.\n", val );
}