链表的练习

回文链表

给定一个链表的 头节点 head ，请判断其是否为回文链表。
如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。

示例 1：
输入: head = [1,2,3,3,2,1]
输出: true

示例 2：
输入: head = [1,2]
输出: fasle

提示：
链表 L 的长度范围为 [1, 105]
0 <= node.val <= 9

进阶：能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/aMhZSa

这时候我们只需要将链表分成两个子链表left\right，然后将右子链表进行倒序，此时只要链表是一个回文串，那么左子链表的前n个节点的值必然和右子节点的值相同，其中n是右子节点的节点数目，之所以说是左子链表的前n个节点，是因为考虑到链表节点数目的奇偶性，如果是奇数，那么左子链表比右子链表的节点多一个节点，如果是偶数，则两者节点数目相同。
所以本题就转成了 获取链表的中点 + 获取链表的逆序 。
对应代码：

class Solution {
    /*
    方法一：开辟空间存放节点的值，然后分别从两侧进行比较判断两者的值是否相等，如果不相等，
    说明不是回文链表，否则已知遍历，当遍历完毕之后，直接返回true   ----空间复杂度O(n)
    方法二：将这条链表分成两条子链表，然后对右子链表进行逆序操作，这时同时遍历两条链表，
    每获得一个节点，就比较两个节点的值是否相同，如果不同，说明不是回文链表，否则，当
    两条子链表中有一条遍历完毕后，说明原来链表时回文链表，返回true  ---空间复杂度O(1)
    */
    public boolean isPalindrome(ListNode head) {
         ListNode slow = head,fast = head;
         //利用快慢指针获取链表的中点slow，同时也是左子链表最后一个节点
         while(fast != null && fast.next != null && fast.next.next != null){
             slow = slow.next;
             fast = fast.next.next;
         }
         ListNode right = reverseList(slow.next);//获取右子链表反转后的链表的头结点
         slow.next = null;
         //判断两个链表的节点的值是否相同
         ListNode cur1 = head,cur2 = right;
         while(cur1 != null && cur2 != null){
             //当两个子链表中有一个为空，说明是回文链表
             if(cur1.val != cur2.val)
               return false;
             cur1 = cur1.next;
             cur2 = cur2.next;
         }
         return true;
    }
    //通过递归实现链表的逆序
    public ListNode reverseList(ListNode head){
        if(head == null || head.next == null)
           return head;
        ListNode newHead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}

运行结果：

重排链表

给定一个单链表 L 的头节点 head ，单链表 L 表示为：

L0 → L1 → … → Ln-1 → Ln
请将其重新排列后变为：

L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …

不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/LGjMqU
方法一：利用线性表
一开始我是用到了双端队列，因为需要从首尾各取一个节点嘛，然后发现即使是普通的列表也可以，因为可以根据它的下标来获取。然而这时候需要格外注意链表数目的奇偶性，否则一不小心，就可能导致重排链表是一个环形链表了。此时空间复杂度为O(n)。

方法二： 链表中点 + 链表逆序 + 链表合并
我们观察一下题目要求，再来看一下实例，我们将发现了这个题目是和上面一道题几乎是一样的。
重排链表的最后结果就是原来链表的左子链表 与 倒序后的右子链表 进行合并的结果。
所以，这个题目相当于 获取链表的中点 + 链表的逆序 + 合并链表 三种类型的题目合成一道题。
因此只要逐步拆解即可。

而要获取链表的中点，可以利用快慢指针来获得，slow每次走1不，fast指针每次走2步，所以fast指针走过的路程将会比slow指针走过的路程多一半，因此只要fast已经遍历完了链表，那么slow刚好走了链表的一半，刚好对应的是链表的中点。

对应代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    /*
    利用双端队列，当然也可以利用一个普通的列表来实现

    public void reorderList(ListNode head) {
        Deque<ListNode> queue = new LinkedList<ListNode>();//定义一个双端队列
        ListNode cur = head,left,right;
        while(cur != null){
            queue.offer(cur);
            cur = cur.next;
        }
        while(!queue.isEmpty()){
            left = queue.pollFirst();
            if(queue.isEmpty()){
                //在跳出左边节点之后，链表为空，说明链表一共有偶数个，此时跳出的left是
                //重排链表之后的最后一个节点，所以需要将left.next置为null，否则就会形成环形链表
               left.next = null;
               break; 
            }
            right = queue.pollLast();
            if(queue.isEmpty())
            //跳出右边节点队列才变成空，说明链表有偶数个节点，此时是最后一个节点，同样需要将right.next变成null，否则就会变成环形链表
               right.next = null;
            else
               right.next = left.next;
            left.next = right;
        }
    }
    */
    /*
    public void reorderList(ListNode head) {
        List<ListNode> list = new ArrayList<ListNode>();
        ListNode cur = head;
        while(cur != null){
            list.add(cur);
            cur = cur.next;
        }
        int i,size;
        for(i = 0,size = list.size() - 1; i < size; ++i,--size){
            if(size == i + 1)//如果刚好size等于i + 1,说明链表中有偶数个节点，那么size对应的节点就是重排链表后的最后一个节点
               list.get(size).next = null;
            else
               list.get(size).next = list.get(i).next;
            list.get(i).next = list.get(size);
        }
        if(i == size){
            //如果i等于size，那么说明链表中有奇数个，并且此时的i刚好是重排链表的最后一个节点
            list.get(i).next = null;
        }
    }
    */
    /*
    上面的方法都是空间复杂度为O(n)，但是我们可以进一步优化，从而使得空间复杂度为O(1)
    此时我们仔细观察题目，我们可以发现，重排后的链表可以看成是原来链表左边一半 和
    右边一半进行反转后的链表 进行合并得到的。

    所以本题就变成了 寻找链表的中点 + 反转链表 + 合并链表

    获取链表的中点，从而将整条链表分成两条,但是我们怎么知道哪个节点是链表的中点呢？
    我们可以获取链表中的节点个数，然后再次遍历即可，当然利用快慢指针实现是最好的。
    慢指针每次只走1步，而快指针每次走2步，所以在快指针已经走完了链表的时候，这时候
    慢指针刚好对应的节点就是中点所在，也是左边链表的最后一个节点。

    反转链表：可以通过递归、双指针等

    合并链表：只要两个链表都没有空，就进行合并（左子链表就比右子链表最多多一个节点，而左子节点多出
    来的那个节点的next需要变成null，否则不做操作的话，就会出现环形链表）
    */
    public void reorderList(ListNode head) {
       ListNode slow = head,fast = head;
       while(fast != null && fast.next != null && fast.next.next != null){
           //通过这样的条件判断，不管链表有奇数还是偶数个节点，slow对应的都是左子链表的最后一个节点
           slow = slow.next;
           fast = fast.next.next;
       }
       ListNode right = reverseList(slow.next);//对右子链表进行反转
       /*
       slow.next = null;听巧妙的，这一步可以在下面进行合并的时候不需要考虑原来链表节点数的奇偶性的
       处理情况
       [1,2,3,4,5] ---> 
       1 -> 2 -> 3 ->null
       5 -> 4 --> null

       所以重排时1 -> 5 -> 2 -> 4 -> 3 -> null

       [1,2,3,4,5,6]
       1 -> 2 -> 3 -> null
       6 -> 5 -> 4 -> null
       所以重排后1 -> 6 -> 2 -> 5 -> 3 -> 4 -> null
       */
       slow.next = null;
       //合并两个子链表
       ListNode cur1 = head,cur2 = right,tmp1,tmp2;
       while(cur1 != null && cur2 != null){
           tmp1 = cur1.next;
           tmp2 = cur2.next;
           cur2.next = cur1.next;
           cur1.next = cur2;
           cur1 = tmp1;
           cur2 = tmp2;
       }
     
      
    }
    //递归实现链表的逆序
    public ListNode reverseList(ListNode head){
        if(head == null || head.next == null)
           return head;
        ListNode newHead = reverseList(head.next);
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}

运行结果：

排序的循环链表

给定循环升序列表中的一个点，写一个函数向这个列表中插入一个新元素 insertVal ，使这个列表仍然是循环升序的。

给定的可以是这个列表中任意一个顶点的指针，并不一定是这个列表中最小元素的指针。

如果有多个满足条件的插入位置，可以选择任意一个位置插入新的值，插入后整个列表仍然保持有序。

如果列表为空（给定的节点是 null），需要创建一个循环有序列表并返回这个节点。否则。请返回原先给定的节点。

示例 2：
输入：head = [], insertVal = 1
输出：[1]
解释：列表为空（给定的节点是 null），创建一个循环有序列表并返回这个节点。

示例 3：
输入：head = [1], insertVal = 0
输出：[1,0]

提示：
0 <= Number of Nodes <= 5 * 10^4
-10^6 <= Node.val <= 10^6
-10^6 <= insertVal <= 10^6

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/4ueAj6

看到这个题目的时候，可能会和我一开始想的那样，插入insertVal依旧是有序的，那么我只要将这个新节点insertVal插入到当前节点的值cur.val 小于等于insertVal，并且cur.next.val 大于等于insertVal的cur节点后面不就好了。这真是太简单了吧。

class Solution {
    public Node insert(Node head, int insertVal) {
        Node node = new Node(insertVal,null);
        if(head == null){
           //链表为空
            head = node;
            head.next = head;
        }else if(head.next == head){
            //链表只有一个节点时
            node.next = head.next;
            head.next = node;
        }else{
            Node cur = head;
            while(true){
                if(cur.val <= insertVal && insertVal <= cur.next.val){
                    /*
                    当insertVal大于等于当前结点的值，小于等于下一个节点的值时，我们将insertVal对
                    应的节点node插入到cur的后面即可插入节点之后依旧有序
                    */
                    node.next = cur.next;
                    cur.next = node;
                    break;
                }
                cur = cur.next;
            }

        }
        return head;
    }
}

运行结果:

按照上面的代码显然没有办法满足于这一种情况，所以本题需要我们考虑两种情况：

• insertVal小于链表的最大节点对应的值maxNode.val,并且大于链表最小节点对应的值,即insertVal不是链表的最值，这时候，我们将可以根据cur.val <= insertVal <= cur.next.val，从而找到insertVal应该插入的位置
• 否则，当insertVal大于链表最大节点对应的值maxNode.val或者小于链表最大节点对应的值，此时insertVal就是整个链表的最值，这时候我们只要将insertVal插入到最后一个最大节点MaxNode后面即可。之所以时插入在最后一个最大节点的后面，是因为最后一个maxNode后一个节点就是没有插入insertVal之前的最小节点，不管insertVal对应的节点时插入以后的最大节点还是最小节点，都是对应这个位置，所以需要将insertVal插入到最后一个最大节点的后面.

那么我们将如何判断insertVal是不是最值呢？很简单，只要遍历到的节点cur重新回到了head位置，说明insertVal就是最值，而我们在每次循环中根据maxNode.val <= cur.val来更新maxNode，从而找到了最后一个最大节点所在。当退出循环的时候，直接将insertVal插入到maxNode的后面即可.

对应代码：

class Solution {
    public Node insert(Node head, int insertVal) {
        Node node = new Node(insertVal,null);
        if(head == null){
            head = node;
            head.next = head;
        }else if(head.next == head){
            //链表只有一个节点时
            node.next = head.next;
            head.next = node;
        }else{
            /*
            如果链表不为空，并且不只一个节点，那么就需要遍历链表
            因为insertVal的值，所以需要分几种情况:
            如果insertVal的值不是链表中的最值，那么这时候可以有办法
            根据 cur.val <= insertVal <= cur.next.Val，从而使得
            将node这个节点插入在cur的后面
            否则，如果insertVal时链表的最值，这时候，只要将这个node插入到
            最后一个最大值后面即可
            */
            Node cur = head;
            Node maxNode = head;
            while(true){
                if(maxNode.val <= cur.val)
                    maxNode = cur;//保证了maxNode是最后一个最大值对应的节点
                if(cur.val <= insertVal && insertVal <= cur.next.val){
                    //当insertVal不是链表的最值的时候，这时候可以根据这个条件进行插入
                    node.next = cur.next;
                    cur.next = node;
                    return head;
                }
                cur = cur.next;
                if(cur == head)//回到了链表头，表示insertVal是最值，此时需要插入到maxNode的后面
                    break;
            }
            node.next = maxNode.next;
            maxNode.next = node;

        }
        return head;
    }
}

运行结果：

分隔链表

给你一个链表的头节点 head 和一个特定值 x ，请你对链表进行分隔，使得所有 小于 x 的节点都出现在 大于或等于 x 的节点之前。你应当 保留 两个分区中每个节点的初始相对位置。

示例 1：
输入：head = [1,4,3,2,5,2], x = 3
输出：[1,2,2,4,3,5]

示例 2：
输入：head = [2,1], x = 2
输出：[1,2]

提示：
链表中节点的数目在范围 [0, 200] 内
-100 <= Node.val <= 100
-200 <= x <= 200
通过次数117,895提交次数186,469

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/partition-list

要求将小于x的节点都放在大于等于x的节点前面，并且要保持节点之间的相对位置，所以我们可以利用队列这一种数据结构来保持相对顺序，队列是用来存放大于等于x的节点，然后再原来链表的基础上进行拼接小于x的节点，然后当队列不为空的时候，需要将队列中的节点拼接到原来的链表中。

对应代码 ：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public ListNode partition(ListNode head, int x) {
        Queue<ListNode> queue = new LinkedList<>();
        ListNode root = new ListNode(0,head);
        ListNode pre = root,cur = head;
        while(cur != null){
            //按照链表的相对顺序，将小于x的节点放在了前面,大于等于x的节点按照先后顺序放到了队列中
            if(cur.val >= x)
               queue.offer(cur);
            else{
                pre.next = cur;
                pre = pre.next;
            }
            cur = cur.next;
        }
        //queue中存放的是大于等于x的节点，并且跳出队列的时候是根据链表的相对顺序了
        while(!queue.isEmpty()){
            pre.next = queue.poll();
            pre = pre.next;
        }
        /*
        需要注意这一步，否则一不小心就形成了环形链表,例如[2,1]，这时候pre = 1,而2.next = 1
        此时经过上面出队操作之后，pre = 2，并且1.next = 2，如果没有这一步的话，就形成了环形链表
        明显不符合要求
        */
        pre.next = null;
        /*
        注意这里返回的不是head，而应该是root.next，因为有可能head就是大于等于x的节点
        这时候head节点就会放到了后面，此时如果返回head的话，那么就会导致它前面的节点缺失
        例如[2,1]，x = 2的时候，那么这时候2就会放在了1的后面，head（2）发生了改变，即
        head.next = null，所以返回head的时候只能返回2，而缺少了1，因此不可以返回head
        而root.next就是分割后的链表的头结点
        */
        return root.next;
    }
}

