【NOWCODE FOUR】:链表

🤵Author：今日说“法”

🏆主攻领域：算法分析与设计

📰个人主页：今日说"法"的博客
📝系列专栏：NOWCODE系列

⚡️前言

        一位大佬曾经说过：程序=数据结构+算法  ，数据结构相当于一套普遍适用的工具，算法相当于一套行之有效的解题方法和解题步骤。Dambisa Moyo 曾经说过：“种一颗树最好的时间是十年前，其次是现在。”所以十年前没有刷题的朋友，现在跟着博主一起刷题吧。

工具介绍：链表

定义

链表通常由一连串节点（“链结点”）组成，每个节点包含任意的实例数据（data fields）和一或两个用来指向上一个/或下一个节点的位置的链接（“links”）。
链表（Linked list）是一种常见的基础数据结构，是一种线性表，但是并不会按线性的顺序存储数据，而是在每一个节点里存到下一个节点的指针(Pointer)。

结构

链表结点=数据+地址（下一个结点的地址）

优缺点

与数组相比：
　　使用链表结构可以克服数组链表需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。但是链表失去了数组随机读取的优点，同时链表由于增加了结点的指针域，空间开销比较大。
　　链表是一种插入和删除都比较快的数据结构，缺点是查找比较慢。除非需要频繁的通过下标来随机访问数据，否则在很多使用数组的地方都可以用链表代替。

CODE Exercise：

One: 删除链表的倒数第n个节点

难度：⭐⭐⭐ ⭐ 

时间限制：1秒

空间限制：256M

描述

给定一个链表，删除链表的倒数第 n 个节点并返回链表的头指针
例如，给出的链表为: 1→2→3→4→5, n= 2.
删除了链表的倒数第 n 个节点之后,链表变为1→2→3→5.

数据范围： 链表长度 0≤n≤1000，链表中任意节点的值满足 0≤val≤100

要求：空间复杂度 O(1)，时间复杂度 O(n)
备注：题目保证 n一定是有效的

 

示例1

输入：{1,2},2

返回值：{2}

Submit(python) 

class Solution:
    def removeNthFromEnd(self, head, n):    
        #左右指针指向头结点
        slow = fast = head
        #fast先走n步
        while n > 0 and fast:
            fast = fast.next
            n = n - 1
            
        if not fast:
            return head.next
        
        while fast.next:
            slow = slow.next
            fast = fast.next
        slow.next = slow.next.next
        return head

        
        

Two: 两个链表的第一个公共结点

难度：⭐⭐⭐ ⭐ 

时间限制：1秒

空间限制：256M

描述

输入两个无环的单向链表，找出它们的第一个公共结点，如果没有公共节点则返回空。（注意因为传入数据是链表，所以错误测试数据的提示是用其他方式显示的，保证传入数据是正确的）

数据范围：n≤1000
要求：空间复杂度 O(1)，时间复杂度 O(n)

例如，输入{1,2,3},{4,5},{6,7}时，两个无环的单向链表的结构如下图所示：

 

可以看到它们的第一个公共结点的结点值为6，所以返回结点值为6的结点。

输入描述：

输入分为是3段，第一段是第一个链表的非公共部分，第二段是第二个链表的非公共部分，第三段是第一个链表和第二个链表的公共部分。 后台会将这3个参数组装为两个链表，并将这两个链表对应的头节点传入到函数FindFirstCommonNode里面，用户得到的输入只有pHead1和pHead2。

返回值描述：

返回传入的pHead1和pHead2的第一个公共结点，后台会打印以该节点为头节点的链表。

 

示例1

输入：{1,2,3},{4,5},{6,7}

返回值：{6,7}

说明：第一个参数{1,2,3}代表是第一个链表非公共部分，第二个参数{4,5}代表是第二个链表非公共部分，最后的{6,7}表示的是2个链表的公共部分 这3个参数最后在后台会组装成为2个两个无环的单链表，且是有公共节点的

示例2

输入：{1},{2,3},{}
返回值：{}

说明：2个链表没有公共节点 ,返回null，后台打印{}

 Submit(python) 

