【算法训练】LeetCode#21 合并两个有序链表

一、描述

合并两个有序链表

难度：简单

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

示例：

输入：1->2->4, 1->3->4
输出：1->1->2->3->4->4

二、问题

数据结构时对链表有本能的排斥，别说是python了，就算是让我用C写，我都不愿意写。。

不过正好补补自己的弱项吧。

.....................

这.....做了半个半个多小时，越做越糊涂，毕竟python的链表操作完全没有接触过，也没有指针，一头雾水~

重点是LeetCode上测试输入是List，我不知道如何在本地用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:
        l3 = ListNode()  # 声明一个结果链表

        loc1 = l1  # 声明l1标记位
        loc2 = l2  # 声明l2标记位
        loc3 = l3  # 存储l3头节点

        # 对结果链表做初始化
        if l1.val <= l2.val:
            l3 = l1
            loc1 = l1.next
        else:
            l3 = l2
            loc2 = l2.next

        while loc1.next is not None and loc2.next is not None:
            if loc1.val <= loc2.val:
                # 如果l1当前值小于l2当前值，则将当前值存入l3，并让l1的标记位向后移动一位
                l3.next = loc1
                l3 = l3.next
                loc1 = loc1.next
            else:
                # 如果l2当前值小于l1当前值，则将当前值存入l3，并让l2的标记位向后移动一位
                l3.next = loc2
                l3 = l3.next
                loc2 = loc2.next

        # 将后续节点存入l3
        if loc1.next is None:
            l3.next = loc2
        else:
            l3.next = loc1
        return loc3

问题应该是在loc3上，原来设想的是用loc3将l3的头地址存储下来，然后最后直接返回loc3就行，但是现在发现loc3一直为空，好像不是以引用的形式存储的l3.

用temp引用l3，不断让temp向后就行了，唉，其实起初就是想这样做，但是太不熟练了

        l3 = ListNode()  # 声明一个结果链表
        while loc1 and loc2:
            if loc1.val <= loc2.val:
                # 如果l1当前值小于l2当前值，则将当前值存入l3，并让l1的标记位向后移动一位
                temp.next = loc1
                temp = temp.next
                loc1 = loc1.next
            else:
                # 如果l2当前值小于l1当前值，则将当前值存入l3，并让l2的标记位向后移动一位
                temp.next = loc2
                temp = temp.next
                loc2 = loc2.next

三、解题

方法一，使用纯链表操作

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:
        l3 = ListNode()  # 声明一个结果链表
        temp = l3
        loc1 = l1  # 声明l1标记位
        loc2 = l2  # 声明l2标记位

        # 当loc1或loc2中有一个遍历完成时，跳出循环
        while loc1 and loc2:
            if loc1.val <= loc2.val:
                # 如果l1当前值小于l2当前值，则将当前值存入l3，并让l1的标记位向后移动一位
                temp.next = loc1
                temp = temp.next
                loc1 = loc1.next
            else:
                # 如果l2当前值小于l1当前值，则将当前值存入l3，并让l2的标记位向后移动一位
                temp.next = loc2
                temp = temp.next
                loc2 = loc2.next

        if loc1 is None:
            temp.next = loc2
        else:
            temp.next = loc1

        return l3.next

方法二，借用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:
        result = []  # 存储两个链表中的val

        # 将l1和l2的值存入list，利用sort进行排序
        while l1:
            result.append(l1.val)
            l1 = l1.next
        # 将l1和l2的值存入list，利用sort进行排序
        while l2:
            result.append(l2.val)
            l2 = l2.next

        result.sort()  # 对list进行从小到大的排序
        l3 = ListNode()
        temp = l3
        for i in result:
            temp.next = ListNode(i)
            temp = temp.next
        return l3.next