运行结果：

方法二：
利用两条链表进行合并，题目已经明确说明了小于x的节点需要放在大于等于x的节点之前，并且需要保证节点的相对位置，所以这时候我们可以定义两条链表small、large，small子链表用于存放小于x的节点，large用于存放大于等于x的节点，之后我们只要将small子链表的最后一个节点的next指针与指向large子链表的头结点即可实现分隔链表，然后返回small子链表的头结点即可。

对应代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution { 
    /*
    方法二：将定义两个子链表，这两个子链表存放的节点都是相对于原来链表的顺序的。
    其中small子链表存放的节点都是小于x的节点，large存放的都是大于等于x的节点。
    这时候只要将small子链表的最后一个节点放在large链表的头结点即可
    */
    public ListNode partition(ListNode head, int x) {
         ListNode small = new ListNode(0,null);
         ListNode large = new ListNode(0,null);
         ListNode cur = head,pre1 = small,pre2 = large;
         while(cur != null){
             if(cur.val < x){
                 //当前节点的值小于x，将其拼接到small子链表中
                 pre1.next = cur;
                 pre1 = pre1.next;
             }else{
                 //当前节点值大于等于x的值，那么将其拼接到large子链表中
                 pre2.next = cur;
                 pre2 = pre2.next;
             }
             cur = cur.next;
         }
         pre2.next = null;//将large子链表的最后一个节点的next为null，否则如果直接进行拼接，则可能导致环形链表的出现
         pre1.next = large.next;
         return small.next;
    }
}

