标签：问题 head ListNode val current next 链表 LeeCode 节点
本文中所使用的链表定义如下所示：
# Definition for singly-linked list.
class ListNode:
def __init__(self, val=0, next=None):
self.val = val
self.next = next
// 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; }
}
LeeCode 203: 移除链表元素
题目描述：
给你一个链表的头节点
head和一个整数val，请你删除链表中所有满足Node.val == val的节点，并返回新的头节点。
标签： 链表，递归
时间复杂度：O(N)
建立模型：
- 移除非头节点：通过前一节点的next属性指向被移除节点的next节点即
pre.next = cur.next - 移除头节点：直接将head后移一位即
head = head.next - 为了统一上面两种操作，创建一个虚拟头节点，其next属性指向head，这样所有节点的移除都被归类为非头节点
- 返回虚拟头节点的next域
代码实现：
# Python3 实现
def removeElement(self, head: ListNode, val: int) -> ListNode:
virtual_head = ListNode(val=0, next=head)
pre, cur = virtual_head, head
while cur is not None:
if cur.val == val:
pre.next = cur.next
else:
pre = cur
cur = cur.next
return virtual_head.next
// Java 实现
public ListNode removeElements(ListNode head, int val) {
ListNode virtualHead = new ListNode(0, head);
ListNode pre = virtualHead;
ListNode cur = head;
while (cur != null) {
if (cur.val == val)
pre.next = cur.next;
else
pre = cur;
cur = cur.next;
}
return virtualHead.next;
}
LeeCode 707: 设计链表
题目描述：
设计链表的实现，可以选择使用单链表或双链表。单链表中的节点应该具有两个属性：
val和next。val 是当前节点的值，next 是指向下一个节点的指针/引用。如果要使用双向链表，则还需要一个属性prev以指示链表中的上一个节点。假设链表中的所有节点都是 0-index 的。
在链表中实现这些功能：
- get(index): 获取链表中第
index个节点的值。如果索引无效，则返回-1 - addAtHead(val): 在链表的第一个元素之前添加一个值为
val的节点。插入后，新节点将成为链表的第一个节点 - addAtTail(val): 将值为
val的节点追加到链表的最后一个元素 - addAtIndex(index, val): 在链表的
index位置添加值为val的节点。如果index的长度等于链表的长度，则将该节点添加到链表的末尾；如果index大于链表长度，则不会插入节点；如果index小于0，则在头部插入节点 - deleteAtIndex(index): 如果索引
index有效，则删除链表中在index位置的节点
建立模型：
- 考虑使用单链表实现
- 需要初始化头节点和链表长度
- 按功能添加代码
代码实现：
# Python3 实现
class MyLinkedList:
def __init__(self):
self.size = 0
self.head = None
def get(self, index: int) -> int:
if index >= self.size:
return -1
temp = self.head
for _ in range(index):
temp = temp.next
return temp.val
def addAtHead(self, val: int) -> None:
node = ListNode(val, None)
if self.head is None:
self.head = node
else:
temp = self.head
self.head = node
self.head.next = temp
self.size += 1
def addAtTail(self, val: int) -> None:
node = ListNode(val, None)
if self.head is None:
self.head = node
else:
temp = self.head
while temp.next:
temp = temp.next
temp.next = node
self.size += 1
def addAtIndex(self, index: int, val: int) -> None:
if index > self.size:
print("Add: Index out of range!")
return
if index == self.size:
self.addAtTail(val)
elif index <= 0:
self.addAtHead(val)
else:
pre = self.head
for _ in range(index - 1):
pre = pre.next
cur = pre.next
# 插入Node
node = ListNode(val, None)
pre.next = node
node.next = cur
self.size += 1
return
def deleteAtIndex(self, index: int) -> None:
if index < 0 or index >= self.size:
print("Delete: Index out of range!")
return
if index == 0:
self.head = self.head.next
else:
pre = self.head
for _ in range(index - 1):
pre = pre.next
cur = pre.next
# 删除cur节点
pre.next = cur.next
self.size -= 1
return
LeeCode 206: 反转链表
题目描述：
给你单链表的头节点
head，请你反转链表，并返回反转后的链表。
标签：链表，递归
时间复杂度：O(N)
建立模型：
- 定义两个指针 previous=head，current=head.next
- 将current指针的next节点保存在temp中
- 翻转previous，current的前后关系
- 更新previous，current指向的节点
代码实现：
# Python3 实现
def reverseList(self, head: ListNode) -> ListNode:
# 空链表或只有一个节点的链表翻转还是它自己
if not head or not head.next:
return head
previous, current = head, head.next
previous = None
while current:
temp = current.next
current.next = previous
# 更新 previous, current节点
previous = current
current = temp
return previous
// Java 实现
public ListNode reverseList(ListNode head) {
if (head == null || head.next == null) {
return head;
}
ListNode previous = head;
ListNode current = head.next;
previous.next = null;
while (current != null) {
ListNode temp = current.next;
current.next = previous;
previous = current;
current = temp;
}
return previous;
}
LeeCode 24: 两两交换链表中的节点
题目描述：
给你一个链表，两两交换其中相邻的节点，并返回交换后链表的头节点。你必须在不修改节点内部的值的情况下完成本题（即只能进行节点交换）。
题目解释：
- 若链表节点个数为偶数，则每两个节点交换即(1, 2), (3, 4), ..., (N-1, N)
- 若链表节点个数为奇数，则前N-1个节点每两个交换，最后一个节点不交换即(1, 2), (3, 4), ..., (N-2, N-1), (N)
建立模型：
- 定义两个指针 previous=virtual_head，current=head
- 将要与current交换的节点保存在following中
- 交换两个相邻的节点
- 更新previous，current节点
代码实现：
# Python3 实现
def swapPairs(self, head: ListNode) -> ListNode:
virtual_head = ListNode(0, head)
previous, current = virtual_head, head
while current and current.next:
following = current.next
# 交换两个相邻节点
previous.next = following
current.next = following.next
following.next = current
# 更新previous, current节点
previous = current
current = current.next
return virtual_head.next
// Java 实现
public ListNode swapPairs(ListNode head) {
ListNode virtualHead = new ListNode(0, head);
ListNode previous = virtualHead;
ListNode current = head;
while (current != null && current.next != null) {
ListNode following = current.next;
previous.next = following;
current.next = following.next;
following.next = current;
previous = current;
current = current.next;
}
return virtualHead.next;
}
标签：问题,head,ListNode,val,current,next,链表,LeeCode,节点 来源： https://www.cnblogs.com/ylyzty/p/16410354.html
本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享； 2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关； 3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关； 4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除； 5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。