為什么不是我的 reverse(); function 工作？

Question

我正在 C 中編寫一個用於反轉循環單鏈表的程序。 由於某種原因，我不斷收到分段錯誤。 我確定問題出在reverse function 上，因為我嘗試評論 function 調用，程序運行良好。

對於我的reverse() function，我使用了 3 個指針： prev 、 next和curr 。 邏輯是我將運行一個循環，直到curr獲取head的地址，該地址將存儲在最后一個節點的link部分，因為它是一個循環鏈表。 我將使用prev指針繼續更新curr->link ，這會將其鏈接從下一個節點更改為其前一個節點。

當循環中斷時， head->link = prev; 和head = prev; 將更新各自的地址，使它們指向反向列表的第一個節點。

//reversing CLL

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

struct node {
    int data;
    struct node *link;
} *head;

void reverse() {
    struct node *prev = NULL, *curr = head, *next;
        
    while (curr != head) {
        next = curr->link;
        curr->link = prev;
        prev = curr;
        curr = next;
    }
        
    head->link = prev;
    head = prev; 
}

void createList(int n) {
    int i, data;    
    
    head = (struct node *)malloc(sizeof(struct node));
        
    struct node *ptr = head, *temp;
            
    printf("Enter data of node 1\t");
    scanf("%d", &data);
            
    head->data = data;
    head->link = NULL;
            
    for (i = 2; i <= n; i++) {
        temp = (struct node *)malloc(sizeof(struct node));
                        
        printf("Enter data of node %d\t", i);
        scanf("%d", &data);
                        
        temp->data = data;
        temp->link = NULL;
                        
        ptr->link = temp;
        ptr = ptr->link;
    }
    ptr->link = head;
}

void disp() {
    struct node *ptr = head;
        
    do {
        printf("%d\t", ptr->data);   //gdb debugger shows problem is in this line
        ptr = ptr->link;
    } while (ptr != head);
}

int main() {
    int n;
        
    printf("Enter no of nodes to be created\t");
    scanf("%d", &n);
        
    createList(n);
            
    printf("\n\nList is displayed below!\n");
        
    disp();
            
    printf("\n\nReversing list ...\n");
            
    reverse();   // on commenting this call, disp() function 
                 // works accurately showing node data non-reversed
                  
    disp();
            
    printf("\n\nList successfully reversed!\n");
}

Answer 1

reverse() function 中的循環立即退出，因為curr已初始化為head的值，因此測試while (curr != head)在第一次迭代時為假。

reverse() then sets head->link to NULL and finally head is also set to NULL (the initial value of prev ), which explains the segmentation fault in the subsequent disp() function where you use a do { } while (pre != head)無法處理空列表。

這是修改后的版本：

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

struct node {
    int data;
    struct node *link;
};

struct node *reverse(struct node *head) {
    struct node *prev = NULL, *curr = head;

    if (head) {
        do {
            struct node *next = curr->link;
            curr->link = prev;
            prev = curr;
            curr = next;
        } while (curr != head);
        curr->link = prev;
        head = prev;
    }
    return head;
}

struct node *createList(int n) {
    struct node *head = NULL, *tail = NULL, *temp;
    int i;

    for (i = 1; i <= n; i++) {
        temp = (struct node *)malloc(sizeof(struct node));
        temp->data = 0;
        temp->link = NULL;

        printf("Enter data of node %d\t", i);
        scanf("%d", &temp->data);

        if (head == NULL) {
            head = temp;
        } else {
            tail->link = temp;
        }
        tail = temp;
        temp->link = head;
    }
    return head;
}

void disp(struct node *head) {
    if (head) {
        struct node *ptr = head;
        do {
            printf("%d\t", ptr->data);
            ptr = ptr->link;
        } while (ptr != head);
    }
}

int main() {
    struct node *head;
    int n = 0;

    printf("Enter no of nodes to be created\t");
    scanf("%d", &n);

    head = createList(n);

    printf("\n\nList is displayed below!\n");
    disp(head);

    printf("\n\nReversing list ...\n");

    head = reverse(head);

    disp(head);

    printf("\n\nList successfully reversed!\n");

    // should free the list
    return 0;
}

Answer 2

對於初學者來說，使用全局變量head是個壞主意

struct node {
    int data;
    struct node *link;
} *head;

在這種情況下，函數依賴於全局變量，您不能在程序中使用多個列表。

由於這個初始化

struct node *prev = NULL, *curr = head, *next;
                          ^^^^^^^^^^^^

while 循環的條件

while (curr != head) {

is 永遠不會計算為 true，因為最初指針curr等於指針head 。

此外，如果列表為空，則此語句

head->link = prev;

調用未定義的行為。

這是一個演示程序，顯示了如何在 main 中聲明列表然后反轉。

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

struct node 
{
    int data;
    struct node *link;
};

size_t assign( struct node **head, const int a[], size_t n )
{
    while ( *head )
    {
        struct node *tmp = *head;
        *head = ( *head )->link;
        free( tmp );
    }
    
    size_t total = 0;
    
    struct node *first = NULL;
    
    while ( total < n && ( *head = malloc( sizeof( struct node ) ) ) != NULL )
    {
        ( *head )->data  = a[total];
        ( *head )->link  = NULL;
        ++total;
        
        if ( first == NULL ) first = *head;
        
        head = &( *head )->link;
    }
    
    if ( first != NULL ) *head = first;
    
    return total;
}

void display( const struct node *head )
{
    if ( head != NULL )
    {
        const struct node *current = head;
        do
        {
            printf( "%d -> ", current->data );
        } while ( ( current = current->link ) != head );
    }       
    
    puts( "null" );
}

struct node * reverse( struct node **head )
{
    if ( *head )
    {
        struct node *last = *head;
        struct node *prev = NULL;

        while ( ( *head )->link != last )
        {
            struct node *current = *head;
            *head = ( *head )->link;
            current->link = prev;
            prev = current;
        }
        
        ( *head )->link = prev;
        last->link = *head;
    }
    
    return *head;
}

int main(void) 
{
    struct node *head = NULL;
    
    int a[] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 };
    
    assign( &head, a, sizeof( a ) / sizeof( *a ) );
    
    display( head );
    
    display( reverse( &head ) );
    
    display( reverse( &head ) );
    
    return 0;
}

程序 output 是

0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> null
9 -> 8 -> 7 -> 6 -> 5 -> 4 -> 3 -> 2 -> 1 -> 0 -> null
0 -> 1 -> 2 -> 3 -> 4 -> 5 -> 6 -> 7 -> 8 -> 9 -> null