设计一个算法，从左往右输出一个双链表各个结点的值

设计一个简单的遍历算法来从左到右输出双链表中每个节点的值：

**算法步骤：**

1. **初始化指针**：
- 创建一个指向头节点的指针`current`，初始值为`head`，表示当前访问的节点。

2. **遍历过程**：
- 当`current`不为空时，执行以下操作：
a. **打印当前节点的值**：`print(current.value)` 或 `System.out.println(current.data)`, 这取决于你的数据结构定义。
b. **移动指针**：将`current`指向下一个节点，即`current = current.next`。如果`current`之前是一个双向链表，还需要检查它是否有前驱节点，如果没有则直接`current = current.next`；如果有，`current = current.next.next`。

3. **结束条件**：
- 当`current`变为`null`时，说明已经遍历到了链表的末尾，此时停止循环。

下面是一个伪代码形式的算法描述：

def print_doubly_linked_list(head):
    if head is not None:
        while current is not None:
            print(current.value)
            current = current.next

相关问题

设计一个算法，从右往左打印一个双链表中各个结点的值

可以使用双指针，先将指针移动到链表的尾部，然后从尾部开始遍历链表，依次输出每个结点的值。具体实现可以参考以下代码：

void printListReverse(ListNode* head) {
if (head == nullptr) {
return;
}
ListNode* tail = head;
while (tail->next != nullptr) {
tail = tail->next;
}
while (tail != nullptr) {
cout << tail->val << " ";
tail = tail->prev;
}
}

有n个记录存储在带头结点的双向链表中，现用双向冒泡排序法对其按升序进行排序，请写出这种排序算法。

双向冒泡排序算法的基本思路是，从左向右冒泡，将最大的元素冒泡到最右边；然后从右向左冒泡，将最小的元素冒泡到最左边。重复这个过程，直到所有元素都排好序。

对于双向链表，我们需要注意的是，链表的节点不仅有值，还有指向前一个节点和后一个节点的指针。因此，在交换两个节点的值时，还需要同时交换它们的前驱和后继节点的指针。

具体实现如下：

def double_bubble_sort(head):
    if not head or not head.next:
        return head

    tail = None  # tail 表示尾节点，初始时为空
    while tail != head.next:  # 当尾节点到达头结点的后面一个节点时，排序结束
        # 从前往后冒泡，将最大的元素冒泡到链表尾部
        p = head.next
        while p.next != tail:
            if p.val > p.next.val:
                # 交换相邻两个节点的值
                p.val, p.next.val = p.next.val, p.val
                # 交换相邻两个节点的前驱和后继节点的指针
                p.prev.next, p.next.prev, p.prev, p.next = p.next, p, p.prev, p.next.next
            else:
                p = p.next
        
        # 更新尾节点
        tail = p
        
        # 从后往前冒泡，将最小的元素冒泡到链表头部
        p = tail.prev
        while p != head:
            if p.val > p.next.val:
                # 交换相邻两个节点的值
                p.val, p.next.val = p.next.val, p.val
                # 交换相邻两个节点的前驱和后继节点的指针
                p.prev.next, p.next.prev, p.prev, p.next = p.next, p, p.prev, p.next.next
            else:
                p = p.prev

    return head

时间复杂度为O(n^2)，其中n为链表的长度。