LEETCODE#21合并有序链表

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

1. 迭代法，比较原两链表中元素大小后将元素插入新的链表中 

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
      ListNode* prehead = new ListNode(-1);
      ListNode* prev = &prehead;
      while(l1 != NULL && l2 != NULL) {
          if(l1->val <= l2->val) {
              prev->next = l1;
              l1 = l1->next;
          } else {
              prev->next = l2;
              l2 = l2->next;
          }
          prev = prev->next;
      }
      prev->next = l1 != NULL ? l1 : l2;//其中一个挪完，另外接上
      return prehead->next;
}

2. 将两条链表中的元素全部存入向量，对向量排序后再用向量中的元素覆盖链表中的元素，同时将两条链表链接起来

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    if(l1==NULL)
      {
          return l2;
      }
    if(l2==NULL)
      {
          return l1;
      }
    vector<int> a;
    ListNode *p1 = l1;
    ListNode *p2 = l2;
    while(p1!=NULL)
    {
        a.push_back(p1->val);
        p1 = p1->next;
    }
    while(p2!=NULL)
    {
        a.push_back(p2->val);
        p2 = p2->next;
    }
    sort(a.begin(),a.end());
    p1 = l1;
    bool sign =0;//保证只连接一次
    for(int i =0;i<a.size();i++)
    {
        p1->val = a[i];
        if(p1->next==NULL&&sign==0)
        {
            p1->next = l2;
            sign =1;
        }
        p1 = p1->next;
    }
    return l1;
}

3. 跟2的做法大致相同，但没有将两条链表连起来，而是新建了一条链表 

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    if (!l1)return l2;
    if (!l2)return l1;
    vector<int> vec = {};
    while (l1!=NULL)
    {
        vec.push_back(l1->val);
        l1 = l1->next;
    }
    while (l2 != NULL)
    {
        vec.push_back(l2->val);
        l2 = l2->next;
    }
    sort(vec.begin(), vec.end());
    int len = vec.size();
    ListNode* p=new ListNode(vec[0]);
    ListNode* head = p;
    for (int i = 1; i < len; i++)
    {
        ListNode* newNode = new ListNode(0);
        newNode->val = vec[i];
        p->next = newNode;
        p = p->next;
    }
    return head;
}

 4. 将两链表连接后用冒泡法

struct ListNode* mergeTwoLists(struct ListNode* l1, struct ListNode* l2){
    if(l1==NULL)
        return l2;
    if(l2==NULL)
        return l1;//l1不为空且l2为空
    struct ListNode* p=l1;
    struct ListNode* q;
    //将两个链表首位相接直接构成一个链表
    while(p->next!=NULL)
        p=p->next;
    p->next=l2;
    //冒泡排序排列val值
    int temp;
    for(p=l1;p;p=p->next)
    {
        struct ListNode *ptr;  
        for(q=p->next;q;q=q->next)
        {
            ptr=p;
            if(ptr->val>q->val)
            {
                temp=q->val;
                q->val=p->val;
                p->val=temp;
            }
        }
    }
    return l1;
}