leetcode初级算法——链表

（题目源自leetcode，方法都是自(cai)己(ji)写的，可能比较符合菜鸡们的思路）
链表是做到现在，感觉自己最拉垮的一节，数据结构真的都还给老师了

1.删除链表中的节点

请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点。传入函数的唯一参数为 要被删除的节点 。

示例 1：

输入：head = [4,5,1,9], node = 5
输出：[4,1,9]
解释：给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.

class Solution:
    def deleteNode(self, node):
        """
        :type node: ListNode
        :rtype: void Do not return anything, modify node in-place instead.
        """
        node.val = node.next.val
        node.next = node.next.next

一开始没看到啥意思，后来发现，给的node，就是让你删除的node。。。

2.删除链表的倒数第N个节点

给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。

示例：

给定一个链表: 1->2->3->4->5, 和 n = 2.

当删除了倒数第二个节点后，链表变为 1->2->3->5.

class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        len = 0
        mid = head
        if head.next == None:
            return head.next
        while mid != None:
            mid = mid.next
            len = len + 1
        target = len - n
        mid = head
        while target > 1:
            mid = mid.next
            target = target - 1
        if mid.next != None and target != 0:
            mid.next = mid.next.next
        if target == 0:
            head = head.next
        return head

比较蠢的办法，用了两次遍历，第一次算出链表的总长度，第二次，根据n求出正方向遍历的节点位置，删掉。

也可以用快慢指针，快指针提前出发n步
或者用迭代回溯，回溯n次
（感觉链表相关的，很多都需要迭代回溯）

3.反转链表

反转一个单链表。

示例:

输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL

class Solution:
    def reverseList(self, head: ListNode) -> ListNode:
        if head == None or head.next == None:
            return head
        out = self.reverseList(head.next)
        head.next.next = head
        head.next = None
        return out

使用迭代回溯，这里注意，其实out自始至终都没有变过，就是指在了最后一个node，变得是head.next.next = head，而且head.next一定得擦除，不然会无限循环

4.合并两个有序链表

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

示例：

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

class Solution:
    def mergeTwoLists(self, l1: ListNode, l2: ListNode) -> ListNode:
        if not l1: return l2
        if not l2: return l1
        if l1.val<=l2.val:
            l1.next = self.mergeTwoLists(l1.next,l2)
            return l1
        else:
            l2.next = self.mergeTwoLists(l1,l2.next)
            return l2

明明很简单，自己想了好久。还是用递归，自己在链表的递归方面真的太不熟练了

5.回文链表

请判断一个链表是否为回文链表。

示例 1:

输入: 1->2
输出: false

class Solution:
    def isPalindrome(self, head: ListNode) -> bool:
        out = []
        while head:
            out.append(head.val)
            head = head.next
        return True if out[:]==out[::-1] else False

就是遍历了链表，把所有的值放进了列表里，然后判断列表是否回文。

6.环形链表

给定一个链表，判断链表中是否有环。

如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。

如果链表中存在环，则返回 true 。 否则，返回 false 。

进阶：

你能用 O(1)（即，常量）内存解决此问题吗？
示例 1：

输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。

class Solution:
    def hasCycle(self, head: ListNode) -> bool:
        if not head:
            return False
        slow = head
        quick = head.next
        while slow != quick:
            if not quick or not quick.next or not slow.next:
                return False
            slow = slow.next
            quick = quick.next.next
        return True

还是用了快慢指针，慢指针走一步，快指针走两步，两个指针指向同一个node，就证明有环。
还可以定义一个hash={}，遍历链表，把node放进hash表里，遇到重复的，就证明是有环。