LeetCode简单题：21. 合并两个有序链表（Python,C++,Java）

一.解法

https://leetcode-cn.com/problems/merge-two-sorted-lists/
要点：链表
C++创建链表用的是指针
java和Python创建链表不用指针
C++将链表2插入到链表1中
java和Python中创建新链表头，用迭代法每次取两个有序链表头中小的那个加入链表，最后将长链表剩下的部分接在后面

二.Python实现

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
    
        prehead = ListNode(-1)
        prev = prehead
        while l1 and l2:
            if l1.val <= l2.val:
                prev.next = l1
                l1 = l1.next
            else:
                prev.next = l2
                l2 = l2.next            
            prev = prev.next

        # 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 if l1 is not None else l2

        return prehead.next

三.C++实现

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode(int x) : val(x), next(NULL) {}
 * };
 */
class Solution {
public:
    ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
    
        ListNode*p1,*p2;
        struct ListNode newhead(0);
        newhead.next=l1;
        l1=&newhead;
        
        while(l2){
            
            p1=l1->next;
            p2=l2->next;
            if(p1==NULL){ l1->next=l2;break;}
            
            if(l2->val<=p1->val){
                l2->next=p1;l1->next=l2;l2=p2;
            }
            
            l1=l1->next;
            
        }
        
        return newhead.next;
        
    }
};

四.java实现

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public 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;
        }

        // 合并后 l1 和 l2 最多只有一个还未被合并完，我们直接将链表末尾指向未合并完的链表即可
        prev.next = l1 == null ? l2 : l1;

        return prehead.next;
    }
}