合并两个有序链表

合并两个有序链表

---

21. 合并两个有序链表

难度简单

将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

示例 1：

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]

示例 2：

输入：l1 = [], l2 = []
输出：[]

示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

提示：

• 两个链表的节点数目范围是 [0, 50]
• -100 <= Node.val <= 100
• l1 和 l2 均按 非递减顺序 排列

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-two-sorted-lists/
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

---

思路解析:

1. 判断l1是否为空，空的话返回l2
2. 判断l2是否为空，空的话返回l1
3. 此时需要判断l1的第一个结点大于l2第一个结点还是l2第一个结点大于l1的第一个结点来划分主链（结点小的作为主链表返回）
   1. 1　　当l1的第一个结点大于l2的第一个结点的时候
      1. 1.1   定义一个指向当前结点的指针指向l2的当前遍历结点
      2. 1.2   定义一个指向头节点的指针指向l2的头结点
      3. 1.3   遍历l1的结点、将结点依次按照有序插入到l2链表中

　　　　　　2.1      当l1的第一个节点小于l2的第一个节点的时候与上面同理

public class test4 {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        ListNode l1 = new ListNode();
        l1.val = 1;
//        l1.next = new ListNode(2);
//        l1.next.next = new ListNode(4);
        ListNode l2 = new ListNode();
        l2.val = 2;
//        l2.next = new ListNode(3);
//        l2.next.next = new ListNode(4);
        System.out.println(new test4().mergeTwoLists(l1, l2));
        System.out.println("111");
    }
    ListNode head;
    
//    public void
    
    
    public   ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if(l1==null) {
            return l2;
        }
        if(l2==null) {
            return l1;
        }
        //将l1合并到l2中
        //

        //遍历l1
        if(l1.val>=l2.val) {
            //定义一个指针指向l2
            ListNode cur = l2; 
            //定义头节点
            ListNode head = l2;
            while(l1!=null) {           
                while(l2!=null) {
                    //判断l1与当前节点的大小
                    if(cur.next!=null) {

//此处判断的时候需要判断l1当前节点是否大于当前遍历l2结点的基础上还需要判断下一个结点是否大于当前结点，否则当前结点后移

　　　　　　if(l1.val>=cur.val&&l1.val<cur.next.val)
　　　　　　　　 { 
　　　　　　　　　　ListNode newNode = new ListNode(l1.val); 
　　　　　　　　　　newNode.next = cur.next; cur.next = newNode; 
　　　　　　　　　　//如果当前节点小于l1结点的时候理应把指针后移 
　　　　　　　　　　l2 = l2.next; 
　　　　　　　　　　//上一个节点 
　　　　　　　　　　cur = l2; 
　　　　　　　　　　break; 
　　　　　　　　　　}
　　 }else if(l1.val>=cur.val) { 
　　　　　　ListNode newNode = new ListNode(l1.val);
　　　　　　 newNode.next = cur.next; 
　　　　　　cur.next = newNode; 
　　　　　　l2 = l2.next;
　　　　　　 //上一个节点 cur = l2; break; }
 　　　　　　l2 = l2.next; cur = cur.next; }
 　　　　　　l1 = l1.next; } 
　　　　　　return head; }
　　else { //定义一个指针指向l2 ListNode cur = l1; 
　　　　　　//定义头节点 ListNode head = l1;
　　　　　　 while(l2!=null) { 
　　　　　　while(l1!=null) { 
　　　　　　//判断l1与当前节点的大小 
　　　　　　if(cur.next!=null) {
　　　　　　　　　　 if(l2.val>=cur.val&&l2.val<cur.next.val) {
                            ListNode newNode = new ListNode(l2.val);
                            newNode.next = cur.next;
                            cur.next = newNode;
                            //如果当前节点小于l1结点的时候理应把指针后移
                            l1 = l1.next;
                            //上一个节点
                            cur = l1;
                            break;
                        }
                    }else if(l2.val>=cur.val) {
                        ListNode newNode = new ListNode(l2.val);
                        newNode.next = cur.next;
                        cur.next = newNode;
                        l1 = l1.next;
                        //上一个节点
                        cur = l1;
                        break;
                    }        
                    l1 = l1.next;
                    cur = cur.next;
                }          
                l2 = l2.next;
            }
            
            return head;
        }


    }

}
class ListNode {
     int val;
     ListNode next;
     ListNode() {}
     ListNode(int val) { this.val = val; }
     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
    @Override
    public String toString() {
        return "ListNode [val=" + val + ", next=" + next + "]";
    }
     
 }

---

测试结果: