合并K个排序链表-最小堆

合并K个排序链表-最小堆
https://leetcode-cn.com/problems/merge-k-sorted-lists/

	static public class ListNode {
        int val;
        ListNode next;

        ListNode(int x) {
            val = x;
        }
    }

    public static void main(String[] args) {
        int[][] nums = new int[][]{{-8,-7,-6,-3,-2,-2,0,3},{-10,-6,-4,-4,-4,-2,-1,4},{-10,-9,-8,-8,-6},{-10,0,4}};

        ListNode[] listNodes = new ListNode[nums.length];
        for (int j = 0 ;j < nums.length; j++) {
            int[] linkNums = nums[j];
            ListNode head = new ListNode(linkNums[0]);
            ListNode pre = head;
            for (int num : linkNums) {
                pre.next = new ListNode(num);
                pre = pre.next;
            }
            listNodes[j] = head;
        }

        ListNode result = mergeKLists(listNodes);

        while (result != null) {
            System.out.print("\t" + result.val);
            result = result.next;
        }
    }

    public static ListNode mergeKLists(ListNode[] lists) {
        int size = 0;
        for (ListNode node : lists) {
            if (node!= null) lists[size++] = node;
        }
        if (size == 0) return null;
        if (size == 1) return lists[0];

        creatHeap(lists, size);

        ListNode result = lists[0];
        ListNode resultHead = result;
        while (size > 0) {
            size = insertHeap(lists, lists[0].next, size);
            result.next = lists[0];
            result = result.next;
        }
        return resultHead;
    }

    public static void creatHeap(ListNode[] nodes, int size) {
        for (int i = (size - 2) / 2; i >= 0; i--) {
            heapify(nodes, i, size);
        }
    }

    public static void heapify(ListNode[] nodes, int i, int size) {
        if ((i * 2 + 1) >= size) return;
        int minIndex = (i * 2 + 2) < size && nodes[i * 2 + 1].val > nodes[i * 2 + 2].val ? i * 2 + 2 : i * 2 + 1;
        if (nodes[i].val > nodes[minIndex].val) {
            swap(nodes, i, minIndex);
            heapify(nodes, minIndex, size);
        }
    }

    public static int insertHeap(ListNode[] nodes, ListNode x, int nodesSize) {
        if (x == null) { //删除，从最后开始
            nodes[0] = nodes[nodesSize -1];
            nodes[nodesSize -1] = null;
            nodesSize = nodesSize -1;
        } else { //替换从第一个开始
            nodes[0] = x;
        }

        for (int i = 0; i < nodesSize  / 2; ) {
            int minIndex = (i * 2 + 2) < nodesSize && nodes[i * 2 + 1].val > nodes[i * 2 + 2].val ? i * 2 + 2 : i * 2 + 1;
            if (nodes[i].val > nodes[minIndex].val) {
                swap(nodes, i, minIndex);
                i = minIndex;
            } else break;
        }
        return nodesSize;
    }

    public static void swap(ListNode[] nums, int i, int j) {
        ListNode temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }