链表（2） - 技术栈

一、合并两个排序的链表

输入两个递增的链表，单个链表的长度为n，合并这两个链表并使新链表中的节点仍然是递增排序的。

数据范围： 0≤n≤1000，−1000≤节点值≤1000

要求：空间复杂度 O(1)，时间复杂度 O(n)

复制代码

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * @param pHead1 ListNode类
     * @param pHead2 ListNode类
     * @return ListNode类
     */
    public ListNode Merge (ListNode pHead1, ListNode pHead2) {
        ListNode dummy = new ListNode(-1);
        ListNode k = dummy;
        while (pHead1 != null && pHead2 != null) {
            // 比较哪一个节点的值更小，然后接到 k 的后面
            if (pHead1.val < pHead2.val) {
                k.next = pHead1;
                k = pHead1;
                pHead1 = pHead1.next;
            } else {
                k.next = pHead2;
                k = pHead2;
                pHead2 = pHead2.next;
            }
        }
        // 最后把剩余的链表接到 k 的后面
        k.next = pHead1 == null ? pHead2 : pHead1;
        return dummy.next;
    }
}

运行结果

二、合并k个已排序的链表

合并 k 个升序的链表并将结果作为一个升序的链表返回其头节点。

数据范围：节点总数 0≤n≤5000，每个节点的val满足 ∣val∣<=1000

要求：时间复杂度 O(nlogn)

复制代码

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * @param lists ListNode类ArrayList
     * @return ListNode类
     */
    public ListNode mergeKLists (ArrayList<ListNode> lists) {
        PriorityQueue<ListNode> minHeap = new PriorityQueue<>((o1,
                o2) -> o1.val - o2.val);
        // 先将非空链表的头节点加入小顶堆
        lists.stream()
        .filter(o -> o != null)
        .forEach(o -> minHeap.offer(o));
        ListNode dummy = new ListNode(-1), k = dummy;
        while (!minHeap.isEmpty()) {
            ListNode cur = minHeap.poll();
            k.next = cur;
            k = k.next;
            if (cur.next != null) {
                minHeap.offer(cur.next);
            }
        }
        return dummy.next;
    }
}

运行结果

三、判断链表中是否有环

判断给定的链表中是否有环。如果有环则返回true，否则返回false。

数据范围：链表长度 0≤n≤10000，链表中任意节点的值满足 ∣val∣<=100000

要求：空间复杂度 O(1)，时间复杂度 O(n)

输入分为两部分，第一部分为链表，第二部分代表是否有环，然后将组成的head头结点传入到函数里面。-1代表无环，其它的数字代表有环，这些参数解释仅仅是为了方便读者自测调试。实际在编程时读入的是链表的头节点。

复制代码

import java.util.*;
/**
 * Definition for singly-linked list.
 * class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public boolean hasCycle(ListNode head) {
        // 快慢指针
        ListNode fast, slow;
        fast = slow = head;
        // 快指针一次走两步，慢指针一次走一步
        // 若链表中没有环，则快指针可以正常走到终点 null；
        // 否则，快慢指针总将相遇
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                return true;
            }
        }
        return false;
    }
}

运行结果