刷题记录9---删除链表的倒数第N个节点+反转链表+回文链表+排序链表+LRU缓存

前言

所有题目均来自力扣题库中的hot 100，之所以要记录在这里，只是方便后续复习

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

题目：
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
示例 1：

输入：head = [1,2,3,4,5], n = 2
输出：[1,2,3,5]
示例 2：
输入：head = [1], n = 1
输出：[]
示例 3：
输入：head = [1,2], n = 1
输出：[1]
解题思路：
【链表遍历】删除某个节点好办，就是将该节点的前节点的下一个节点等于下一个节点的下一个节点，关键是如何找到要删除节点的前一个节点。我们可以先计算整个链表的长度length，然后要删除的节点就是第length-n+1个节点，其前一个节点就是第length-n个节点。还有一个问题是如果要删除的节点是头节点，头节点没有前节点怎么办？这样我们可以定义一个虚拟头节点，将原头节点放在整个虚拟头节点后面，但需要注意此时要删除节点的前节点的位置就随之变成了length - n + 1
代码（python）：

# Definition for singly-linked list.
# class ListNode:
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution:
    def removeNthFromEnd(self, head: ListNode, n: int) -> ListNode:
        node = ListNode(0, head)
        first = head
        second = node

        for i in range(0, n):
            first = first.next
        
        while first :
            first = first.next
            second = second.next
        
        second.next = second.next.next

        return node.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 removeNthFromEnd(ListNode head, int n) {
   
        // 获取链表长度
        int length = getLength(head);
        // 定义一个虚拟头，将参数节点添加到该节点的后面，为了删除原参数节点头位置时方便
        ListNode newHead = new ListNode(0, head);
        // 定义一个索引节点，用来遍历链表
        ListNode cur = newHead;
        // 计算得到要删除节点的 前一个节点 的位置即第几个节点，注意此时的头位置是 新定义的虚拟头
        int index = length - n + 1;
        //滑动索引节点 到 要删除节点的前一个节点的位置，注意滑动是 index - 1，而不是 index
        for (int i = 0; i < index - 1; i ++){
   
            cur = cur.next;
        }
        //将 删除节点的前一个节点 的 下一个节点  变为下一个节点的下一个节点 ，从而达到删除效果
        cur.next = cur.next.next;
        // 返回虚拟头节点的下一个节点，即原参数节点部分
        return newHead.next;
    }

    public int getLength(ListNode head){
   
        int length = 0;
        ListNode newHead = head;
        while (newHead != null){
   
            length ++;
            newHead = newHead.next;
        }
        return length;
    }
}

知识点：

• 无

原题链接：删除链表的倒数第N个节点

206.反转链表

题目：
给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。
示例 1：

输入：head = [1,2,3,4,5]
输出：[5,4,3,2,1]
示例 2：
输入：head = [1,2]
输出：[2,1]
示例 3：
输入：head = []
输出：[]
解题思路：
【反转链表】固定方式，记住即可
代码（python）：

# Definition for singly-linked list.
# class ListNode(object):
#     def __init__(self, val=0, next=None):
#         self.val = val
#         self.next = next
class Solution(object):
    def reverseList(self, head):
        """
        :type head: ListNode
        :rtype: ListNode
        """
        # 定义 索引节点
        cur = head
        # 定义之前节点，用来存储已经反转过的链表头
        pre = None
        # 如果索引节点不为空
        while cur:
            # 先存储索引节点的下一节点
            next_node = cur.next
            # 更新索引节点的下一节点为 之前节点
            cur.next = pre
            # 更新之前节点为 索引节点
            pre = cur
            # 更新索引节点 为原下一节点
            cur = next_node
        # 最后 之前节点  即为反转过的链表头
        return pre

代码（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 reverseList(ListNode head) {
   
        ListNode pre = null;
        ListNode cur = head;
        while (cur != null) {
   
            ListNode next = cur.next;;//存储下一个节点
            cur.next = pre;//让下一个节点指向前一个节点
            pre = cur;//更新前一个节点为当前节点，下一个循环使用
            cur = next;//更新当前节点为刚刚存储的下一个节点，下一个循环使用
        }
        return pre;
    }
}

知识点：

• 无

原题链接：反转链表

234.回文链表

题目：
给你一个单链表的头节点 head ，请你判断该链表是否为回文链表。如果是，返回 true ；否则，返回 false 。
示例 1：