5- Ingrese dos listas enlazadas que aumentan monotónicamente y genere la lista combinada de las dos listas enlazadas. Por supuesto, necesitamos la lista combinada para satisfacer las reglas monótonas y no decrecientes.

Título: ingrese dos listas enlazadas que aumentan monotónicamente y envíe la lista combinada de las dos listas enlazadas. Por supuesto, necesitamos que la lista combinada cumpla con las reglas monotónicas no decrecientes.

• El código es el siguiente

  1  clase pública  Demo4 {
   2   3 public static void main (String [] args) {
   4 // 先 创建 多个 节点 ， 供 测试 使用  5          ListNode listNode1 = new ListNode (1 );
  6          ListNode listNode2 = new ListNode (2 );
  7          ListNode listNode3 = new ListNode (6 );
  8          ListNode listNode4 = new ListNode (14 );
  9          ListNode listNode5 = new ListNode (15 );
10 
                
         // 把 各个 节点 链 起来
11          listNode1.next = listNode2;
12          listNode2.next = listNode3;
13          listNode3.next = listNode4;
14          listNode4.next = listNode5;
15          listNode5.next = null ;
16          
17          ListNode listNode6 = new ListNode (6 );
18          ListNode listNode7 = new ListNode (7 );
19          ListNode listNode8 = new ListNode (10 );
20         ListNode listNode9 = new ListNode (11 );
 21          ListNode listNode10 = new ListNode (13 );
 22          listNode6.next = listNode7;
 23          listNode7.next = listNode8;
 24          listNode8.next = listNode9;
 25          listNode9.next = listNode10;
 26          listNode10. siguiente = nulo ;
 27  
28          System.out.println ("Los datos en la lista original 1 son los siguientes:" );
 29          printList (listNode1);
 30          System.out.println ("\ nLos datos en la lista original 2 son los siguientes:");
 31          printList (listNode6);
 32          
33          System.out.println ("\ n \ nLos datos de la lista después de la fusión son los siguientes:" );
 34          ListNode mergeHead = Merge (listNode1, listNode6);
 35          printList (mergeHead);
 36      }
 37      
38      / ** 
39       * Ingrese dos listas vinculadas que aumentan monotónicamente y genera la lista combinada de las dos listas vinculadas. Por supuesto, necesitamos la lista vinculada sintetizada para satisfacer las reglas monótonas y no decrecientes.
40       * / 
41 es      público  estática NodoLista la Merge (NodoLista Lista1, Lista2 NodoLista) {
 42 es          SI (Lista1 == nula ) de retorno Lista2;
 43 es          SI (Lista2 == nula) volver lista1;
44          
45          ListNode res = null ;
46          if (list1.val < list2.val) {
 47              res = list1;
48              res.next = Merge (list1.next, list2);
49          } más {
 50              res = list2;
51              res.next = Fusionar (list1, list2.next);
52          }
 53          return res;
54      }
 55      
56      / ** 
57      * Ingrese dos listas enlazadas que aumentan monotónicamente y envíe la lista combinada de las dos listas enlazadas. Por supuesto, necesitamos la lista combinada para satisfacer las reglas monótonas y no decrecientes.
58       * / 
59      public  static ListNode myMerge (ListNode list1, ListNode list2) {
 60          if (list1 == null ) return list2;
 61          if (list2 == null ) return list1;
 62          ListNode mergeHead = null ;
 63          ListNode current = null ;
 64          while (list1! = Null && list2! = Null ) {
 65              if (list1.val <=list2.val) {
 66                  if (mergeHead == null ) {
 67                      mergeHead = current = list1;
68                  } else {
 69                      current.next = list1;
70                      actual = actual.siguiente;
71                  }
 72                  list1 = list1.next;
73              } else {
 74                  if (mergeHead == null ) {
 75                      mergeHead = current = list2;
76                 } else {
 77                      current.next = list2;
78                      actual = actual.siguiente;
79                  }
 80 list2                  = list2.next;
81              }
 82          }
 83          if (list1 == null ) {
 84              current.next = list2;
85          } else {
 86              current.next = list1;
87          }
 88          return mergeHead;
89      }
 90  
91      / ** 
92       * atravesar lista enlazada individualmente
 93       * @param listNode
 94       * / 
95      public  static  void printList (ListNode listNode) {
 96          ListNode tempNode = listNode;
 97          while (tempNode! = Null ) {
 98              System.out. printf ("% d \ t" , tempNode.val);
 99              tempNode = tempNode.next;
 100          }
 101      }
 102 }

1  clase pública  ListNode {
 2 int val;
3      ListNode next = null ;
4 5 public ListNode ( int val) {
 6 this .val = val;
7     }
 8 }      
               

• Resultado de la operación