在c中交换反转链表

Question

给定一个列表，我想通过将第一个与最后一个交换，第二个与倒数第二个交换，以此类推。

我编写了这个函数来交换每一对，其中pos1 和pos2 是要交换的两个位置。

maxPos 是两个位置中最大的一个， node1 和node2 是遍历列表后找到的两个节点。

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

而不是为每一对递归地调用它，即。 (1,n-1), (2,n-2), (3,n-3) 每次都要遍历列表，想知道有没有办法迭代解决。

Answer 1

您真的要交换节点内容吗？

您可以使用一个非常简单的函数迭代地反转列表：

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

当使用带有锚元素的列表时（例如，第一个元素是节点但不用于存储数据），您可以使用

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

用于交换操作。但是对于单链表，由于昂贵的节点查找，您的反向操作具有 O(n^2) 的复杂性。

如其他地方所述，用于反转列表：

• 使用双链接的
• 用 O(n) 反向迭代它
• 移除元素 (O(1))
• 将元素附加到新的头部 (O(1))
• 将新列表合并到旧列表中 (O(1))

Answer 3

您必须声明一个新方法来反转整个列表，该方法只会被调用一次。另外你最好使用双向链表来解决这个问题。

节点结构：

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

方法：

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