2021字节跳动校招秋招算法面试真题解题报告–leetcode19 删除链表的倒数第 n 个结点，内含7种语言答案
1.题目描述
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。
进阶：你能尝试使用一趟扫描实现吗？
2.解题报告
在对链表进行操作时，一种常用的技巧是添加一个哑节点（dummy node），它的 \textit{next}next 指针指向链表的头节点。这样一来，我们就不需要对头节点进行特殊的判断了。
例如，在本题中，如果我们要删除节点 yy，我们需要知道节点 yy 的前驱节点 xx，并将 xx 的指针指向 yy 的后继节点。但由于头节点不存在前驱节点，因此我们需要在删除头节点时进行特殊判断。但如果我们添加了哑节点，那么头节点的前驱节点就是哑节点本身，此时我们就只需要考虑通用的情况即可。
这个题目是双指针的经典应用，如果要删除倒数第n个节点，让fast移动n步，然后让fast和slow同时移动，直到fast指向链表末尾。删掉slow所指向的节点就可以了。
3.最优答案
c答案
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* struct ListNode *next;
* };
*/
//定义两个指针，刚开始分别指向头结点，然后先让一个指针先走n-1步，接着两个指针同时遍历链表，当第一个指针到达链表尾部的时候，第二个指针指向的就是要删除的倒数第n个结点。
struct ListNode* removeNthFromEnd(struct ListNode* head, int n) {
struct ListNode *fast=head;
struct ListNode *slow=head;
for(int i=0;i<n;i++){
fast=fast->next;
if(fast==NULL) return head->next;
}
while(fast->next !=NULL){
fast=fast->next;
slow=slow->next;
}
slow->next=slow->next->next;
return head;
// struct ListNode *fast=head;
// struct ListNode *slow=head;
// int i;
// for(i=0;i<n;i++)
// {
// fast=fast->next;
// if(fast == NULL) return head->next;
// }
// while(fast->next != NULL)
// {
// fast=fast->next;
// slow=slow->next;
// }
// slow->next=slow->next->next;
// return head;
}
c++答案
class Solution
{
public:
ListNode* removeNthFromEnd(ListNode* head, int n)
{
if (!head->next) return NULL;//空链表
ListNode *pre = head, *cur = head;
for (int i = 0; i < n; i++)
cur = cur->next;
if (!cur)
return head->next;//cur==NULL，此时n大于链表长度，返回首元素
while (cur->next)
{
cur = cur->next;
pre = pre->next;//cur先走了n个长度，领先pre了n个长度;所以当cur走到末尾时，pre刚好指向倒数第n个节点
}
pre->next = pre->next->next;
return head;
}
};
java答案
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
ListNode root =head;
HashMap<Integer,ListNode> map = new HashMap<>();
int count = 0;
while(head != null){
count += 1;
map.put(count,head);
head = head.next;
}
if(count == 1 || count == n){
root = root.next;
}else if(n == 1 && count ==2){
map.get(count - n ).next = null;
}else {
map.get(count - n ).next = map.get(count - n + 2);
}
return root;
}
}
JavaScript答案
/**
* Definition for singly-linked list.
* function ListNode(val) {
* this.val = val;
* this.next = null;
* }
*/
/**
* @param {ListNode} head
* @param {number} n
* @return {ListNode}
*/
var removeNthFromEnd = function(head, n) {
if(head == null || n <= 0) {
return head;
}
var dummy = new ListNode(0);
dummy.next = head;
var p = dummy
var q = dummy
for(var i = 0; i < n + 1; i++) {
p = p.next;
}
while(p) {
p = p.next;
q = q.next
}
q.next = q.next.next;
return dummy.next;
// var count = 0;
// var p = head;
// while(p) {
// count++
// p = p.next
// }
// //顺数第m个
// var m = count - n + 1;
// var dummy = new ListNode(0);
// dummy.next = head;
// var cur = dummy;
// for(var i = 1; i < m; i++) {
// cur = cur.next;
// }
// cur.next = cur.next.next;
// return dummy.next;
};
c#答案
/**
* Definition for singly-linked list.
* public class ListNode {
* public int val;
* public ListNode next;
* public ListNode(int x) { val = x; }
* }
*/
public class Solution {
public ListNode RemoveNthFromEnd(ListNode head, int n) {
if(head==null)return null;
var list=new List<ListNode>(){head};
int i=0;
while(i<list.Count){
if(list[i].next!=null) {
list.Add(list[i].next);
}
i++;
}
if(list.Count==1){
return null;
}
else if(list.Count==n){
return list[1];
}
i=list.Count-n;
if(i>-1){
if(n==1){
list[list.Count-2].next=null;
}
else if(i-i>=0 && i+1<list.Count)
list[i-1].next=list[i+1];
}
return list[0];
}
}
python2.x答案
# Definition for singly-linked list.
# class ListNode(object):
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution(object):
def removeNthFromEnd(self, head, n):
"""
:type head: ListNode
:type n: int
:rtype: ListNode
"""
dummy = ListNode(0)
dummy.next = head
first = second = dummy
for i in range(n):
first = first.next
while first.next:
first = first.next
second = second.next
second.next = second.next.next
return dummy.next
python3.x答案
# 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
"""
head2 =[head.val]
while head.next != None:
head =head.next
head2.append(head.val)
head2.pop(-n)
return head2
go答案
/**
* Definition for singly-linked list.
* type ListNode struct {
* Val int
* Next *ListNode
* }
*/
func removeNthFromEnd(head *ListNode, n int) *ListNode {
var arr []*ListNode
arr = append(arr, head)
for node := head; node.Next != nil; node = node.Next {
arr = append(arr, node.Next)
}
if n == len(arr) {
head = head.Next
} else if n == 1 {
del := arr[len(arr)-2]
del.Next = nil
} else {
del := arr[len(arr)-n]
deleteNode(del)
}
return head
}
func deleteNode(node *ListNode) {
next := node.Next
node.Val = next.Val
node.Next = next.Next
}