剑指offer-合并两个排序的链表

题目描述

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

public class Test {
    
    class ListNode {
        int value;
        ListNode next;
        public ListNode(int value) {
            this.value = value;
        }
    }
    /**
     * node1: 1->3->5->7;
     * node2: 2->4->6->8->9->10->11;
     * @param args
     */
    public static void main(String[] args) {
        Test t = new Test();
        ListNode node1 = t.new ListNode(1);
        ListNode node2 = t.new ListNode(2);
        ListNode node3 = t.new ListNode(3);
        ListNode node4 = t.new ListNode(4);
        ListNode node5 = t.new ListNode(5);
        ListNode node6 = t.new ListNode(6);
        ListNode node7 = t.new ListNode(7);
        ListNode node8 = t.new ListNode(8);
        ListNode node9 = t.new ListNode(9);
        ListNode node10 = t.new ListNode(10);
        ListNode node11= t.new ListNode(11);
        node1.next = node3;
        node2.next = node4;
        node3.next = node5;
        node4.next = node6;
        node5.next = node7;
        node6.next = node8;
        node7.next = null;
        node8.next = node9;
        node9.next = node10;
        node10.next = node11;
        node11.next = null;
    
        
        ListNode mergeNode = t.merge1(node1,node2);
        while(mergeNode != null) {
            System.out.println(mergeNode.value);  // 打印合并链表
            mergeNode = mergeNode.next;
        }
    }    
    /**
     * 递归方法：调用自身进行比较合并，消耗内存。
     * @param head1
     * @param head2
     * @return
     */
    public ListNode merge(ListNode head1, ListNode head2) {
        // head1为空，返回head2
        if(head1 == null) return head2;
        // head2为空，返回head1
        if(head2 == null) return head1;
        // 记录合并链表
        ListNode node = null;
        if(head1.value > head2.value) {
            node = head2;
            node.next = merge(head1, head2.next);
        } else {
            node = head1;
            node.next = merge(head1.next, head2);
        }
        return node;
    }
    
    /**
     * 非递归方法：消耗内存少。
     * @param head1
     * @param head2
     * @return
     */
    public ListNode merge1(ListNode head1, ListNode head2) {
        // head1为空，返回head2
        if(head1 == null) return head2;
        // head2为空，返回head1
        if(head2 == null) return head1;
        // 记录合并链表
        ListNode tempNode = new ListNode(-1);   
        // 指向合并链表的尾结点
        ListNode node = tempNode;
        
        // 两链表都不为空进行比较合并 
        while(head1 !=null && head2 !=null) {
            if(head1.value < head2.value) {   
                node.next = head1;
                head1 = head1.next;
            } else {
                node.next = head2;
                head2 = head2.next;
            }
            node = node.next; // 将指针移动到合并后链表的结尾，方便下次
        }
        // 如果第一个链表的元素未处理完，将其接到合并链表的最后一个结点之后
        if(head1 != null) {
            node.next = head1;
        }
        
        // 如果第二个链表的元素未处理完，将其接到合并链表的最后一个结点之后
        if(head2 != null) {
            node.next = head2;
        }
        return tempNode.next;  
    }
}