Das rekursive Umkehren eines Arrays von verketteten Listen ist nicht die Umkehrung aller Knoten in der Reihenfolge

Question

Ich habe ein Array von verketteten Listen, die ich rekursiv umkehren möchte. Wenn ich die Funktion zum Reverse aufrufen, werden nicht alle Knoten, sondern ein paar Knoten umgekehrt.

Die umgekehrte Funktion scheint den ersten Knoten (Basisfall) zu löschen und seinen Punkt mit dem letzten Knoten zu füllen (Ende des Unterfalles). Ich denke, dass das Problem in dem Aufruf der for-Schleife innerhalb der reverse_nodes Funktion liegt, aber das scheint nicht zu beheben. Hier

ist eine Ausgabe ..

pre-reverse function: 
----- 
group 0 

alice, 2 
----- 
group 1 

martin, 4 
----- 
group 2 

keanu, 6 
----- 
group 3 

miles, 8 


post - reverse function 
----- 
group 0 

miles, 8 
----- 
group 1 

martin, 4 
----- 
group 2 

keanu, 6 
----- 
group 3 

miles, 8 

Ich versuche, es zu umkehren zu bekommen, dass es lautet: 8,6,4,2

Bitte beachten Sie, ich nur einen entsprechenden Code-Blöcke enthalten sind, wie die struct-Architektur, die Head/Tail-Konstruktion, das Löschen aller Knoten vor dem Einlesen der Binärdatei, das Lesen der Binärdatei in Knoten und die Hauptfunktion. Kann ich Hilfe bekommen, um herauszufinden, was in der umgekehrten Funktion dazu führt, dass es sich nicht vollständig umkehrt? Danke für deine Zeit. Siehe Code unten!

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

    typedef struct node 
    { 
     char name[20]; 
     int size; 
     struct node *next; 
    }node; 

    node* head[4]={NULL,NULL,NULL,NULL}; 
    node* tail[4]={NULL,NULL,NULL,NULL}; 


    void wipe_nodes() 
    { 
     int i; 

     node *p=NULL; 

     for(i=4; i>0; i--) 
     { 
      p=head[i]; 

      if(p == NULL) 
      { 
       printf("Nodes are clear!\n"); 
      } 

      while(p != NULL) 
      { 
       delete_party(p->name, p->size); // cant call name and size 
       p = p -> next; 
      } 

     } 
    } 


    void bin_to_list(char *filename) 
{ 
    FILE *fp; 
    int ret; 


    fp = fopen(filename, "rb"); 

    if (fp == NULL) 
    { 
     printf("Null file!\n"); 
     return; 
    } 



    node temp; 

    //temp = (node *)malloc(sizeof(node)); 



    while((ret = fread(&temp, sizeof(node), 1, fp) > 0)) 
    { 
     printf("%s %d", temp.name, temp.size); 
     if(temp.size == 0) 
     { 
      printf("\nThat is not a valid command. Party not added!\n"); 
     } 
     if(temp.size >= 1 && temp.size <= 2) 
     { 
      add_party(0, temp.name, temp.size); 
     } 
     else if(temp.size >= 3 && temp.size <= 4) 
     { 
      add_party(1, temp.name, temp.size); 
     } 
     else if(temp.size >= 5 && temp.size <= 6) 
     { 
      add_party(2, temp.name, temp.size); 
     } 
     else if(temp.size >= 7) 
     { 
      add_party(3, temp.name, temp.size); 
     } 
    } 

    fclose(fp); 
    return; 
} 


    void reverse_nodes(node *p, node *q) 
    { 
     int i; 

     for(i=0; i<4; i++) 
     { 
      //node *p=head[i]; 

      if(p == NULL) 
      { 
       printf("Error, no nodes!\n"); 
       return; 
      } 


      if (p->next == NULL) 
      { 
       printf("LOL, only one node! Can't reverse!\n"); 
       head[i] = p; 
      } 

      else 
      { 
       reverse_nodes(p->next, p); 
      } 

      p->next = q; 
      return; 



    int main(int argc, char *argv[]) 
    { 
     int x, i; 
     read_to_list(argv[1]); 
     bin_to_list(argv[2]); 
     while (1) 
     { 
      fflush(stdin); 
      printf("\n\nEnter 1 to add a party\nEnter 2 to remove a party\nEnter 3 for the list of the party\nEnter 4 to change party size.\nEnter 5 to quit (write to .txt file).\nEnter 6 to read from bin file.\nEnter 7 to reverse the list.\n\n"); 

      scanf("%d",&x); 
      char name[20]; 
      int size; 
      switch(x) 
      { 

       case 1: 
        printf("\nParty Name: "); 
        scanf("%s", name); 
        printf("\nParty Size: "); 
        scanf("%d", &size); 
        if(size == 0) 
        { 
         printf("\nThat is not a valid command. Party not added!\n"); 
        } 
        if(size >= 1 && size <= 2) 
        { 
         add_party(0, name, size); 
        } 
        else if(size >= 3 && size <= 4) 
        { 
         add_party(1, name, size); 
        } 
        else if(size >= 5 && size <= 6) 
        { 
         add_party(2, name, size); 
        } 
        else if(size >= 7) 
        { 
         add_party(3, name, size); 
        } 
        break; 

       case 2: 
        printf("\nSize of party to delete: "); 
        scanf("%i", &size); 
        delete_party(NULL, size); 
        break; 

       case 3: 
        list_parties(); 
        break; 

       case 4: 
        change_partysize(name, size); 
        break; 

       case 5: 
        write_to_file(argv[1]); 
        write_to_bin(argv[2]); 
        exit(0); 
        break; 

       case 6: 
        wipe_nodes(); 
        bin_to_list(argv[2]); 
        break; 

       case 7: 
        for(i=0; i<4; i++) 
        { 
         reverse_nodes(head[i], NULL); 
        } 
        break; 

       default: 
        continue; 
      } 
     } 
    } 

Answer 1

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

/* Link list node */ 
struct Node 
{ 
    int data; 
    struct Node* next; 
}; 

/* Function to reverse the linked list */ 
static void reverse(struct Node** head_ref) 
{ 
    struct Node* prev = NULL; 
    struct Node* current = *head_ref; 
    struct Node* next; 
    while (current != NULL) 
    { 
     next = current->next; 
     current->next = prev; 
     prev = current; 
     current = next; 
    } 
    *head_ref = prev; 
} 

/* Function to push a node */ 
void push(struct Node** head_ref, int new_data) 
{ 
    /* allocate node */ 
    struct Node* new_node = 
      (struct Node*) malloc(sizeof(struct Node)); 

    /* put in the data */ 
    new_node->data = new_data; 

    /* link the old list off the new node */ 
    new_node->next = (*head_ref);  

    /* move the head to point to the new node */ 
    (*head_ref) = new_node; 
} 

/* Function to print linked list */ 
void printList(struct Node *head) 
{ 
    struct Node *temp = head; 
    while(temp != NULL) 
    { 
     printf("%d ", temp->data);  
     temp = temp->next; 
    } 
}  

/* Driver program to test above function*/ 
int main() 
{ 
    /* Start with the empty list */ 
    struct Node* head = NULL; 

    push(&head, 20); 
    push(&head, 4); 
    push(&head, 15); 
    push(&head, 85);  

    printf("Given linked list\n"); 
    printList(head);  
    reverse(&head);      
    printf("\nReversed Linked list \n"); 
    printList(head);  
    getchar(); 
} 

Answer 2

Ihre reverse_nodes Funktion nur ist das next Mitglied der node Einstellung, nicht den aktuellen Knoten, so dass, wenn es an das Ende der Liste bekommt, wird es die next des letzten Mitglied auf den eingestellten vorherige Mitglied in der verknüpften Liste, aber lassen Sie das letzte Mitglied unberührt.

Dieser arbeitete für mich:

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

typedef struct node 
{ 
    char name[20]; 
    int size; 
    struct node *next; 
}node; 

node* head; 


void reverse_nodes(node ** pphead) 
{ 
    node *prev = NULL; 
    node *current = *pphead; 
    node *next; 

    while (current != NULL) 
    { 
     next = current->next; 
     current->next = prev; 
     prev = current; 
     current = next; 
    } 
    *pphead = prev; 
} 

void main(void) 
{ 
    int i; 
    node * phead; 

    head = phead = (node *)malloc(sizeof(node)); 
    phead->size = 0; 
    for (i = 0; i < 4; i++) 
    { 
     node * p; 

     phead->next = (node *)malloc(sizeof(node)); 
     phead = phead->next; 
     phead->size = i + 1; 
     phead->next = NULL; 
    } 

    reverse_nodes(&head); 

    phead = head; 
    while (phead) 
    { 
     printf("%d\r\n", phead->size); 
     phead = phead->next; 
    } 
} 

Edit:

Rekursion ist in der Regel eine schlechte Idee, wie Sie den Stapel blasen könnten am Ende - es ist immer am besten, um zu versuchen und tun, was Sie tun müssen, in eine einzelne (oder mehrere wenn erforderlich) Funktion (en) wenn möglich, was in diesem Fall leicht möglich ist.