单向链表并交集问题

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

typedef struct Element
{
    int val;
    struct Element *suivant;
}Element;

typedef struct List
{
    Element *tete;
}List;

typedef struct File //队列
{   Element *front;
    Element *rear;
}File;

 List *Initialize()
 {
     List *list = malloc(sizeof(List));
    if(list != NULL){
        list -> tete =NULL;    //initialisation de la tele
    }
    return list;
 }

void Insert(List * list, int element)
{
    Element *new=malloc(sizeof(Element));
    Element *p=list->tete;
    new->val=element;
    //insertion de la tete
    if(p==NULL||p->val>=element)
    {
        new->suivant=p;
        list->tete=new;
    }
    else
    {
        while(p->suivant&&p->suivant->val<element)
            p=p->suivant;
        new->suivant=p->suivant;
        p->suivant=new;
    }
}

void Display(List *list)
{
    if(list&&list->tete){
            Element *p=list->tete;
            while(p){
                printf(" %d",p->val);
                p=p->suivant;
            }
        }
        else{
            printf("cette liste est vide");
        }
}

 int isPresent(Element *head, int val)  //判断是否存在
{
    Element *t = head;
    while(t != NULL)
    {
        if( t->val == val )
            return 1;
        t = t->suivant;
    }
    return 0;
}


 List *Intersect(List *list1, List *list2)
 {
     List* result=Initialize();
     Element *p1=list1->tete;
     Element *p2=list2->tete;
     while(p1)
     {
         if(isPresent(p2,p1->val))
            Insert(result,p1->val);
         p1=p1->suivant;
    }
    return result;
 }

List *Union(List *list1, List *list2)
 {
     List* result=Initialize();
     Element *p1=list1->tete;
     Element *p2=list2->tete;
     while(p1)
     {
         Insert(result,p1->val);
         p1=p1->suivant;
     }
     while(p2)
     {
         if(!isPresent(result->tete,p2->val))
         Insert(result,p2->val);
         p2=p2->suivant;
    }
    return result;
 }

 File *Initialize_File()
 {
     File *file=malloc(sizeof(File));
     file->front=NULL;
     file->rear=NULL;
     return file;
 }

void Push(File * file, Element element)
{
    Element *new=malloc(sizeof(Element));
    new->val=element.val;
    new->suivant=NULL;
    if(file->front==NULL)
    {
        file->front=new;
        file->rear=new;
    }
    else
    {
        new->suivant=file->front;
        file->front=new;
    }

}

 Element Pop(File *file)  
 {   Element *p1=file->front;
     Element *p2=file->rear;
     if(file->front==NULL)
        printf("vide");
     else
        {
            while(p1->suivant!=p2)
                p1=p1->suivant;
            file->rear=p1;
        }
     return *p2;
 }

File *ListToFile(List *list)
{
    Element *p=list->tete;
    File *file=Initialize_File();
    while(p)
    {
        Push(file, *p);
        p=p->suivant;
    }
    return file;
}

void Display_File(File *file)
{   Element *p=file->front;
    while(p)
    {
        printf("%d ",p->val);
        p=p->suivant;
    }
}
 void Reverse(List * list) //遍历整个链表的同时，将正在访问的节点插入到链表头部。
 {
     Element *p=list->tete;
     Element *q=p->suivant;

     while(p->suivant)
     {
        p->suivant=q->suivant;
        q->suivant=list->tete;
        list->tete=q;
        q=p->suivant;
     }

 }

int main()
{   List *list1=Initialize();
    List *list2=Initialize();
    printf("list1:");
    Insert(list1,2);
    Insert(list1,4);
    Insert(list1,6);
    Insert(list1,5);
    Insert(list1,11);
    Display(list1);
    printf("\nlist2:");
    Insert(list2,2);
    Insert(list2,3);
    Insert(list2,5);
    Insert(list2,9);
    Display(list2);
    List *list3=Intersect(list1,list2);
    printf("\nIntersection:");
    Display(list3);
    List *list4=Union(list1,list2);
    printf("\nUnion:");
    Display(list4);
    printf("\nUse queue:");
    File *file=ListToFile(list1);
    Display_File(file);
    printf("\nReverse_list2:");
    Reverse(list4);
    Display(list4);
    return 0;
}