5- Insira duas listas vinculadas monotonicamente crescentes e produza a lista combinada das duas listas vinculadas.Claro, precisamos da lista combinada para satisfazer as regras monótonas e não decrescentes.

Título: Insira duas listas vinculadas monotonicamente crescentes e produza a lista combinada das duas listas vinculadas.Claro, precisamos da lista combinada para atender às regras monotônicas não decrescentes.

• O código é o seguinte

  Um  público  classe Demo4 {
   2  
  3      pública  estáticos  vazios principais (String [] args) {
   4          // 先创建多个节点,供测试使用
  5          ListNode listNode1 = novo ListNode (1 );
  6          ListNode listNode2 = novo ListNode (2 );
  7          ListNode listNode3 = novo ListNode (6 );
  8          ListNode listNode4 = novo ListNode (14 );
  9          ListNode listNode5 = novo 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 = novo ListNode (6 );
18          ListNode listNode7 = novo ListNode (7 );
19          ListNode listNode8 = novo 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; next = null ;
 27  
28          System.out.println ("Os dados na lista original 1 são os seguintes:" );
 29          printList (listNode1);
 30          System.out.println ("\ nOs dados na lista original 2 são os seguintes:);
 31          printList (listNode6);
 32          
33          System.out.println ("\ n \ nOs dados da lista vinculada após a mesclagem são os seguintes:" );
 34          ListNode mergeHead = Merge (listNode1, listNode6);
 35          printList (mergeHead);
 36      }
 37      
38      / ** 
39       * Insira duas listas vinculadas monotonicamente crescentes e produza a lista combinada das duas listas vinculadas.Claro, precisamos da lista vinculada sintetizada para satisfazer as regras monótonas e não decrescentes.
40       * / 
41      pública  ListNode Merge estática (ListNode list1, ListNode list2) {
 42          if (list1 == null ) retorna list2;
 43          if (list2 == null) Retornar lista1;
44          
45          ListNode res = nulo ;
46          if (lista1.val < lista2.val) {
 47              res = lista1;
48              res.next = Mesclar (lista1.next, lista2);
49          } mais {
 50              res = lista2;
51              res.next = Mesclar (lista1, lista2.next);
52          }
 53          retorno res;
54      }
 55      
56      / ** 
57      * Insira duas listas vinculadas monotonicamente crescentes e produza a lista combinada das duas listas vinculadas.Claro, precisamos da lista combinada para satisfazer as regras monótonas e não decrescentes.
58       * / 
59      public  static ListNode myMerge (ListNode list1, ListNode list2) {
 60          if (list1 == null ) retorna list2;
 61          if (list2 == null ) retorna list1;
 62          ListNode mergeHead = null ;
 63          ListNode current = null ;
 64          while (list1! = Nulo && list2! = Nulo ) {
 65              if (list1.val <=list2.val) {
 66                  if (mergeHead == null ) {
 67                      mergeHead = current = list1;
68                  } mais {
 69                      current.next = list1;
70                      atual = atual.próximo;
71                  }
 72                  list1 = list1.next;
73              } mais {
 74                  if (mergeHead == null ) {
 75                      mergeHead = current = list2;
76                 } else {
 77                      current.next = list2;
78                      atual = atual.próximo;
79                  }
 80                  list2 = list2.next;
81              }
 82          }
 83          if (lista1 == nulo ) {
 84              atual.próximo = lista2;
85          } mais {
 86              current.next = list1;
87          }
 88          return mergeHead;
89      }
 90  
91      / ** 
92       * atravessar lista vinculada individual
 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  classe pública  ListNode {
 2 int val;
3      ListNode next = null ;
4 5 public ListNode ( int val) {
 6 this .val = val;
7     }
 8 }      
               

• Resultado da operação