class Solution:
    def FindFirstCommonNode(self , pHead1 , pHead2 ):
        # write code here
        tmp1=pHead1
        tmp2=pHead2
        while tmp1 and tmp2:
            if tmp1==tmp2:
                return tmp2
            tmp1=tmp1.next
            tmp2=tmp2.next
        if tmp1:
            k=0
            while tmp1:
                tmp1=tmp1.next
                k+=1
            tmp1=pHead1
            tmp2=pHead2
            for i in range(k):
                tmp1=tmp1.next
            while tmp1!=tmp2:
                if tmp1==tmp2:
                    return tmp2
                tmp1=tmp1.next
                tmp2=tmp2.next
            return tmp1
        if tmp2:
            k=0
            while tmp2:
                tmp2=tmp2.next
                k+=1
            tmp2=pHead2
            tmp1=pHead1
            for i in range(k):
                tmp2=tmp2.next
            while tmp2!=tmp1:
                tmp2=tmp2.next
                tmp1=tmp1.next
            return tmp2

 Three:链表相加(二)

难度：⭐⭐⭐ ⭐ 

时间限制：1秒

空间限制：256M

 

描述

假设链表中每一个节点的值都在 0 - 9 之间，那么链表整体就可以代表一个整数。

给定两个这种链表，请生成代表两个整数相加值的结果链表。

数据范围：0≤n,m≤1000000，链表任意值 0≤val≤9
要求：空间复杂度 O(n)，时间复杂度 O(n)

例如：链表 1 为 9->3->7，链表 2 为 6->3，最后生成新的结果链表为 1->0->0->0。

 

示例1

输入：[9,3,7],[6,3]
返回值：{1,0,0,0}

说明：如题面解释

示例2

输入：[0],[6,3]

返回值：{6,3}

 Submit(python) 

class ListNode:
    def __init__(self, x):
        self.val = x
        self.next = None
#
# 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
#
# 
# @param head1 ListNode类 
# @param head2 ListNode类 
# @return ListNode类
#
class Solution:
    def addInList1(self , head1: ListNode, head2: ListNode) -> ListNode:
        # write code here
        #得到第一个数字
        num1 = ''
        cur = head1
        while cur:
            num1 += str(cur.val)
            cur = cur.next
        num2 = ''
        cur = head2
        while cur:
            num2 = num2+str(cur.val)
            cur = cur.next
        num1 = str(int(num1)+int(num2))
        head = ListNode(-1)
        cur = head
        for i in range(len(num1)):
            cur.next = ListNode(int(num1[i]))
            cur = cur.next
        return head.next

    def addInList(self , head1: ListNode, head2: ListNode) -> ListNode:
        list1 = []
        list2 = []
        cur = head1
        while cur:
            list1.append(cur)
            cur = cur.next
        cur = head2
        while cur:
            list2.append(cur)
            cur = cur.next
        jinwei = 0
        while len(list1) > 0 or len(list2) > 0:
            if len(list2) == 0:
                tmp1 = list1.pop()
                if tmp1.val + jinwei>=10:
                    tmp1.val = tmp1.val + jinwei - 10
                    jinwei = 1
                else:
                    tmp1.val = tmp1.val + jinwei
                    return head1
            elif len(list1) == 0:
                tmp2 = list2.pop()
                if tmp2.val + jinwei>=10:
                    tmp2.val = tmp2.val + jinwei - 10
                    jinwei = 1
                    tmp2.next = head1
                    head1 = tmp2
                else:
                    tmp2.next = head1
                    tmp2.val = tmp2.val + jinwei
                    return head2
            else:
                tmp1 = list1.pop() ; tmp2 = list2.pop()
                if tmp1.val + tmp2.val + jinwei >= 10:
                    tmp1.val = tmp1.val + tmp2.val + jinwei - 10
                    jinwei = 1
                else:
                    tmp1.val = tmp1.val + tmp2.val + jinwei
                    jinwei = 0
        if jinwei == 0:
            return head1
        else:
            head = ListNode(1)
            head.next = head1
            return head


head1 = ListNode(9)
head1.next = ListNode(3)
head1.next.next = ListNode(7)
head2 = ListNode(6)
head2.next = ListNode(3)
head = Solution().addInList(head2 , head1)
cur = head
while cur:
    print(cur.val)
    cur = cur.next

🔥结语

        ❄️ 冰冻三尺非一日之寒❄️，只刷一两天刷法可成不了编程界的耶路撒冷，千里之行始于足下，所以还是得坚持刷题阿，每天记得要上机哟！！！