运行结果：

两两交换链表中的节点

给定一个链表，两两交换其中相邻的节点，并返回交换后的链表。
你不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。

示例 1：
输入：head = [1,2,3,4]
输出：[2,1,4,3]

示例 2：
输入：head = []
输出：[]

示例 3：
输入：head = [1]
输出：[1]

提示：
链表中节点的数目在范围 [0, 100] 内
0 <= Node.val <= 100

进阶：你能在不修改链表节点值的情况下解决这个问题吗?（也就是说，仅修改节点本身。）

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/swap-nodes-in-pairs

方法一：
将链表按照奇偶性来进行分割成为两条子链表，然后同时遍历两条链表，每遍历到一个节点，就将奇数下标的节点放在偶数下标的节点前面。
方法二：利用迭代
假设dummy这个头结点是最早的两个节点完成交换后的最后一个节点，比如链表[2,1,3,4]，那么如果[2,1]两个节点进行交换，这时候交换之后为[1,2]，此时dummy就在2这个节点的位置。然后我们需要获取dummy的后面两个节点，表示即将要进行交换的两个节点node1,node2，然后每获取到这样的一对节点，我们都需要进行这样的操作从而实现两两交换：

dummy.next = node2;
node1.next = node2.next;
node2.next = node1;

然后这时候的node1就是交换后的最后一个节点，更新dummy为node1.重复上述操作，直到dummy没有节点，或者只有一个节点为止。

