LeetCode——链表专题
链表逆序
1.简单
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
简单，直接上手。
class Solution {
public ListNode reverseList(ListNode head) {
ListNode newHead = null;//新头节点
ListNode cur = head;
while(cur!=null){//顺序遍历，头插法插入
ListNode Next = cur.next;//存储后继结点
cur.next = newHead;
newHead = cur;
cur = Next;
}
return newHead;
}
}2.中等
反转从位置 m 到 n 的链表。请使用一趟扫描完成反转。
说明:
1 ≤ m ≤ n ≤ 链表长度。
示例:
输入: 1->2->3->4->5->NULL, m = 2, n = 4
输出: 1->4->3->2->5->NULL
思路：先移动到要逆序的链表处，然后逆序之后再相连，思路简单，关键是做好标记变量。
class Solution {
public ListNode reverseBetween(ListNode head, int m, int n) {
int change_len = n - m + 1;//需要逆置的节点个数
ListNode pre = null;//head结点的前驱
ListNode res = head; //返回结果
while(head!=null&&(--m!=0)){//移动到要逆置的链表头
pre = head;
head = head.next;
}
ListNode tail = head;//逆置后的链表尾
ListNode newHead = null;
while(head!=null&&(change_len!=0)){//逆置链表
ListNode Next = head.next;
head.next = newHead;
newHead = head;
head = Next;
change_len--;
}
tail.next = head; //将逆置后的链表与后面剩余的链表相连
if(pre!=null){//如果不是从头开始逆置的
pre.next = newHead;//将前面剩余的尾结点指向逆置后的新节点
}else{
res = newHead;
}
return res;
}
}链表相交
1.简单
编写一个程序，找到两个单链表相交的起始节点。
如下面的两个链表：
在节点 c1 开始相交。
示例 1：
输入：intersectVal = 8, listA = [4,1,8,4,5], listB = [5,0,1,8,4,5], skipA = 2, skipB = 3
输出：Reference of the node with value = 8
输入解释：相交节点的值为 8 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [4,1,8,4,5]，链表 B 为 [5,0,1,8,4,5]。在 A 中，相交节点前有 2 个节点；在 B 中，相交节点前有 3 个节点。
示例 2：
输入：intersectVal = 2, listA = [0,9,1,2,4], listB = [3,2,4], skipA = 3, skipB = 1
输出：Reference of the node with value = 2
输入解释：相交节点的值为 2 （注意，如果两个列表相交则不能为 0）。从各自的表头开始算起，链表 A 为 [0,9,1,2,4]，链表 B 为 [3,2,4]。在 A 中，相交节点前有 3 个节点；在 B 中，相交节点前有 1 个节点。
示例 3：
输入：intersectVal = 0, listA = [2,6,4], listB = [1,5], skipA = 3, skipB = 2
输出：null
输入解释：从各自的表头开始算起，链表 A 为 [2,6,4]，链表 B 为 [1,5]。由于这两个链表不相交，所以 intersectVal 必须为 0，而 skipA 和 skipB 可以是任意值。
解释：这两个链表不相交，因此返回 null。
注意：
如果两个链表没有交点，返回 null.
在返回结果后，两个链表仍须保持原有的结构。
可假定整个链表结构中没有循环。
程序尽量满足 O(n) 时间复杂度，且仅用 O(1) 内存。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
HashSet set = new HashSet<>();
ListNode res = null;
while(headA!=null){
set.add(headA);
headA = headA.next;
}
while(headB!=null) {
if(set.add(headB)==false) {
res = headB;
break;
}
headB = headB.next;
}
return res;
}
} 给定一个链表，判断链表中是否有环。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：true
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：true
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：false
解释：链表中没有环。
进阶：
你能用 O(1)（即，常量）内存解决此问题吗？
public class Solution {
public boolean hasCycle(ListNode head) {
boolean flg = false;
HashSet set = new HashSet<>();
while(head!=null){
if(!set.add(head)){
flg = true;
break;
}
head = head.next;
}
return flg;
}
} 给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。
说明：不允许修改给定的链表。
示例 1：
输入：head = [3,2,0,-4], pos = 1
输出：tail connects to node index 1
解释：链表中有一个环，其尾部连接到第二个节点。
示例 2：
输入：head = [1,2], pos = 0
输出：tail connects to node index 0
解释：链表中有一个环，其尾部连接到第一个节点。
示例 3：
输入：head = [1], pos = -1
输出：no cycle
解释：链表中没有环。
进阶：
你是否可以不用额外空间解决此题？
public class Solution {
public ListNode detectCycle(ListNode head) {
HashSet set = new HashSet<>();
while(head!=null){
if(!set.add(head)){
return head;
}
head = head.next;
}
return null;
}
}