2017-11-07 3 views
0

필자는 재귀 적으로 역순으로 시도하는 링크 된리스트의 배열을 가지고있다. 역순으로 함수를 호출하면 모든 노드를 리버스하지 않고 두 개의 노드를 리버스합니다.링크 된리스트의 배열을 반복적으로 뒤집는 것이 모든 노드를 순서대로 뒤집지 않는다.

반전 기능은 첫 번째 노드 (기본 사례)를 삭제하고 그 지점을 마지막 노드 (하위 사례의 끝)로 채우는 것처럼 보입니다. 나는 문제가 그것에 대한 루프의 호출에 있다고 생각한다 reverse_nodes 그러나 그 문제를 해결하지 않는 것 같습니다. 8,6,4,2

난 단지 관련 코드 블록을 포함했다 참고 : 여기에

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 

나는 그것이 읽 반대하려고 노력하고 있어요 .. 어떤 출력 head/tail 구조, 바이너리 파일을 읽기 전에 모든 노드를 삭제하고, 바이너리 파일을 노드로 읽어 들이며, main 함수와 같은 구조체 구조와 같은 구조를 사용합니다. 역기능에서 완전히 역전되지 않는 원인을 알아내는 데 도움이 될 수 있습니까? 시간 내 주셔서 감사합니다. 아래 코드를 참조하십시오!

#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; 
      } 
     } 
    } 

답변

0
#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(); 
} 
0

귀하의 reverse_nodes 기능은 바로 nodenext 멤버가 아닌 현재 노드가리스트의 마지막에 도달 할 때 그래서, 그것은에 마지막 멤버의 next을 설정합니다 설정되어 링크 된 목록의 이전 멤버는 그대로두고 마지막 멤버는 그대로 둡니다.

은 나를 위해 일한 :

#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; 
    } 
} 

편집 :

재귀 일반적으로 당신이 스택을 불어 끝낼 수 있기 좋은 생각 - 그것을 시도하고 당신이해야 할 일을하는 것이 가장있어 가능한 경우 단일 (또는 필요한 경우 다중) 기능 (이 경우에는 쉽게 가능함).

관련 문제