8. Java-合并K个有序链表

package com.dhl.beyond;

// 快速修改变量名称 shift + F6

import java.util.ArrayList;
import java.util.List;


public class test {
    
    
    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);
        node1.next = node2;
        node2.next = node3;
        node4.next = node5;
        Node[] nodes = {
    
    node1,node4};
        Node node = mergeKLists(nodes);
        printNode(node);

    }
static class Node {
    
    
        int val;
        Node next;

        Node(int x) {
    
    
            this.val = x;
        }
    }


    public static void printNode(Node head) {
    
    
        if (head == null) {
    
    
            System.out.println("该链表为空");
        }
        Node current = head;
        while (current != null) {
    
    
            System.out.print(current.val );
            if (current.next != null){
    
    
                System.out.printf(" -> ");
            }
            current = current.next;
        }
        System.out.println();
    }


    

    public static Node mergeKLists(Node[] lists) {
    
    
        //边界判断 异常判断
        if (lists == null || lists.length == 0) return null;
        //用List实现堆 索引0不放元素 index的左孩子为2*index 右孩子为2*index+1
        List<Node> heap = new ArrayList<>();
        Node head = null;
        Node s = null;
        heap.add(null);
        //先将K个链表的第一个节点放入堆中 堆得大小≤k 因为如果有null 则不放进去
        for (int i = 0; i < lists.length; i++) {
    
    
            if (lists[i] != null) {
    
    
                heap.add(lists[i]);
            }
        }

        //从n/2处 向上维护堆得性质
        for (int i = (heap.size() - 1) / 2; i >= 1; i--) {
    
    
            protectedHeap(heap, i);
        }
        //每次从堆顶拿走最小的节点
        //如果这个节点的下一个节点为null 如果这个节点的下一个节点不为null 该怎么办？自行脑补，我打字很难表达
        //维护堆得性质
        while (heap.size() > 1) {
    
    
            Node temp = heap.get(1);
            if (temp.next == null) {
    
    
                heap.set(1, heap.get(heap.size() - 1));
                heap.remove(heap.size() - 1);
            } else {
    
    
                heap.set(1, temp.next);
            }
            protectedHeap(heap, 1);
            if (head == null) {
    
    
                head = temp;
                s = head;
            } else {
    
    
                s.next = temp;
                s = s.next;
            }
            s.next = null;
        }
        return head;
    }

    //维护堆得性质 方法如下
    public static void protectedHeap(List<Node> heap, int index) {
    
    
        if (2 * index >= heap.size()) return;
        if (2 * index + 1 >= heap.size()) {
    
    
            if (heap.get(2 * index).val >= heap.get(index).val)
                return;
            else {
    
    
                Node temp = heap.get(2 * index);
                heap.set(2 * index, heap.get(index));
                heap.set(index, temp);
                protectedHeap(heap, 2 * index);
            }
        } else {
    
    
            int temp = heap.get(2 * index).val < heap.get(2 * index + 1).val ? 2 * index : 2 * index + 1;
            if (heap.get(temp).val < heap.get(index).val) {
    
    
                Node node = heap.get(temp);
                heap.set(temp, heap.get(index));
                heap.set(index, node);
                protectedHeap(heap, temp);
            } else {
    
    
                return;
            }
        }
    }


}