深入理解链表插入排序：O(1)空间复杂度与节点重连机制-java教程-PHP中文网

深入理解链表插入排序：O(1)空间复杂度与节点重连机制

花韻仙語

发布： 2025-10-31 12:57:01

原创

278人浏览过

深入理解链表插入排序：o(1)空间复杂度与节点重连机制

本文深入探讨了链表插入排序的严格定义与实现。通过分析一个常见但非标准的实现，我们阐明了真正的链表插入排序应通过节点重连而非创建新节点来实现O(1)额外空间复杂度的原地排序。文章强调了理解算法核心机制对于高效编程的重要性。

引言：插入排序的核心原理

插入排序是一种简单直观的排序算法，其基本思想是将一个待排序的元素插入到已排序序列的正确位置。它迭代地从输入数据中“移除”一个元素，找到其在已排序列表中的位置，然后将其“插入”到该位置。这个过程重复进行，直到所有输入元素都被处理完毕。对于数组而言，这通常涉及元素的移动；而对于链表，其实现方式则有其独特之处。

链表插入排序的特性与挑战

在链表结构中实现插入排序，其关键在于如何处理节点的“移除”和“插入”操作。严格意义上的链表插入排序应当在O(1)的额外空间复杂度下完成，这意味着算法不应创建新的节点，而是通过修改现有节点的指针（即“重连”操作）来改变它们的顺序。如果实现中创建了新的链表或复制了节点数据，那么它虽然可能达到排序目的，但已偏离了传统意义上链表插入排序所追求的空间效率。

代码分析：一种基于新列表的排序实现

以下代码展示了一种将原始链表元素逐个插入到一个新创建的已排序链表中的方法：

public static List sort(List list) {        
    List sortedList = new List();                  // sortedList
    List.Iter curIndex = List.Iter.last(sortedList);  // terminated forward iterator        

    for(List.Iter iter = List.Iter.first(list); !iter.end(); iter.next()) {
        curIndex = List.Iter.last(sortedList);
        List.Node node = iter.key_data();  
        System.out.println("node: "+node.data);
        System.out.println("curIndex: "+curIndex.key_data().data);
        if (sortedList.empty()) {                
            sortedList.insAfter(curIndex, node.key, node.data);                
        }
        else if (curIndex.key_data().key >= node.key) {
            boolean hasPrev = true;
            while (hasPrev && curIndex.key_data().key >= node.key) {
                hasPrev = curIndex.prev();                    
            }                                
            sortedList.insAfter(curIndex, node.key, node.data);                        
        }
        else {                            
            boolean hasNext = true;
            while (hasNext && curIndex.key_data().key < node.key) {
                hasNext = curIndex.next();
            }
            sortedList.insAfter(curIndex, node.key, node.data);                
        }

    }
    return sortedList;
}

登录后复制

代码解析：

该实现通过以下步骤完成排序：

初始化一个空的 sortedList。
遍历原始 list 中的每一个节点。
对于每个从原始 list 中取出的节点，在 sortedList 中找到其合适的插入位置。
使用 sortedList.insAfter() 方法将该节点的键和数据插入到 sortedList 中。

优点：

功能上实现了将一个无序列表转换为一个有序列表。
逻辑相对直观，易于理解。

局限性：

降重鸟

要想效果好，就用降重鸟。AI改写智能降低AIGC率和重复率。

113

查看详情

非原地排序： 该方法并没有修改原始链表 list 的顺序，而是创建了一个全新的 sortedList。
空间复杂度： 由于创建了一个新的链表并插入了所有节点（或其数据副本），其额外空间复杂度为 O(n)，其中 n 是列表的元素数量。这与严格意义上链表插入排序所追求的 O(1) 额外空间不符。
不符合严格定义： 严格的插入排序要求“移除”输入元素并“插入”到已排序部分。此代码并未从原始列表中“移除”节点，而是从原始节点中提取数据并在新列表中创建了新的数据项或节点。

“真正”的链表插入排序：节点重连机制

一个符合严格定义的链表插入排序，尤其是对于双向链表，应该通过“重连”现有节点来实现，从而达到 O(1) 的额外空间复杂度。其核心思想是：

维护已排序部分： 假设链表头部或某个特定点开始的子链表是已排序的。最初，这个已排序部分可能只包含链表的第一个节点（或为空）。
逐个“取出”节点： 从未排序的剩余部分中取出一个节点。这里的“取出”意味着要修改其前后节点的指针，使其暂时脱离原链表。
寻找插入位置： 在已排序的子链表中从头开始（或从尾部开始，取决于具体策略）遍历，找到该节点应插入的正确位置。
“插入”并重连： 将取出的节点插入到找到的位置，这涉及到修改四个指针：
- 被插入节点的前驱节点的 next 指针。
- 被插入节点的后继节点的 prev 指针。
- 被插入节点自身的 prev 和 next 指针。

概念性步骤示例（单向链表简化）：

假设我们有一个头节点 head，并且 sortedHead 指向已排序部分的头。

// 假设 head 是原始链表的头，sortedHead 是已排序链表的头
// 初始时，sortedHead = head; head = head.next; sortedHead.next = null; (将第一个元素作为已排序部分)

while (head != null) {
    ListNode current = head;
    head = head.next; // 从原链表中取出 current 节点

    // 在 sortedHead 中找到 current 的插入位置
    // 如果 current 比 sortedHead 小，则插入到 sortedHead 之前
    if (current.val < sortedHead.val) {
        current.next = sortedHead;
        sortedHead = current;
    } else {
        // 遍历 sortedHead 找到插入点
        ListNode search = sortedHead;
        while (search.next != null && current.val >= search.next.val) {
            search = search.next;
        }
        // 插入 current
        current.next = search.next;
        search.next = current;
    }
}
// 最终 sortedHead 就是完全排序的链表

登录后复制

对于双向链表，操作会更复杂，需要额外处理 prev 指针的修改。关键在于，整个过程不涉及 new ListNode()，所有操作都是对现有节点指针的修改。