编写算法逆置一个带头结点的双链表。

1. 如果链表为空或只有一个结点，则直接返回原链表。
2. 定义三个指针pre、p和q，分别指向当前结点的前一个结点、当前结点和当前结点的后一个结点。
3. 将当前结点的前一个结点指向当前结点的后一个结点，将当前结点的后一个结点指向当前结点。
4. 将pre指向当前结点，将当前结点指向q。
5. 重复上述过程，直到q指向空。
6. 将头结点的next指向pre，即完成逆置。

算法实现如下：

def reverse_list(head):
    if not head or not head.next:
        return head
    pre = None
    p = head.next
    while p:
        q = p.next
        p.next = pre
        p.prev = q
        pre = p
        p = q
    head.next = pre
    pre.prev = head
    return head

相关问题

编写算法逆置一个带头结点的双链表

算法如下：

1. 定义三个指针p、q、r，分别指向当前节点、前一个节点和后一个节点。
2. 初始化p指向头结点的下一个节点，q指向头结点，r指向p的下一个节点。
3. 将头结点的next指针置为NULL。
4. 依次遍历链表中的每个节点，将p的next指针指向q，将p的prev指针指向r。
5. 将q指针指向p，将p指针指向r，将r指针指向r的下一个节点。
6. 当r指针指向NULL时，遍历结束，将头结点的next指针指向q。

代码如下：

void reverseList(Node *head)
{
    Node *p = head->next;
    Node *q = head;
    Node *r = p->next;
    head->next = NULL;
    while (r != NULL)
    {
        p->next = q;
        p->prev = r;
        q = p;
        p = r;
        r = r->next;
    }
    p->next = q;
    p->prev = NULL;
    head->next = p;
}

编写算法逆置一个带头结点的双链表代码c++

以下是逆置一个带头结点的双链表的C++代码：

#include <iostream>

using namespace std;

struct ListNode {
    int val;
    ListNode* next;
    ListNode* prev;
    ListNode(int x) : val(x), next(NULL), prev(NULL) {}
};

ListNode* reverseList(ListNode* head) {
    if (head == NULL || head->next == NULL) {
        return head;
    }
    
    ListNode* curr = head->next;
    ListNode* prev = NULL;
    
    while (curr != NULL) {
        ListNode* next = curr->next;
        curr->next = prev;
        curr->prev = next;
        prev = curr;
        curr = next;
    }
    
    head->next = prev;
    head->next->prev = NULL;
    
    return head;
}

int main() {
    ListNode* head = new ListNode(-1);
    ListNode* tail = head;
    for (int i = 1; i <= 5; i++) {
        ListNode* node = new ListNode(i);
        tail->next = node;
        node->prev = tail;
        tail = node;
    }
    
    cout << "Original list: ";
    ListNode* curr = head->next;
    while (curr != NULL) {
        cout << curr->val << " ";
        curr = curr->next;
    }
    cout << endl;
    
    head = reverseList(head);
    
    cout << "Reversed list: ";
    curr = head->next;
    while (curr != NULL) {
        cout << curr->val << " ";
        curr = curr->next;
    }
    cout << endl;
    
    return 0;
}

这里使用了双指针法，通过一个 `prev` 指针和一个 `curr` 指针来逆置链表。同时需要注意一些细节，比如链表头结点的处理和指针的赋值顺序等。