Leetcode面T2(1-8)链表
Q2.1 移除重复节点
编写代码，移除未排序链表中的重复节点。保留最开始出现的节点。
示例1:
输入：[1, 2, 3, 3, 2, 1]
输出：[1, 2, 3]
示例2:输入：[1, 1, 1, 1, 2]
输出：[1, 2]
链表节点定义
public class ListNode {
//节点存储的数据
int val;
//节点的后继节点
ListNode next;
//构造方法，生成一个节点时要存入一个数据
public ListNode(int val) {
this.val = val;
}
}
方法实现
import java.util.HashSet;
import java.util.Set;
class Solution {
public ListNode removeDuplicateNodes(ListNode head) {
//pre指向当前节点的前驱
ListNode pre = null;
ListNode p = head;
Set set = new HashSet<>();
//遍历节点
while (p != null) {
//如果哈希表中已存在这个元素则删除
if (set.contains(p.val)) {
//删除，删除后前驱节点不需要往后移
pre.next = p.next;
} else {
//如果哈希表中不存在这个元素则添加进来
set.add(p.val);
//未删除，前驱节点后移
pre = p;
}
//无论是否删除都让p指向下一个待检测的节点
p = p.next;
}
return head;
}
public static void main(String[] args) {
//定义一个测试样例
int arr[] = {1, 2, 3, 3, 2, 1};
//将数组元素依次存入链表
ListNode head = new ListNode(1);
int i = 1;
ListNode p1 = head;
while (i < arr.length) {
p1.next = new ListNode(arr[i]);
p1 = p1.next;
++i;
}
//调用方法测试
new Solution().removeDuplicateNodes(head);
//输出样例的预期结果
ListNode p2 = head;
while (p2 != null) {
System.out.print(p2.val + (p2.next == null ? "" : " "));
p2 = p2.next;
}
}
}
对于进阶问题：如果不得使用临时缓冲区，该怎么解决？一种简单的方法是，我们在给定的链表上使用两重循环，其中第一重循环从链表的头节点开始，枚举一个保留的节点，这是因为我们保留的是「最开始出现的节点」。第二重循环从枚举的保留节点开始，到链表的末尾结束，将所有与保留节点相同的节点全部移除，时间复杂度为O(N^2)。
方法实现
public ListNode removeDuplicateNodes(ListNode head) {
//first节点指向每一轮比较的第一个节点
ListNode first = head;
while (first != null) {
//scanner节点为每一轮第一个节点之后的节点
//并依次与first节点比较，如果元素值相同则过滤掉
ListNode scanner = first.next;
//scanner节点的前驱节点
ListNode pre = first;
while (scanner != null) {
if (first.val == scanner.val) {
pre.next = scanner.next;
} else {
pre = scanner;
}
//让scanner指向下一个节点并与first节点比较
scanner = scanner.next;
}
//依次选取下一个节点作为第一个节点
first = first.next;
}
return head;
}
Q2.2 返回倒数第 k 个节点
实现一种算法，找出单向链表中倒数第 k 个节点。返回该节点的值。
注意：本题相对原题稍作改动
示例：
输入： 1->2->3->4->5 和 k = 2
输出： 4
解题思路
这是典型的双指针游走题目，设有两个指针 p1，p2 ：
初始时，两个指针均指向 head。
先将p2向后移动 k 次。此时p1，p2的距离为 k。
同时移动 p1，p2, 直到 p2 指向null。此时p1.val即为答案。
如下图所示：
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public int kthToLast(ListNode head, int k) {
ListNode p1 = head;
ListNode p2 = head;
int count = 1;
while (count <= k) {
p2 = p2.next;
++count;
}
while (p2 != null) {
p1 = p1.next;
p2 = p2.next;
}
return p1.val;
}
}
Q2.3 删除中间节点
实现一种算法，删除单向链表中间的某个节点（即不是第一个或最后一个节点），假定你只能访问该节点。
示例：
输入：单向链表a->b->c->d->e->f中的节点c
结果：不返回任何数据，但该链表变为a->b->d->e->f
解题思路
解法一：与后结点交换数值，然后删除后结点
思路：由于只能访问当前结点，删除元素一般需要前置结点，所以可以把当前结点的值与后结点交换再删除后结点
分析：时间复杂度是常数级，效率很快，不需要额外内存空间
//解法一：与后结点交换数值，再删除后结点
public static void test1(ListNode node) {
ListNode next_node = node.next;
//交换两个结点的值
int temp = next_node.val;
next_node.val = node.val;
node.val = temp;
//下面删除next_node
node.next=next_node.next;
//测试
/*while(node!=null){
System.out.println(node.val);
node=node.next;
}*/
}方法二：
class Solution {
public void deleteNode(ListNode node) {
//删除当前节点node ，可以删去其下一个节点，
//并将下一个节点的值赋值给当前节点
node.val = node.next.val;
node.next = node.next.next;
}
}
Q2.4 分割链表
编写程序以 x 为基准分割链表，使得所有小于 x 的节点排在大于或等于 x 的节点之前。如果链表中包含 x，x 只需出现在小于 x 的元素之后(如下所示)。分割元素 x 只需处于“右半部分”即可，其不需要被置于左右两部分之间。
示例:
输入: head = 3->5->8->5->10->2->1, x = 5
输出: 3->1->2->10->5->5->8
class Solution {
/*
这个题目的意思其实是：将所有小于 x 的节点放在 x 节点之前
例如：
[1,4,3,2,5,2] 3 -> [1, 2, 2, 3, 4, 5]
[3, 5, 8, 5, 10, 2, 1] 5 -> [1, 2, 3, 5, 5, 8, 10]
方法： 双指针
cur 为遍历的当前节点。pre 为遍从前向后第一个未交换的节点
cur 向后遍历过程总若遇到小于 x 的元素 则与pre 进行交换
*/
public ListNode partition(ListNode head, int x) {
ListNode cur = head;
ListNode pre = head;
while (cur != null) {
if (cur.val < x) {
swap(cur, pre);
pre = pre.next;
}
cur = cur.next;
}
return head;
}
public void swap(ListNode p1, ListNode p2) {
int temp = p1.val;
p1.val = p2.val;
p2.val = temp;
}
}Q2.5 链表求和
给定两个用链表表示的整数，每个节点包含一个数位。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。这些数位是反向存放的，也就是个位排在链表首部。编写函数对这两个整数求和，并用链表形式返回结果。
示例：
输入：(7 -> 1 -> 6) + (5 -> 9 -> 2)，即617 + 295
输出：2 -> 1 -> 9，即912
进阶：假设这些数位是正向存放的，请再做一遍。示例：
输入：(6 -> 1 -> 7) + (2 -> 9 -> 5)，即617 + 295
输出：9 -> 1 -> 2，即912
思路：
用递归解法，分别从两个链表的第一个节点开始，取一个值相加，相加的结果对10取模，取模得到值作为结果的一位节点。重复上述操作再从两个链表的下一位取值相加( 注 意 得 加 上 前 一 次 操 作 的 进 位 ) \color{red}{(注意得加上前一次操作的进位)}(注意得加上前一次操作的进位)，结果存入结点，通过递归将这些节点连接起来。
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode addTwoNumbers(ListNode l1, ListNode l2) {
//add为求和函数
ListNode res = add(l1, l2, 0);
return res;
}
//head1和head2分别为两个链表的第一个元素,value为上一次操作的进位
static ListNode add(ListNode head1,ListNode head2, int value) {
if (head1 == null && head2 == null) {
if (value == 1) {
//最后还有进位需要生成最后一个值为1的节点
return new ListNode(1);
} else {
//已完成最后一位的相加操作，开始逐层返回
return null;
}
}
if (head1 != null) {
//链表1要相加的那位不为空就把值加上
value += head1.val;
}
if (head2 != null) {
//链表2要相加的那位不为空就把值加上
value += head2.val;
}
//如果两个值相加后>=10就会产生进位，对10取模可得到减去进位的值
ListNode res = new ListNode(value % 10);
//如果两位相加的值小于10则没有进位，即进位为0
//如果两位相加的值>=10,则要向高位进1
//此处value值的意义变成了向高位的进位
value = value < 10 ? 0 : 1;
//此处的三目运算符功能是防止产生空指向异常，只有head1或者head2
//不为空的情况才下才有next节点
//传入的value值为向高位的进位
res.next = add(head1==null?null:head1.next, head2==null?null:head2.next, value);
return res;
}
}
Q2.6 回文链表
编写一个函数，检查输入的链表是否是回文的。
示例 1：输入： 1->2
输出： false
示例 2：输入： 1->2->2->1
输出： true
class Solution {
public boolean isPalindrome(ListNode head) {
if(head == null || head.next == null){
return true;
}
//找到链表中间点
ListNode low = head;
ListNode fast = head;
while(fast != null && fast.next != null){
low = low.next;
fast = fast.next.next;
}
if(fast != null){//说明有奇数个结点,low需要再走一步。
low = low.next;
}
//翻转后半段链表
ListNode cur = low.next;
low.next = null;
while(cur != null){
ListNode temp = cur.next;
cur.next = low;
low = cur;
cur = temp;
}
//比较前后段是否一致
while(low != null){
if(low.val != head.val){
return false;
}
low = low.next;
head = head.next;
}
return true;
}
}
Q2.7 链表相交
给定两个（单向）链表，判定它们是否相交并返回交点。请注意相交的定义基于节点的引用，而不是基于节点的值。换句话说，如果一个链表的第k个节点与另一个链表的第j个节点是同一节点（引用完全相同），则这两个链表相交。
示例 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) 内存。
总结：
1.这里是单项链表，不可能出现剪刀形状的相交。
2.这里的是的相交是下面的情况
3.让两个节点分别从一个链表的首部开始，走完一个链表重新走另外一个链表，如果相遇必然相交，因为走的路径都是AD+DC+BD
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
if(headA==null||headB==null)
{
return null;
}
ListNode p1=headA;
ListNode p2=headB;
while(p1!=p2)
{
p1=p1==null? headB:p1.next;
p2=p2==null? headA:p2.next;
}
return p1;
}
}
Q2.8 环路检测
给定一个链表，如果它是有环链表，实现一个算法返回环路的开头节点。
如果链表中有某个节点，可以通过连续跟踪 next 指针再次到达，则链表中存在环。 为了表示给定链表中的环，我们使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。 如果 pos 是 -1，则在该链表中没有环。注意：pos 不作为参数进行传递，仅仅是为了标识链表的实际情况。
示例 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 boolean isRinged(Node head){
if(head == null){
return false;
}
Node slow = head;
Node fast = head;
while(fast.next != null && fast.next.next != null){
slow = slow.next;
fast = fast.next.next;
if(fast == slow){
return true;
}
}
return false;
}Q2.9 给定一个有环链表，实现一个算法返回环路的开头结点
(1)创建两个指针：FastPointer和SlowPointer。
(2)SlowPointer每走一步，FastPointer就走两步。
(3)两者碰在一起时，将SlowPointer指向LinkedListHead，FastPointer保持不变。
(4)以相同速度移动SlowPointer和FastPointer，一次一步，然后返回新的碰撞处。
LinkedListNode findBegining(LinkedListNode head) {
LinkedListNode slow = head;
LinkedListNode fast = head;
/*找出碰撞处，将处于链表中LOOP_SIZE-k步的位置*/
while(fast != null && fast.next != null) {
slow = slow.next;
fast = fast.next.next;
if(slow == fast) { // 碰撞
break;
}
}
/*错误检查，没有碰撞处，也即没有回路*/
if(fast == null || fast.next == null) {
return null;
}
/*将slow指向首部，fast指向碰撞处，两者距离环路
*起始处k步，若两者以相同速度移动，则必定会在环
*路起始处碰在一起*/
slow = head;
while(slow != fast) {
slow = slow.next;
fast = fast.next;
}
/*至此两者均指向环路起始处*/
return fast;
}参考：https://blog.csdn.net/universe_ant/article/details/70215648