交换反转c中的链表

Question

Given a list, I want to reverse the list by swapping the first with the last, second with the second last and so on.

I wrote this function to swap each pair where pos1 and pos2 are the two positions to be swapped.

maxPos is the largest of the two positions, node1 and node2 are the two nodes that were found after traversing the list.

int swap(struct node *list, int pos1, int pos2) {

    if (node1 != NULL && node2 != NULL) {
        if (prev1 != NULL)
            prev1->next = node2;
        if (prev2 != NULL)
            prev2->next = node1;
        temp        = node1->next;
        node1->next = node2->next;
        node2->next = temp;
        if (prev1 == NULL)
            head = node2;
        else if (prev2 == NULL)
            head = node1;
    }
    return 1;
}

Instead of calling this recursively for each pair, ie. (1,n-1) , (2,n-2) , (3,n-3) for which it has to traverse the list every time, I was wondering if there is a way for it to be solved iteratively.

Answer 1

Do you really want to swap node contents?

You can reverse the list iteratively with a very simple function:

struct node {
    // whatever payload fields...
    struct node *next;
};

struct node *reverse_list(struct node *list) {
    struct node *last = NULL;
    while (list != NULL) {
        struct node *next = list->next;
        list->next = last;
        last = list;
        list = next;
    }
    return last;
}

Answer 2

When using a list with an anchor element (eg the first element is a node but not used for storing data), you can use

struct node **list_nth(struct node *node, size_t idx)
{
    for (;idx > 0 && node; --idx)
        node = node->next;

    return node ? &(node->next) : NULL;
}

void list_swap(struct node *head, size_t idx_a, size_t idx_b)
{
    struct node **a = list_nth(head, min(idx_a, idx_b));
    struct node **b = list_nth(head, max(idx_a, idx_b));
    struct node *tmp;

    if (idx_a == idx_b)
        return;

    if (!a || !b)
        abort();

    if ((*a)->next == *b) {
        tmp = *a;

        *a  = *b;
        tmp->next = (*b)->next;
        (*a)->next = tmp;
    } else {
        tmp        = (*a)->next;
        (*a)->next = (*b)->next;
        (*b)->next = tmp;

        tmp = *a;
        *a  = *b;
        *b  = tmp;
    }
}

for the swap operation. But for single linked lists, your reverse operation has a complexity of O(n^2) due to the expensive node lookup.

As noted somewhere else, for reversing a list:

• use a double-linked one
• iterate it in reverse with O(n)
• remove the element (O(1))
• append the element to a new head (O(1))
• merge the new list into the old one back (O(1))

Answer 3

You'll have to declare a new method for reversing the whole list that'll be called only once. Also you'd better use a doubly-linked list for this problem.

Node structure:

struct node {
    int data;
    struct node *next;
    struct node *prev;
};

Method:

void reverse() {

    struct node *temp = head; // assuming you have the head node as a global variable.
    struct node *lastPtr = head;

    for (int i = 0; i < len; i++) { // assuming you have length as a global variable.
        lastPtr = lastPtr->next;
    }

    for (int i = 0; i < len / 2; i++) {
        temp->data += lastPtr->data;
        lastPtr->data = temp->data - lastPtr->data;
        temp->data -= lastPtr->data;
        temp = temp->next;
        lastPtr = lastPtr->prev;
    }
}