Bon un petit rappel pour commencer.

Rappel sur les fonctions en C

- En C les paramètres de fonction sont des recopies.
- A la fin d'une fonction les variables locales sont effacées.
- Par contre ce qui a pu être alloué dans la fonction n'est pas désalloué si ce n'est pas demandé explicitement.

Rappel sur les pointeurs

Un pointeur sert :
1- à modifier quelque chose qu'on aurait aimé passer en paramètre. Concrètement l'adresse est recopiée, mais pas ce qui est à cette adresse
2- à passer un paramètre plus petit (une adresse est plus rapide à recopier qu'une grosse structure)
3- à ne stocker qu'une fois qu'une donnée si on a besoin dans plusieurs structures.

Les allocations mémoires

En toute rigueur :
- à chaque malloc est associé un free situé dans le même horizon (un horizon est une paire d'accolade)
- parfois ce n'est pas possible donc on crée une sorte de constructeur qui fait l'allocation, et on pense à appeler le destructeur à la fin pour libérer la mémoire.

Les listes chainées

typedef struct maillon{
struct maillon * suivant;
int *data; // dans ton cas une tâche
} maillon_t;

typedef maillon_t * liste_t;

int inserer_tache(liste_t * l,int nouveau){
maillon_t * mcur,mlast;
for(mcur = l; mcur; mcur = mcur->suivant){
if( *(mcur->data) == nouveau ) return 0; // deja présent dans la liste
}
// liste parcourue, on a rien trouvé ! ajout du nouveau maillon
mcur->suivant = (maillon_t *)malloc(sizeof(maillon_t));
mlast = mcur->suivant;
mlast->suivant = NULL;
mlast->data = nouveau;
return 1;
}

Mieux que les listes, les sets

Concrètement ce n'est pas une structure très rapide car l'insertion et l'accès se font en O(n). Une structure de liste triée serait plus rapide, mais idéalement il faudrait une structure d'arbre pour bénéficier d'une dichotomie. Celà suppose que tu aies une relation d'ordre sur les datas. En C++ ca s'écrit présque immédiatement :

#include <set>

// Definition d'une tache
struct tache_t{
int x;
tache_t(int x0=0):x(x0){}
};

// La relation d'ordre
bool operator<(
const tache_t & t1,
const tache_t & t2
){
return (t1.x < t2.x);
}

int main(){
std::set<tache_t> taches; // ensemble des taches
tache_t t1(1),t2(5),t3(2);
taches.insert(t1);
taches.insert(t2);
taches.insert(t3);
return 0;
}
Le set permet définit un ensemble ordonné d'élément insérés de manière unique. L'accès et l'insertion se font en O(log(n)) ce qui est nettement plus rapide...

Bonne chance