2个单项链表额合并，根据id大小进行合并

package com.DataStructure.linkedlist;

/**
 * 仰望星空，俯视大地
 **/
public class Redo {
    public static void main(String[] args) {
        Node node1 = new Node(1);
        Node node2 = new Node(2);
        Node node3 = new Node(3);
        Node node4 = new Node(4);
        Node node5 = new Node(5);
        Node node6 = new Node(6);
        Node node7 = new Node(7);
        Node node8 = new Node(8);
        node1.next=node3;
        node3.next=node5;
        node5.next=node7;

        node2.next=node4;
        node4.next=node6;
        node6.next=node8;

        Node cNode1 = combineTwoList1(node1, node2);
        while (cNode1!=null){
            System.out.println(cNode1.id);
            cNode1=cNode1.next;
        }

        Node cNode2=combineTwoList2(node1,node2);
        while (cNode2!=null){
            System.out.println(cNode2.id);
            cNode2=cNode2.next;
        }
    }

    //采用递归的方式
    public static Node combineTwoList1(Node n1, Node n2) {
        //首先判断链表节点是否为空，如果链表以类的方式存在，则传入head.next即可
        if (n1 == null && n2 == null) {
            System.out.println("两个链表都为空");
            return null;
        }
        if (n1 == null || n2 == null) {
            return n1 == null ? n2 : n1;
        }
        Node head = null;
        if (n1.id < n2.id) {
            head = n1;
            //将n2节点与n1.next节点进行比较
            head.next = combineTwoList1(n1.next, n2);
        } else {
            head = n2;
            head.next = combineTwoList1(n1, n2.next);
        }
        //返回头节点，通过头节点或者链表
        return head;
    }

    //采用非递归的方式
    public static Node combineTwoList2(Node n1, Node n2) {
//首先判断链表节点是否为空，如果链表以类的方式存在，则传入head.next即可
        if (n1 == null && n2 == null) {
            System.out.println("两个链表都为空");
            return null;
        }
        if (n1 == null || n2 == null) {
            return n1 == null ? n2 : n1;
        }
        Node head = null;
        //防止头结点变化，创建临时变量
        Node cur1 = null;
        Node cur2 = null;
        Node pre = null;
        Node next = null;
        head = n1.id < n2.id ? n1 : n2;
        //等于将id小的节点赋值给cur1，大的给cur2
        cur1 = head == n1 ? n1 : n2;
        cur2 = head == n1 ? n2 : n1;

        while (cur1 != null && cur2 != null) {
            if (cur1.id <= cur2.id) {
                pre=cur1;
                cur1=cur1.next;
            }
            else{
                next = cur2.next;
                pre.next = cur2;
                cur2.next = cur1;
                pre = cur2;
                cur2 = next;
            }
        }
        pre.next = cur1 == null ? cur2 : cur1;
        return head;
    }
}

class Node {
    public int id;
    public Node next;

    public Node(int id) {
        this.id = id;
    }
}