双向链表冒泡排序算法从小到大，简洁明了

双向链表上的冒泡排序算法通常会稍微复杂一些，因为链表操作涉及到节点的前后指针而非数组的直接元素交换。以下是简化的冒泡排序算法步骤：

1. 定义两个指针，`current` 和 `previous`，分别指向链表的头节点和空节点。
2. 进入一个循环，该循环将持续到列表长度小于2，这是冒泡排序结束的标志，因为最短的序列在一次遍历中即可确定顺序。
3. 在循环内部，对当前节点（`current`）开始，执行以下操作：
a. 遍历相邻节点，比较它们的值。如果前一个节点（`previous->value`）大于后一个节点（`current->value`），则交换它们的位置，同时更新指针：将`previous`移动到当前节点，然后`current`移动到下一个节点。
b. 如果相邻节点的值已经是有序的，不需要交换，直接前进到下一对相邻节点。
4. 当`current`到达链表尾部时，跳出内层循环，并将`previous`设置回`current`，因为外层循环需要继续处理剩下的部分。
5. 再次从链表头部开始，直到整个链表都被检查过一遍。

这个过程会重复，每次迭代都会把最大的元素“冒泡”到链表的末尾，直到整个链表变得有序。

相关问题

使用单向链表实现冒泡排序，从小到大

单向链表不适合直接用于冒泡排序，因为冒泡排序依赖于元素之间的相对位置交换，而在链表中节点的顺序通常是通过指针连接而非相邻存储。然而，如果你坚持要用链表形式实现类似冒泡的效果，可以模拟链表的遍历过程，将元素视为链表中的数据，比较它们的大小来进行“交换”位置。

首先，创建一个链表节点类`ListNode`，包含一个数值属性`value`和一个指向下一个节点的引用`next`。然后，定义一个辅助函数`bubbleSortList`来实现冒泡排序的过程：

class ListNode:
    def __init__(self, value=0):
        self.value = value
        self.next = None

def bubbleSortList(head):
    if head is None or head.next is None:
        return head
    
    current = head
    swapped = True  # 标志是否有元素交换
    while swapped:
        swapped = False
        prev = current
        while current.next is not None:
            if current.value > current.next.value:
                # 将当前节点与下一个节点的值交换
                temp = current.value
                current.value = current.next.value
                current.next.value = temp
                
                swapped = True  # 标记有交换
            prev = current
            current = current.next

    return head

这段代码会遍历链表，如果遇到相邻的节点值逆序，就交换它们的位置。直到链表不再发生交换为止，说明已经排好序。

双向链表双向冒泡排序

双向链表的双向冒泡排序可以通过比较相邻节点的数据域来实现。具体步骤如下：

1. 首先，定义一个指向链表头节点的指针，命名为`current`。
2. 使用两个循环嵌套，外层循环控制比较的轮数，内层循环控制每一轮的比较次数。
3. 在内层循环中，比较`current`节点和`current.next`节点的数据域，如果前者大于后者，则交换它们的数据域。
4. 内层循环结束后，将`current`指针指向下一个节点，继续进行下一轮的比较。
5. 外层循环结束后，整个链表的数据域将按照从小到大的顺序排列。

下面是一个示例代码，演示了双向链表的双向冒泡排序：

class Node:
    def __init__(self, data):
        self.data = data
        self.prev = None
        self.next = None

def bubble_sort(head):
    if head is None or head.next is None:
        return head
    
    end = None
    while end != head.next:
        current = head.next
        while current.next != end:
            if current.data > current.next.data:
                current.data, current.next.data = current.next.data, current.data
            current = current.next
        end = current
    
    return head

# 创建双向链表
head = Node(4)
node1 = Node(2)
node2 = Node(1)
node3 = Node(3)

head.next = node1
node1.prev = head
node1.next = node2
node2.prev = node1
node2.next = node3
node3.prev = node2

# 执行双向冒泡排序
sorted_head = bubble_sort(head)

# 输出排序后的链表数据
current = sorted_head.next
while current is not None:
    print(current.data)
    current = current.next

输出结果为：

1
2
3
4