21.合并两个有序链表

将两个升序链表合并为一个新的 升序 链表并返回。
新链表是通过拼接给定的两个链表的所有节点组成的。

输入：l1 = [1,2,4], l2 = [1,3,4]
输出：[1,1,2,3,4,4]
示例 2：

输入：l1 = [], l2 = []
输出：[]
示例 3：

输入：l1 = [], l2 = [0]
输出：[0]

提示：

两个链表的节点数目范围是 [0, 50]
-100 <= Node.val <= 100
l1 和 l2 均按 非递减顺序 排列

#include <complex>
#include <iostream>
#include<iterator>
#include <vector>
#include <fstream>
#include <string>

using namespace std;

  struct ListNode {
      int val;
      ListNode *next;

      ListNode() : val(0), next(nullptr) {}
      ListNode(int x) : val(x), next(nullptr) {}
      ListNode(int x, ListNode *next) : val(x), next(next) {}
  };

class Solution {
public:
    ListNode* mergeTwoLists(ListNode* list1, ListNode* list2) {
        //顺序选取list1中的节点
        //将选取的节点与另一个链表的所有节点依次进行比较，
        //直到这个节点大于等于另一个链表的第n个节点
        //判断这个节点的值是否小于或等于第n+1个节点：是：将此节点插入到第n个节点和第n+1节点之间
        //否，继续将此节点的值和后面的所有节点依次进行比较，判断是否小于或等于某一节点，是，将这个节点插到某一节点前面
        //一直为否，将此节点插到最后一位，并终止判断
        ListNode* current_node=list1 ;  //将list1插入list2
        ListNode* current_node2=list2; //list2被插入，循环前定义list2当前元素，避免循环时被初始化
        while (current_node !=nullptr )   //当前节点不为空，情况1：如果list1为[ ]，则不用后续步骤，直接返回list2
        {
            ListNode* next = current_node->next;  //存储下一节点位置，为了避免插入次节点插入到list2后，该节点的下一节点的位置发生改变从而无法轮到原来的list1的下一节点
            if (list2 == nullptr)   //情况2：如果list2为空，则无需比较，直接结果为list1
                return list1;
            if (current_node->val <= list2->val)  //考虑list1中该节点比list2中第一个最小的值还小的情况：向前插入，在循环前进行此步，否则将比较list2中所有元素浪费时间
            {
                current_node->next = list2;  //该节点插入list2前面
                list2 = current_node;  //记得更新整个list2，list2最前面的元素应当为此节点
            }
            else             
            for (current_node2=list2 ; current_node2 != nullptr; current_node2 = current_node2->next)  //循环，从list2第一个节点开始，依次进行比较
            {
                if (current_node2->next == nullptr)  //key  前面已经排除掉前插情况， 走到这一步，需要插入的节点肯定比list第一个节点大，此处考虑list2当前节点即为最后一个节点的情况
                {
                    current_node2->next = current_node; //将需要被插入的节点后插
                    current_node2->next->next = nullptr; //**一定要记得被插入节点后面指向空**，让其成为list2最后一个节点，如若不然，该节点后面如果还有节点，它将指向原本在list1中自己的后面的下一节点，下次循环时，轮到此节点，将一直指向自己，变成死循环！
                    break; //不用判断后续步骤直接退出循环
                }
                
	            else if (current_node->val >= current_node2->val && current_node->val <= current_node2->next->val) //不是list2最后一个节点，如果需要插入的节点大于等于当前list2此节点 且 小于等于下一节点，则插入这两个节点之间
	            {
                    current_node->next = current_node2->next;  //被插入的节点的下一节点更改为当前list2节点的下一节点，和下一句的顺序不可以更换
                    current_node2->next = current_node;   //当前list2的下一节点改为被插入节点（list2当前节点的下一节点发生更改）
                    break;
	            }
            }

            current_node = next;  //继续判断下一节点
        }
        return list2;

    }
};

int main() // 自行测试
{
    ListNode listpool1[7];
    listpool1[0].val = -10;
    listpool1[0].next = &listpool1[1];
    listpool1[1].val = -10;
    listpool1[1].next = &listpool1[2];
    listpool1[2].val = -9;
    listpool1[2].next = &listpool1[3];
    listpool1[3].val = -4;
    listpool1[3].next = &listpool1[4];
    listpool1[4].val = 1;
    listpool1[4].next = &listpool1[5];
    listpool1[5].val = 6;
    listpool1[5].next = &listpool1[6];
    listpool1[6].val = 6;
    listpool1[6].next = nullptr;

    ListNode listpool2[1];
    listpool2[0].val = -7;
    listpool2[0].next = nullptr;

    Solution solution;
    solution.mergeTwoLists(&listpool1[0], &listpool2[0]);
}