对应代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    /*
    通过观察可以发现，这个相当于两条子链表进行合并
    其中一条子链表奇数下标节点形成的链表，另一条则使偶数下标节点形成的链表
    例如[1,2,3,4]，偶数下标节点为1 -> 3,奇数下标节点为 2 -> 4
    然后遍历这两条链表，每遍历到一个，就将偶数下标节点放到奇数下标节点的后面

    public ListNode swapPairs(ListNode head) {
          if(head == null || head.next == null)
              return head;//如果链表为空，或者只有一个链表，那么直接返回head
          ListNode slow = head,fast = head.next,left = head,right = head.next;
          while(fast != null && fast.next != null){
              //将链表分割成为两条子链表
              slow.next = slow.next.next;
              fast.next = fast.next.next;
              fast = fast.next;
              slow = slow.next;
          }
          slow.next = null;
          //合并两个子链表
          return mergeList(left,right);

    }
    public ListNode mergeList(ListNode left,ListNode right){
        ListNode cur1 = left,cur2 = right,tmp1,tmp2;
        while(cur2.next != null){
            tmp1 = cur1.next;
            tmp2 = cur2.next;
            cur1.next = cur2.next;
            cur2.next = cur1;
            cur1 = tmp1;
            cur2 = tmp2;
        }
        cur2.next = cur1;
        return right;
    }
    */
    /*
    利用迭代的方式进行实现：
    创建一个带有头结点的链表，这时候头结点为dummy
    将一个指针tmp指向dummy，当当前这个节点tmp后面只有一个节点或者没有节点的时候
    直接退出循环，否则就进入循环体，表示tmp的后面至少有两个节点node1,node2
    即node1 = tmp.next,node2 = tmp.next.next;
    这时候我们对这两个节点进行交换：
    tmp.next = node2;
    node1.next = node2.next;
    node2.next = node1;
    然后更新tmp为node1
    */
    public ListNode swapPairs(ListNode head) {
          if(head == null || head.next == null)
              return head;//如果链表为空，或者只有一个链表，那么直接返回head
          ListNode root = new ListNode(0,head);
          ListNode dummy= root,node1,node2;
          while(dummy!= null && dummy.next != null && dummy.next.next != null){
             //获取dummy后面两个节点
              node1 = dummy.next;
              node2 = dummy.next.next;
              //获取后面两个节点后，需要进行一下操作，从而实现两个节点进行交换
              dummy.next = node2;
              node1.next = node2.next;
              node2.next = node1;
              //更新dummy
              dummy = node1;
          }
          return root.next;
    }
}

