p122 Combinar K listas ordenadas (código 23)

Uno: solución al problema

Método uno: He solucionado el problema de fusionar dos listas vinculadas antes, luego el primer método es fusionar las listas vinculadas en la matriz de dos en dos para obtener el resultado final. Tiempo: O (k * n), Espacio: O (1)

Método 2: utilice el método de dividir y conquistar para unir. Recurrencia continua, solo queda una lista vinculada al final. Tiempo: O (n * log (k)), Espacio: O (log (k))

Dos: ejemplos de código completos (versión C ++ y versión Java)

Método uno C ++:

Solución de 
clase 
{ private : 
    ListNode * mergeTwoSortedLists (ListNode * l1, ListNode * l2) 
    { 
        ListNode * dummy = new ListNode ( 0 ); 
        ListNode * p = dummy;
        while (l1! = NULL && l2! = NULL) 
        { 
            if (l1-> val <l2-> val) 
            { 
                p -> next = l1; 
                l1 = l1-> siguiente; 
            } 
            más 
            { 
                p -> siguiente =l2; 
                l2 = l2-> siguiente; 
            } 

            p = p-> siguiente; 
        } 

        if (l1! = NULL) p-> next = l1;
        if (l2! = NULL) p-> siguiente = l2; 

        volver ficticio-> siguiente; 
    } 
public : 
    ListNode * mergeKLists (vector <ListNode *> & lists) 
    { 
        if (lists.size () == 0 ) return NULL; 
        ListNode * result = NULL;
        para (ListNode * list: lists) 
        {
            resultado = mergeTwoSortedLists (resultado, lista); 
        } 

        resultado devuelto ; 
    } 
};

Método uno Java:

clase Solución 
    { 
        private ListNode mergeTwoSortedLists (ListNode l1, ListNode l2) 
        { 
              ListNode dummy = new ListNode ( 0 ); 
              ListNode p = dummy;
              while (l1! = null && l2! = null ) 
              { 
                  if (l1.val < l2.val) 
                  { 
                      p.next = l1; 
                      l1 = l1.siguiente; 
                  } 
                  más = 
                  {
                      p.siguientel2; 
                      l2 = l2.siguiente; 
                  } 
                  p = p.siguiente; 
              } 

              if (l1! = null ) p.next = l1;
              if (l2! = nulo ) p.next = l2; 

              return dummy.next; 
        } 

        public ListNode mergeKLists (ListNode [] lists) 
        { 
               if (lists == null || lists.length == 0 ) return  null ; 
               Resultado ListNode = nulo ;
               para(ListNode list: lists) 
               { 
                   result = mergeTwoSortedLists (resultado, lista); 
               } 

               resultado devuelto ; 
        } 
    }

Método dos C ++:

Solución de 
clase 
{ private : 
    ListNode * mergeTwoSortedList (ListNode * l1, ListNode * l2) 
    { 
            ListNode * dummy = new ListNode ( 0 ); 
            ListNode * p = dummy;
            while (l1! = NULL && l2! = NULL) 
            { 
                if (l1-> val <l2-> val) 
                { 
                    p -> next = l1; 
                    l1 = l1-> siguiente; 
                } 
                más 
                {
                    p -> siguiente =l2; 
                    l2 = l2-> siguiente; 
                } 

                p = p-> siguiente; 
            } 

            if (l1! = NULL) p-> next = l1;
            if (l2! = NULL) p-> siguiente = l2; 

            volver ficticio-> siguiente; 
    } 

    ListNode * merge (vector <ListNode *> & lists, int start, int end) 
    { 
        if (start == end) return lists [start];
        if (inicio> fin) devuelve NULL;
        int mid = start + (end-start) /2 ; 
        ListNode * left = merge (listas, inicio, mediados); 
        ListNode * right = merge (listas, mid + 1 , end); 

        return mergeTwoSortedList (izquierda, derecha); 
    } 
public : 
    ListNode * mergeKLists (vector <ListNode *> & lists) 
    { 
        if (lists.size () == 0 ) return NULL; 

        return merge (lists, 0 , lists.size () - 1 ); 
    } 
};

Método dos Java:

clase Solución 
    { 
        listNode privado mergeTwoSortedList (ListNode l1, ListNode l2) 
        { 
                ListNode dummy = new ListNode ( 0 ); 
                ListNode p = dummy;
                while (l1! = null && l2! = null ) 
                { 
                    if (l1.val < l2.val) 
                    { 
                        p.next = l1; 
                        l1 = l1.siguiente; 
                    } 
                    más 
                    {
                        p.siguiente= l2; 
                        l2 = l2.siguiente; 
                    } 
                    p = p.siguiente; 
                } 
                
                if (l1! = null ) p.next = l1;
                if (l2! = nulo ) p.next = l2; 
                
                return dummy.next; 
        }
         fusión privada de ListNode (ListNode [] listas, int start, int end) 
        { 
               if (start == end) devuelve listas [start];
               if (inicio> fin) devuelve  nulo;
               int mid = inicio + (fin-inicio) / 2 ; 
               ListNode left = merge (listas, inicio, mediados); 
               ListNode right = merge (listas, mid + 1 , end); 
               
               return mergeTwoSortedList (izquierda, derecha); 
        } 

        public ListNode mergeKLists (ListNode [] lists) 
        { 
               if (lists == null || lists.length == 0 ) return  null ; 
               
               return merge (lists, 0 , lists.length- 1 ); 
        } 
    }