反转链表的每k个节点

Question

I have two implementation of reversing a linked list. The first one is defined as Node *Reverse(Node *head, int k) method. This method reverses every k alternate sub groups of a linked list.

Example: Inputs: 1->2->3->4->5->6->7->8->NULL and k = 3
Output: 3->2->1->6->5->4->8->7->NULL

The other implementation is defined as kAltReverse(Node *head, int k). This function reverses every k node but then skips the next k node and does the same for the next k node.

 Example Input: 1->2->3->4->5->6->7->8->9->NULL and k = 3
 Output: 3->2->1->4->5->6->9->8->7->NULL 

Here is my code with definition of the Node structure and the two functions Reverse and kAltReverse

// This is the definition of node structure
typedef struct container{
    int data;
    struct container *next;
} Node;


 Node *reverse(Node *head, int k){
    Node *temp = head;
    Node *curr = head;
    Node *prev = NULL;
    Node *next = NULL;
    int count = 0;

    // Reverses the first k nodes iteratively
    while (curr != NULL && count < k){
            next = curr->next;
            curr->next = prev;
            prev = curr;
            curr = next;
            count++;
    }

    // Recursively linking the head of the list to next reversed list.
    if (next != NULL) temp->next = reverse(next,k);
    return prev;
}


Node *kAltReverse(Node *head, int k){
    Node *temp = head;
    Node *curr = head;
    Node *prev = NULL;
    Node *next = NULL;
    int count = 0;

    // Reverse the first k node of the linked list
    while (curr != NULL && count < k){
            next = curr->next;
            curr->next = prev;
            prev = curr;
            curr = next;
            count++;
    }

    // Now head points to the kth node. So change next of head to (k+1)th node
    if (head != NULL) temp->next = curr;
    count = 0;

    //Move the pointer node so as to skip next k nodes.
    while(curr != NULL && count < k-1){
            curr = curr->next;
            count++;
    }

    // Recursively call for the list starting from curr->next.
    // And make rest of the list as next of first node.
    if (curr != NULL) curr->next = kAltReverse(curr->next,k);


    return prev;
}

int main(){
    Node *head1 = NULL;
    /* Insert function is a function for pushing the element in stack 
       like fashion on to the list*/
    insertFirst(&head1, 6);
    insertFirst(&head1, 4);
    insertFirst(&head1, 3);
    insertFirst(&head1, 2);
    insertFirst(&head1, 1);
    insertFirst(&head1, 5);
    // So the list will be 5->1->2->3->4->6->NULL

    // Now when I call the functions Reverse and kAltReverse I get undesired 
    // output.
    printlist(head1);
    Node *Reverse = reverse(head1, 2);
    printlist(Reverse);
    Node *kAlt1 = kAltReverse(head1,2);
    printlist(kAlt1);
    return 0;
}

The output which I get is:

  5 1 2 3 4 6  // This is the original list 

  1 5 3 2 6 4  // This is the output given by Reverse method

  3 5 2 6 4    // This is the output given by kAltReverse method

But if I call them separately and comment out the other method, I get desired output ie

Output from reverse: 1 5 3 2 6 4 // This is correct

Output form kAltReverse as: 1 5 2 3 6 4 // This is correct too.

So they work separately but not together.

I am unable to figure out why this happens when both are called simultaneously. On the other hand when these methods are called independent of each other they give proper output. Please help.

Answer 1

You don't change head , but you do change (reorder) the interior nodes inside the list. Try calling printlist(head1) after calling reverse and you will see it. – Some programmer dude

Using a call by value does not create a copy of the whole linked linked list. It just works on a copy of the head node. In the frame of the function reverse(head1, 2); , a copy of head1 is used in the context of the function and head1 is left unchanged. Let's call this copy head1f . If head1f.data=42 is called, head1.data is unchanged. But if head1f.next->data=42 is used instead, head1.next->data is now 42 : head1f.next and head1.next points to the same Node . – francis