设计算法将单链表L就地逆置，即利用原表各结点的空间实现逆置

可以按照以下步骤进行单链表的就地逆置：

1. 定义三个指针：pre、cur、next，分别表示当前节点的前一个节点、当前节点和当前节点的后一个节点。

2. 将 pre 指向 NULL，cur 指向单链表的头结点。

3. 遍历单链表，每遍历一个节点，就将该节点的 next 指针指向 pre，然后依次向后移动 pre、cur 和 next 指针，即：pre = cur，cur = next，next = next->next。

4. 遍历完单链表后，将原头结点的 next 指针置为 NULL，将逆置后的单链表的头结点设为原来的尾节点。

下面是具体的实现代码：

void reverseList(ListNode* &head) {
    if (head == NULL || head->next == NULL) {
        return;
    }
    ListNode *pre = NULL, *cur = head, *next = head->next;
    while (next != NULL) {
        cur->next = pre;
        pre = cur;
        cur = next;
        next = next->next;
    }
    cur->next = pre;
    head->next = NULL;
    head = cur;
}

需要注意的是，在函数中需要使用引用来修改头结点，否则逆置后的单链表无法返回给调用者。

相关问题

设计算法将单链表L就地逆置，即利用原表各结点的空间实现逆置。

可以使用三个指针来实现单链表的就地逆置，具体算法如下：

1. 初始化三个指针：pre指向NULL，cur指向L的头结点，next指向cur的下一个结点。
2. 遍历链表，依次将cur结点的next指向pre结点，然后将pre、cur、next分别后移。具体操作如下：

a. 将cur的next指向pre：cur->next = pre;

b. 将pre、cur、next依次向后移动：pre = cur; cur = next; next = next->next;

3. 遍历完链表后，将原链表的头结点指向逆置后的尾结点。具体操作如下：

a. 将L的头结点指向pre结点：L->next = pre;

最后返回L即可。

下面是C++代码实现：

void reverseList(ListNode* head) {
    ListNode* pre = NULL;
    ListNode* cur = head->next;
    ListNode* next = cur->next;
    while (next != NULL) {
        cur->next = pre;
        pre = cur;
        cur = next;
        next = next->next;
    }
    cur->next = pre;
    head->next = cur;
}

需要注意的是，这里的head是一个头结点，而不是实际存储数据的第一个结点。在遍历完链表后，head->next指向的就是逆置后的尾结点。

设计算法将带头结点的双循环链表L就地逆置，即利用原表各结点的空间实现逆置。

算法步骤如下：

1. 如果链表L为空或只有一个结点，则直接返回。
2. 定义三个指针prev、p和next，分别指向原链表中相邻的三个结点。
3. 将prev指针指向L的头结点，p指针指向头结点的下一个结点。
4. 进入循环，判断p是否指向头结点。如果是，则退出循环；否则执行以下步骤：
1. 将next指针指向p的下一个结点。
2. 将p的next指针指向prev。
3. 将prev指针指向p。
4. 将p指针指向next。
5. 将头结点的next指针指向prev，完成链表逆置。

具体实现代码如下：

void ReverseList(DLinkList L) {
    if (L == NULL || L->next == L) {
        return;
    }
    DLinkList prev = L, p = L->next, next;
    while (p != L) {
        next = p->next;
        p->next = prev;
        prev = p;
        p = next;
    }
    L->next = prev;
    prev->prior = L;
}