• Merge k Sorted Lists


    Solution and Precautions:

    Very similar to the classical merger sort for two sorted arrays, since the k linked list are already sorted, we just find the smallest number among the heads list[i][0] (i=0,…k-1), of course, if some list already reached to the end, that is list[i][0] is NULL, we just ignore this list, the smallest number is obviously the smallest one in the combined or merged final list, we repeat this process and push the smallest number found into the tail of the final merger list until there is no elements leaft. To fast find the smallest number among the k head elements, we could adopt the heap data structure, thus each found and delete of the minHeap, it cost O(log k), and it is possible to perform n such operations where n is the total number of elements of the k list, thus the time complexity is bounded by O(n * log k).

    Note, the bound could be even tighter since the size of the heap could be smaller when some list is consumed up. So for the delete min operations later on it might cost less than log k. (The exact bound is not easy to figure out for me)

    Min Heap Method

    /**
     * Definition for singly-linked list.
     * public class ListNode {
     *     int val;
     *     ListNode next;
     *     ListNode(int x) {
     *         val = x;
     *         next = null;
     *     }
     * }
     */
     /* Min heap*/
    public class Solution {
        public ListNode mergeKLists(ArrayList<ListNode> lists) {
           if(lists == null || lists.size() == 0) return null;
           
           Comparator<ListNode> comparator = new Comparator<ListNode>(){
               public int compare(ListNode m, ListNode n){
                   if(m.val == n. val) return 0;
                   else if(m.val > n .val) return 1;
                   else return -1;
               }
           };
           
           
           PriorityQueue<ListNode> p = new PriorityQueue<ListNode>(lists.size(), comparator);
           
           for( int i = 0; i < lists.size(); i++){
               if(lists.get(i) != null)
                p.add(lists.get(i));
           }
           
           ListNode head = null, c =null;
           
           while(!p.isEmpty()){
               if(head == null) {
                   head = p.poll();
                   c = head;
               } else{
                   c.next = p.poll();
                   c = c.next;
               }
               
               if(c.next != null) p.add(c.next);
           }
           return head;
        }
        
    }

    ref:http://blog.csdn.net/zyfo2/article/details/8682727

    Use Merge Two sorted List Method

     /* Merge Two lists method*/
    public class Solution {
        public ListNode mergeKLists(ArrayList<ListNode> lists) {
            ListNode head = null;
            int len = lists.size();
            
            if(len == 0) 
                return null;
            else if(len ==1) 
                return lists.get(0);
            
            head = merge2List(lists.get(0), lists.get(1));
            for(int i =2; i< len; i++){
                head = merge2List(lists.get(i), head);
            }
            return head;
            
        }
        
        public ListNode merge2List(ListNode node1, ListNode node2){
            ListNode head = new ListNode(Integer.MIN_VALUE);
            ListNode tmp = head;
            while(node1 != null && node2 != null){
                if(node1.val <= node2.val){
                    ListNode node = new ListNode(node1.val);
                    tmp.next = node;
                    tmp = tmp.next;
                    node1 = node1.next;
                }else{
                     ListNode node = new ListNode(node2.val);
                    tmp.next = node;
                    tmp = tmp.next;
                    node2 = node2.next;
                }
            }
            
            if(node1 != null){
                tmp.next = node1;
            }
            
            if(node2 != null){
                tmp.next = node2;
            }
            
            return head.next;
        }
        
    }
  • 相关阅读:
    工厂设计模式
    Java 注解 (Annotation)你可以这样学
    java的多线程和并发库
    NIO高并发基础
    Java编写画图板程序细节-保存已画图形
    程序员必须知道的知识
    慢慢读懂经济【持续更新】-经济浅谈
    Spring IOC与AOP的简单实现
    Python网络爬虫【持续更新】-BeautifulSoup库的使用
    Python网络爬虫【持续更新】-requests库的使用
  • 原文地址:https://www.cnblogs.com/RazerLu/p/3535608.html
Copyright © 2020-2023  润新知