运行结果：

合并K个升序链表

给你一个链表数组，每个链表都已经按升序排列。
请你将所有链表合并到一个升序链表中，返回合并后的链表。

示例 1：
输入：lists = [[1,4,5],[1,3,4],[2,6]]
输出：[1,1,2,3,4,4,5,6]
解释：链表数组如下：
[
1->4->5,
1->3->4,
2->6
]
将它们合并到一个有序链表中得到。
1->1->2->3->4->4->5->6

示例 2：
输入：lists = []
输出：[]

示例 3：
输入：lists = [[]]
输出：[]

提示：
k == lists.length
0 <= k <= 10^4
0 <= lists[i].length <= 500
-10^4 <= lists[i][j] <= 10^4
lists[i] 按 升序 排列
lists[i].length 的总和不超过 10^4

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/merge-k-sorted-lists

方法一：
获取lists中的第一条链表ans，然后将遍历lists中剩下的链表，每遍历到一条链表，我们就将这一条链表和ans进行合并，然后将合并之后的链表的头结点返回赋值给ans，从而使得ans是这两条链表合并后的，重复上述操作，直到lists遍历完毕，此时ans就是K个链表合并之后的链表。
方法二：利用分治思想
我们来想一下，假设一条链表看成是一个数字，而这时候的lists就相当于无序的数组，我们应该怎样实现这个数组有序呢？答案可以选择归并排序、快速排序等排序算法，但是这个元素是一个链表啊，所以明显快速排序不行，所以利用归并排序,而在归并排序中的主要思想就是分治思想。

