一. 删除链表中的节点
请编写一个函数，使其可以删除某个链表中给定的（非末尾）节点，你将只被给定要求被删除的节点。
现有一个链表 -- head = [4,5,1,9]，它可以表示为:
4 -> 5 -> 1 -> 9
示例 1:
输入: head = [4,5,1,9], node = 5 输出: [4,1,9] 解释: 给定你链表中值为 5 的第二个节点，那么在调用了你的函数之后，该链表应变为 4 -> 1 -> 9.
示例 2:
输入: head = [4,5,1,9], node = 1 输出: [4,5,9] 解释: 给定你链表中值为 1 的第三个节点，那么在调用了你的函数之后，该链表应变为 4 -> 5 -> 9.
说明:
- 链表至少包含两个节点。
- 链表中所有节点的值都是唯一的。
- 给定的节点为非末尾节点并且一定是链表中的一个有效节点。
- 不要从你的函数中返回任何结果。
我的解答：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
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 #当前结点的下一个结点是原来的下下个结点
二. 删除链表的倒数第N个节点
给定一个链表，删除链表的倒数第 n 个节点，并且返回链表的头结点。
示例：
给定一个链表: 1->2->3->4->5, 和 n = 2. 当删除了倒数第二个节点后，链表变为 1->2->3->5.
说明：
给定的 n 保证是有效的。
进阶：
你能尝试使用一趟扫描实现吗？
我的解答：
（1）定义2个指针p1，p2。
（2）使用循环让p2指向顺数第n个节点，同时p1指向第头结点；
（3）然后，p1和p2同时移动，直到p2指向NULL，此时p1应该指向倒数第n个节点。
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def removeNthFromEnd(self, head, n):
"""
:type head: ListNode
:type n: int
:rtype: ListNode
"""
#这里head的type就是一个链表结点
#链表只有一个元素的情况，需要删除这个元素
if(head.next == None):
return None
else:
p1 = head
p2 = head
count = 0 #这个是控制node1和node2的位置的（倒数第几个）
while p1.next != None:
p1 = p1.next
if(count >= n):
p2 = p2.next
count = count + 1
#这时候第一个指针已经走到终点了，然后只需要删除第二个指针指向的结点
#删除最后一个结点的情况
if(n == 1):
p2.next = None
return head
#删除第一个结点的情况
elif(n - count == 1):
return head.next
else:
p2.next = p2.next.next
return head
三. 反转链表
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
我的解答：
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def reverseList(self, head):
"""
:type head: ListNode
:rtype: ListNode
"""
# 第一次 p q r
# 第二次 p q
# ......
if(head == None):
return None
else:
p = head
q = head.next
p.next = None
while q:
r = q.next
q.next = p
p = q
q = r
return p
四. 合并两个有序链表
将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
示例：
输入：1->2->4, 1->3->4 输出：1->1->2->3->4->4
我的解答：
方法1：递归方法
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeTwoLists(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
#方法一：递归
if not l1 and not l2:
return None
if not l1:
return l2
if not l2:
return l1
if l1.val>=l2.val:
l2.next = self.mergeTwoLists(l1,l2.next)
return l2
else:
l1.next = self.mergeTwoLists(l1.next,l2)
return l1
方法2：非递归
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def mergeTwoLists(self, l1, l2):
"""
:type l1: ListNode
:type l2: ListNode
:rtype: ListNode
"""
#方法2：非递归
head = ListNode(0)
savehead = head #保留初始链表结点索引
if not l1 and not l2:
return None
else:
while l1 and l2:
if l1.val >= l2.val:
head.next = l2
l2 = l2.next
else:
head.next = l1
l1 = l1.next
head = head.next
if l1:
head.next = l1
if l2:
head.next = l2
return savehead.next
五. 回文链表
请判断一个链表是否为回文链表。
示例 1:
输入: 1->2 输出: false
示例 2:
输入: 1->2->2->1 输出: true
进阶：
你能否用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题？我的解答：
方法1：将链表中的数放到一个数组中，然后进行判断
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def isPalindrome(self, head):
"""
:type head: ListNode
:rtype: bool
"""
#解答1：将链表中的数放到一个数组中，然后进行判断
#完成链表——>数组
nums = []
while head:
nums.append(head.val)
head = head.next
#判断数组是否为回文序列
for i in range(len(nums)):
if(nums[i] != nums[-i-1]):
return False
return True方法2：快慢指针（1个走一步，1个走两步）找到中点（指针1在中点，指针2在末尾），然后将后半部分进行逆序，最后两部分进行比较看是否是回文链表
具体实现还没写出来
六. 环形链表
给定一个链表，判断链表中是否有环。
进阶：
你能否不使用额外空间解决此题？
我的解答：
快慢指针（1个一次一格，另1个一次两格），那么如果有环的话，跑的快的一定会追满的一圈（相当于每次next，两个指针就会接近一步）。
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def hasCycle(self, head):
"""
:type head: ListNode
:rtype: bool
"""
#判断链表是否为空，如果为空，返回false
if not head:
return False
#非空链表如下
p1 = p2 = head
while p1.next and p2.next.next:
p1 = p1.next
p2 = p2.next.next
if(p1 == p2):
return True
return False