两个有序链表的合并（JAVA）

单链表主类

参考单链表反转中的主类代码

有序链表合并思路

原链表m和n都是有序的，比如都是正序排列（从小到大）
两个链表同时从头开始向后移动
移动前先比较节点大小，更小的存入新链表的链尾（此为中间步骤）

直到有一个链表移动结束，再将另一个链表的剩余部分追加到新链表的链尾。

代码

public SinglyLinkedList<T> mergeSorted(SinglyLinkedList<T> sortedList) {
	// 空链情况处理
    if (this.getHeader() == null) {
        return sortedList;
    }
    if (sortedList == null || sortedList.getHeader() == null) {
        return this;
    }
    SinglyLinkedList<T> mergeResult = new SinglyLinkedList<T>();
    SinglyLinkedNode<T> m = this.getHeader();
    SinglyLinkedNode<T> n = sortedList.getHeader();
    // 先处理头
    int compare = m.compareTo(n);
    if (compare < 0) {
        // m比n小
        mergeResult.setHeader(m);
        m = m.getNext();
    } else {
        // n比m小，或n=m
        mergeResult.setHeader(n);
        n = n.getNext();
    }
    mergeResult.size++;

    SinglyLinkedNode<T> current = mergeResult.getHeader();
    while (m != null && n != null) {
        compare = m.compareTo(n);
        if (compare < 0) {
            // m比n小
            current.setNext(m);
            m = m.getNext();
        } else {
            // n比m小，或n=m
            current.setNext(n);
            n = n.getNext();
        }
        current = current.getNext();
        mergeResult.size++;
    }

    // m、n 有且只有一个为null
    if (m == null) {
        current.setNext(n);
        while (n != null) {
            n = n.getNext();
            mergeResult.size++;
        }
    } else {
        current.setNext(m);
        while (m != null) {
            m = m.getNext();
            mergeResult.size++;
        }
    }

    return mergeResult;
}

最初按这个思路写代码的时候，是将头的处理放在了while循环体里，compare比较的两个分支中需要单独判断current是否为空，然后将新链表的头装上，看着有些恶心，就又改了

@Deprecated
public SinglyLinkedList<T> mergeSortedOld(SinglyLinkedList<T> sortedList) {
    // 空链情况处理
    if (this.getHeader() == null) {
        return sortedList;
    }
    if (sortedList == null || sortedList.getHeader() == null) {
        return this;
    }
    SinglyLinkedList<T> mergeResult = new SinglyLinkedList<T>();
    SinglyLinkedNode<T> m = this.getHeader();
    SinglyLinkedNode<T> n = sortedList.getHeader();

    SinglyLinkedNode<T> current = null;
    while (m != null && n != null) {
        int compare = m.compareTo(n);
        if (compare < 0) {
            // m比n小
            if (current == null) {
                mergeResult.setHeader(m);
                current = m;
            } else {
                current.setNext(m);
                current = current.getNext();
            }
            m = m.getNext();
        } else {
            // n比m小，或n=m
            if (current == null) {
                mergeResult.setHeader(n);
                current = n;
            } else {
                current.setNext(n);
                current = current.getNext();
            }
            n = n.getNext();
        }
        mergeResult.size++;
    }

    // m、n 有且只有一个为null
    if (m == null) {
        current.setNext(n);
        while (n != null) {
            n = n.getNext();
            mergeResult.size++;
        }
    } else {
        current.setNext(m);
        while (m != null) {
            m = m.getNext();
            mergeResult.size++;
        }
    }

    return mergeResult;
}

时间复杂度分析

和两条链表的长度m，n有关
极端情况下

1 -> 2 -> 3 -> 4
1 -> 1 -> 2 -> 2 -> 3 -> 4

最大时间复杂度O(m+n)
理想情况下

1 -> 2
3 -> 4 -> 5 -> 6

最小时间复杂度O(min(m,n))

更早的一个思路

以有序单链表m为基准，从头开始，依次与链表n的节点做比较
如果m的节点小，则把n的节点放到m节点之后（处理n节点前，暂存n的剩余部分），m链表向后移动两位
如果m的节点大，则把n的节点放到m节点之前（处理n节点前，暂存n的剩余部分），m链表向后移动一位
相等情况可放在上述两条分支上的任意一条
写的过程中，出现了一个很麻烦的事情，就是在第二种情形下，需要获取m的当前节点的上一个节点，才能把n的节点顺利放到m节点之前。而对于单链表而言，向后找时间复杂度O(1)，但向前找时间复杂度O(n)。
除非是双向链表，不然这个不是好的处理方式

更更早的一个思路

时间复杂度是O(m*n)（存疑…）
写一个有序链表的插入逻辑，新插入的节点会在链表中的恰当位置
然后把另一个链表所有节点从头到尾执行一遍插入
这个时间复杂度会挺高的