对应代码：

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    /*
    两两进行合并即可：
    首先获取前面两条，调用方法merge()，从而获取合并之后的链表ans,
    然后遍历列表中的剩余链表，每遍历到一个，就调用方法merge，将这个
    遍历到的链表和ans进行合并，然后更新ans


    但是利用归并排序的思想同样可以实现:类似于归并排序，只是这里的元素是一个链表罢了
    public ListNode mergeKLists(ListNode[] lists) {
        
        int i,size = lists.length;
        if(size == 0)
           return null;
        else if(size == 1)
           return lists[0];
        else{
            ListNode ans = lists[0];//将获取到第一条链表，然后遍历剩下的链表，每获得一条，就和ans进行合并，将合并之后的链表头赋值给ans
            for(i = 1; i < size; ++i){
                ans = merge(ans,lists[i]);
            }
            return ans;
        }
        
    }
    public ListNode merge(ListNode head1,   ListNode head2){
        ListNode root = new ListNode(0,head1);
        ListNode pre = root,cur1 = head1,cur2 = head2,tmp;//在不开辟一个新的链表，在head1的基础上进行合并
        while(cur1 != null && cur2 != null){
            if(cur1.val >= cur2.val){
                //cur1的值大于等于cur2，那么需要将cur2拼接在cur1的前面，pre的后面
               tmp = cur2.next;
               cur2.next = cur1;
               pre.next = cur2; 
               cur2 = tmp;
            }else{
                //如果cur1的节点的值小，那么需要移动cur1
               cur1 = cur1.next;
            }
            pre = pre.next;
        }
        pre.next = cur2 == null ? cur1 : cur2;
        return root.next;
    }
    */
    public ListNode mergeKLists(ListNode[] lists) {
        int i,size = lists.length;
        if(size == 0)
           return null;
        else if(size == 1)
           return lists[0];
        else{
           return mergeSort(lists,0,size - 1);
        }
        
    }
    public ListNode mergeSort(ListNode[] lists,int low,int high){
        if(low < high){
            int mid = low + (high - low) / 2;//获取中间元素（当然也可以是mid = (low + high) / 2
            ListNode left = mergeSort(lists,low,mid);
            ListNode right = mergeSort(lists,mid + 1,high);
            return merge(left,right);//将两个子链表合并成一个链表返回
        }else{
            //当low等于high的时候，直接返回这一条链表
            return lists[low];
        }
    }
    public ListNode merge(ListNode head1,   ListNode head2){
        ListNode root = new ListNode(0,head1);
        ListNode pre = root,cur1 = head1,cur2 = head2,tmp;//在不开辟一个新的链表，在head1的基础上进行合并
        while(cur1 != null && cur2 != null){
            if(cur1.val >= cur2.val){
                //cur1的值大于等于cur2，那么需要将cur2拼接在cur1的前面，pre的后面
               tmp = cur2.next;
               cur2.next = cur1;
               pre.next = cur2; 
               cur2 = tmp;
            }else{
                //如果cur1的节点的值小，那么需要移动cur1
               cur1 = cur1.next;
            }
            pre = pre.next;
        }
        pre.next = cur2 == null ? cur1 : cur2;
        /*
        这里同样不是返回head1,如果返回的是head1，同样会导致原来链表head1一些数据的缺失
        */
        return root.next;
    }
}

运行结果：