Problèmes avec la liste liée en C

Question

Je suis novice en C et je travaille sur une liste liée XOR pour un projet. J'ai la plupart du code fait, mais je ne peux pas sembler obtenir la fonction de suppression de la liste pour fonctionner correctement. Il semble capable de supprimer certains nombres, mais pas n'importe quel nombre que vous passez dans la fonction. Est-ce que quelqu'un avec C pourrait jeter un coup d'oeil et peut-être indiquer où je me suis trompé? Je travaille sur ce sujet depuis un certain temps maintenant et n'ai pas eu beaucoup de chance et j'ai commencé plus de 3 fois :(Toute aide est très appréciée Merci Vous pouvez voir ma première tentative de code here Je ne peux publier qu'un seul lien , donc si vous voulez voir ma deuxième tentative, me le dire et je peux l'envoyer par courriel à vous ou quelque chose que vous remercions de votre temps

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

struct node { 
     int data; 
     unsigned long link; 
}; 
struct node *head, *tail, *currN, *prevN, *nextN, *tmp; 

void insert(struct node **headN, struct node **tailN, int n); 
void delete(struct node **headN, struct node **tailN, int n); 
void list(struct node *head, int i); 
void nextNode(); 
void previNode(); 

//============================================================ 

void insert(struct node **headN, struct node **tailN, int numN) { 
    struct node *newnode = malloc(sizeof(struct node)); 
    newnode->link =(unsigned long)(*headN); 
    newnode->data = numN; 

    //if empty list 
    if (*headN == NULL){ 
      *headN = newnode; 
      currN = *headN; 
      (*headN)->link = 0; 
    } else if ((*headN)->link == (unsigned long)NULL){ 
      if (numN <= (*headN)->data){ 
       newnode->link = (unsigned long) *headN; 
       (*headN)->link = (unsigned long) newnode; 
       tail = *headN; 
       *headN = newnode; 
       nextN = tail; 
       prevN = NULL; 
      } else { 
       newnode->link = (unsigned long) *headN; 
       (*headN)->link = (unsigned long) newnode; 
       tail = newnode; 
       nextN = NULL; 
       currN = tail; 
       prevN = *headN; 
       } 
    } else { 
      currN = *headN; 
      prevN = NULL; 
      nextN = (struct node *)(currN->link^(unsigned long) prevN); 
      if (numN > tail->data){ 
       while (currN!=tail){ 
        nextNode(); 
       } 
       newnode->link = (unsigned long) currN; 
       currN->link = (unsigned long) newnode^(unsigned long) prevN; 
       tail = newnode; 
      } else if (numN < head->data){ 
       currN->link = (unsigned long) newnode^(unsigned long) nextN; 
       newnode->link = (unsigned long) currN; 
       *headN = newnode; 
       nextN = currN; 
       currN = *headN; 
      } else { 
       while (numN > currN->data){ 
        nextNode(); 
       } 
       newnode->link = (unsigned long) prevN^(unsigned long) currN; 
       prevN->link ^= (unsigned long) currN^(unsigned long) newnode; 
       currN->link ^= (unsigned long) prevN^(unsigned long) newnode; 
      } 
    } 
} 

void delete(struct node **headN, struct node **tailN, int numD){ 

    struct node *prevN = NULL; 
    struct node *currN = *headN; 

    while (currN != NULL) 
    { 
     struct node *nextN = (struct node *) (currN->link^(unsigned long)prevN); 
     //if the number is found, then delete it 
     if (currN->data == numD) 
     { 
      if(prevN) 
        { 
        prevN->link ^= (unsigned long)currN^(unsigned long)nextN; 
       } 
        else 
        *headN = nextN; 
       if(nextN) 
        { 
        nextN->link ^= (unsigned long)currN^(unsigned long)prevN; 
        } 
        else 
        *tailN = prevN; 
      free(currN); 
      break; 
     } 
      prevN = currN; 
     currN = nextN; 
    } 
} 

void list(struct node *head, int i){ 

    if(i == 0){ 
    currN = head; 
    prevN = NULL; 
    int count = 1; 
    nextN = (struct node *) (currN->link^(unsigned long) prevN); 
    printf("Linked List in ascending order\n"); 
    while(currN!=NULL){ 
      if(count <= 10){ 
       printf("%-5d", currN->data); 
       nextNode(); 
       count++; 
      } 
      else{ 
       printf("\n"); 
       count = 1; 
      } 
    } 
    } 
    printf("\n\n"); 

    if(i == 1){ 
    printf("Linked List in descending order\n"); 
    currN = tail; 
    int count2 = 1; 
    prevN = (struct node *) currN->link; 
    nextN = NULL; 
    while (currN!=NULL){ 
     if(count2 <= 10){ 
       printf("%-5d", currN->data); 
       previNode(); 
       count2++; 

      }else{ 
       printf("\n"); 
       count2 = 1; 
      } 
    } 
    } 
    printf("\n");   
} 

void nextNode(){ 
    nextN = (struct node *) (currN->link^(unsigned long) prevN); 
    prevN = currN; 
    currN = nextN; 
} 

void previNode(){ 
    prevN = (struct node *) (currN->link^(unsigned long) nextN); 
    nextN = currN; 
    currN = prevN;  
} 

int main(){ 

    int i, num; 
    float seed; 
    head = NULL; tail = NULL; currN = NULL; prevN = NULL; nextN = NULL; 

    init_seed(1234567); 
    set_range(1,9999); 
    //inserting data into the linked list 
    for (i=0; i<100; ++i){ 
     num = rndm(); 
     insert(&head, &tail, num); 
    } 

    list((struct node*)head, 0); 
    //delete((struct node**)head, (struct node**)tail, 45); 
    //delete((struct node**)head, (struct node**)tail, 4040); 
    //delete((struct node**)head, (struct node**)tail, 9769); 
    list((struct node*)head, 1); 


    return 0; 
} 

Answer 1

Une note sur votre code:..

Le node.link ne devrait pas être un unsigned long il puisque cela suppose des caractéristiques de votre compilateur/plate-forme

EDIT: Peut-être que je mésusage d sur la liste liée XOR, discussion.

EDIT 2: (comme suggéré par @Matthew Flaschen) utilisez intptr_t pour rendre votre code plus portable.

Answer 2

Il semble que vous ayez pris du code sur Internet et essayé de l'utiliser.

Le code fonctionne très bien, vous ne savez pas ce qu'est un pointeur.

Vous faites:

delete((struct node**)head, (struct node**)tail, 45); 

Et voici les définitions des variables head et tail:

struct node { 
    int data; 
    unsigned long link; 
}; 
struct node *head, *tail, *currN, *prevN, *nextN, *tmp; 

Le prototype de la fonction delete() est void delete(struct node **headN, struct node **tailN, int numD);

« Oh la le compilateur demande struct node **, jetons-le ". Ce n'est pas comme ça que ça fonctionne.

Essayez ceci:

delete(&head, &tail, 45); 

Answer 3

En regardant la fonction delete me demande au sujet de cette manipulation de pointeur, par la manière, vous utilisez adresse des paramètres si vraiment il devrait être delete(&head, &tail, 45);

passer de cette ....

 
void delete(struct node **headN, struct node **tailN, int numD) 
{ 
    struct node *prevN = NULL; 
    struct node *currN = *headN; 
    struct node *tempNode = NULL; 

    while (currN != NULL) 
    { 
     struct node *nextN = (struct node *) (currN->link^(unsigned long)prevN); 
     //if the number is found, then delete it 
     if (currN->data == numD) 
     { 
      if(prevN) 
      prevN->link ^= (unsigned long)currN^(unsigned long)nextN; 
      else 
      *headN = nextN; 
      if(nextN) 
      nextN->link ^= (unsigned long)currN^(unsigned long)prevN; 
      else 
      *tailN = prevN; 
      /* Sanity check here...you could be screwing up the list 
      ** by calling free(currN) 
      */ 
      tempNode = currN; 
      free(tempNode); 
      /* free(currN); <-- That could be misleading... */ 
      break; 
     } 
     prevN = currN; 
     currN = nextN; 
    } 
} 

cette modification du code est de veiller à ce que currN est cohérente, regardant avec des yeux sur la manipulation du pointeur, cela pourrait être discutable, comme la liste pourrait se retrouver brisée en faisant un free sur le currN ... juste pour être sûr ...