5- Entrer deux listes chaînées croissantes monotones et sortir la liste combinée des deux listes chaînées Bien sûr, nous avons besoin de la liste combinée pour satisfaire aux règles monotones et non décroissantes.

Titre: Entrez deux listes chaînées à augmentation monotone et sortez la liste combinée des deux listes chaînées. Bien entendu, nous avons besoin de la liste combinée pour respecter les règles monotones non décroissantes.

• Le code est le suivant

  1  classe publique  Demo4 {
   2   3 public static void main (String [] args) {
   4 // 先 创建 多个 节点 ， 供 测试 使用  5          ListNode listNode1 = new ListNode (1 );
  6          ListNode listNode2 = nouveau ListNode (2 );
  7          ListNode listNode3 = nouveau ListNode (6 );
  8          ListNode listNode4 = nouveau ListNode (14 );
  9          ListNode listNode5 = nouveau ListNode (15 );
dix 
                
         // 把 各个 节点 链 起来
11          listNode1.next = listNode2;
12          listNode2.next = listNode3;
13          listNode3.next = listNode4;
14          listNode4.next = listNode5;
15          listNode5.next = null ;
16          
17          ListNode listNode6 = nouveau ListNode (6 );
18          ListNode listNode7 = nouveau ListNode (7 );
19          ListNode listNode8 = nouveau ListNode (10 );
20         ListNode listNode9 = nouveau ListNode (11 );
 21          ListNode listNode10 = nouveau 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 ("Les données de la liste d'origine 1 sont les suivantes:" );
 29          printList (listNode1);
 30          System.out.println ("\ nLes données de la liste d'origine 2 sont les suivantes:");
 31          printList (listNode6);
 32          
33          System.out.println ("\ n \ nLes données de la liste liée après la fusion sont les suivantes:" );
 34          ListNode mergeHead = Merge (listNode1, listNode6);
 35          printList (mergeHead);
 36      }
 37      
38      / ** 
39       * Entrer deux listes chaînées à augmentation monotone et sortir la liste combinée des deux listes chaînées. Bien entendu, nous avons besoin de la liste chaînée synthétisée pour satisfaire aux règles monotones et non décroissantes.
40       * / 
41      public  static ListNode Merge (ListNode list1, ListNode list2) {
 42          if (list1 == null ) return list2;
 43          if (list2 == null) retourne list1;
44          
45          ListNode res = null ;
46          if (list1.val < list2.val) {
 47              res = list1;
48              res.next = Fusionner (list1.next, list2);
49          } else {
 50              res = list2;
51              res.next = Fusionner (list1, list2.next);
52          }
 53          retour res;
54      }
 55      
56      / ** 
57      * Entrez deux listes chaînées à augmentation monotone et sortez la liste combinée des deux listes chaînées. Bien entendu, nous avons besoin de la liste combinée pour satisfaire aux règles monotones et non décroissantes.
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                      current = current.next;
71                  }
 72                  list1 = list1.next;
73              } else {
 74                  if (mergeHead == null ) {
 75                      mergeHead = current = list2;
76                 } else {
 77                      current.next = list2;
78                      current = current.next;
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       * parcourir la liste liée séparément
 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 publique  ListNode {
 2 int val;
3      ListNode suivant = null ;
4 5 ListNode public ( int val) {
 6 this .val = val;
7     }
 8 }      
               

• Résultat de l'opération