链表部分
通用操作
-
链表的两种操作方式
不用虚拟头结点 用虚拟头节点
-
为什么要定义cur指针
因为操作完链表以后，是要返回头节点的。 如果你上来就操作头节点，那么头节点的值都改了，返回head就不是我们最开始的链表了。
-
写while循环的时候，只要考虑清楚极端条件就可以了
考虑清楚头结点和尾节点的判断条件 当处理的是头结点的时候考虑：1.会不会出现空指针。2.操作的是不是头结点
-
尾部节点的判断条件
cur.next==null; -- 表示当前指针已指向尾部节点 while(cur.next!=null) -- 表示如果循环没有到尾部节点，就一直进行循环
-
指针指向下一个节点
cur=cur.next;
-
如果要操作当前节点，一定要能获取到前一个节点指针位置
-
节点定义和单链表定义
class MyLinkedList {
int size;
ListNode head;
...
}
class ListNode {
int val;
ListNode next;
public ListNode(int val) {
this.val = val;
}
}-
寻找到操作节点前一个节点的指针代码（带头结点）
for (int i = 0; i < index; i++) {//如果是不带头结点，i初始值从1开始
pred = pred.next; //pred最开始指向虚拟节点，循环结束后，pred已指向前一个节点
}
-
寻找到操作节点指针代码（和上面的区别在于<=）（带头结点）
for (int i = 0; i <= index; i++) {//如果是不带头结点，i初始值从1开始
pred = pred.next; //pred最开始指向虚拟节点，循环结束后，pred已指向当前节点
}
-
获得链表的长度
ListNode curA = headA; // headA为链表实际头结点
int lenA = 0;
while (curA != null) { // 求链表A的长度
lenA++;
curA = curA.next;
}力扣203.移除表元素
关键点：
-
如果cur.next==val，移除。否则cur向后移动一位，注意是否则！
-
如果cur=cur.next写在if外面，那么如果cur.next==val时，cur会移动两位，到最后一个元素就会报空指针
-
class Solution {
public ListNode removeElements(ListNode head, int val) {
//输入：head = [1,2,6,3,4,5,6], val = 6
//输出：[1,2,3,4,5]
ListNode dummyNode=new ListNode(-1);
dummyNode.next=head;
ListNode cur=dummyNode;
while(cur.next!=null){
if(cur.next.val==val){
cur.next=cur.next.next;
}else{
cur=cur.next;
}
}
return dummyNode.next;
}
}力扣707.设计链表
删除节点
-
要删除第n个节点，cur指向前一个节点，第n个节点一定是cur.next。
不是cur，因为如果你第n个节点是cur，那你又怎么知道你前一个节点呢？
-
删除中间某个节点
我们通过操作cur来删掉
cur指向前一个节点 cur.next指向第n个节点（当前要删的节点） 通过cur.next=cur.next.next，这样就把cur指针的下一个节点（cur.next,即n节点）就删掉了
-
如果删除节点的同时要改变链表的长度
要size--
-
如果直接删除头节点
head=head.next;
class Solution {
public ListNode removeElements(ListNode head, int val) {
//输入：head = [1,2,6,3,4,5,6], val = 6
//输出：[1,2,3,4,5]
ListNode dummyNode=new ListNode(-1);
//将虚拟节点和头结点关联起来
dummyNode.next=head;//这句很关键
ListNode cur=dummyNode;
while(cur.next!=null){
if(cur.next.val==val){
cur.next=cur.next.next;
}else{
cur=cur.next;
}
}
return dummyNode.next;
}
}插入节点
-
插入，一定要先new出新节点newNode
-
指针改变的顺序：一定是先更新newNode指向第n个节点的指针，再更新cur指向第n个节点的指针。
如果是在头结点插入，插入顺序： newNode.next=dummyNode.next; -- 1. dummyNode.next=newNode; -- 2. -- 注意:1和2的顺序一定不能反了 如果不在头结点插入，插入顺序： newNode.next=cur.next; -- 1. cur.next=newNode; -- 2. -- 注意:1和2的顺序一定不能反了 否则如果先将cur的指针指向newNode节点，那就丢了cur.next指针（即n节点）的位置，newNode就无法指向n节点了
-
在第n个节点前插入新节点，一定要能获取到该节点的前一节点的指针
第n个节点用cur.next表示
-
如果增加节点的改变链表长度要做size++
完整代码
注意，下面是3个常出错的点：
get方法中 if(index<0 || index>=size){...} 这里一定是>=，因为从0开始，走不到size，当index==size时会报空指针异常
get方法中的for循环，注意是i<=index，因为当i=0是，依旧执行循环，cur从虚拟头指向真正第一个节点
deleteAtIndex方法中 if(index>=size){..} ，同样是>=，因为也index==size时，指针同样也指向null
定义节点时，构造函数不要忘了 ListNode(int val){ this.val=val;}
class MyLinkedList {
//定义链表头节点和长度
int size;
ListNode head;
public MyLinkedList() {
//初始化链表头结点和长度
head=new ListNode(0);
size=0;
}
public int get(int index) {
//对index进行合法性判断
if(index<0 || index>=size){
return -1;
}
ListNode cur=head;
//先将指针移动到要操作的当前节点
for(int i=0;i<=index;i++){
cur=cur.next;
}
return cur.val;
}
public void addAtHead(int val) {
addAtIndex(0,val);
}
public void addAtTail(int val) {
addAtIndex(size,val);
}
public void addAtIndex(int index, int val) {
//先判断index合法性
if(index<0 || index>size){//这因为节点从0开始，size其实不在节点里，但在插入操作时，如果cur指向size，插入是合理的
return;
}
size++;
ListNode cur=head;
for(int i=0;i<index;i++){//这才是将指针遍历到操作节点的前一个
cur=cur.next;
}
//造个要插入的新节点
ListNode addNode=new ListNode(val);
addNode.next=cur.next;
cur.next=addNode;
}
public void deleteAtIndex(int index) {
//先判断index合法性
if(index>=size){//这因为节点从0开始，size其实不在节点里，但在插入操作时，如果cur指向size，插入是合理的
return;
}
size--;
//如果index小于0，删除就删除头结点
index=Math.max(0,index);
ListNode cur=head;
for(int i=0;i<index;i++){//这才是将指针遍历到操作节点的前一个
cur=cur.next;
}
//这里的特殊情况：如果index=0，删除头结点，不满足上面for循环，此时cur依然是dummyNode
cur.next=cur.next.next;
}
}
class ListNode {
//定义存储内容和指针
int val;
ListNode next;
ListNode(int val){ //这个每次不要忘了
this.val=val;
}
}力扣206.反转链表操作
有双指针和递归两种操作方法
关键点：
-
要用temp保存cur.next，否则下次操作找不到下一节点
-
向后移动两个指针，应该是pre=cur在前，cur=temp在后
-
如果cur=temp在前，pre和cur就指向的是同一个位置了（死循环了）
-
-
循环结束后，cur指向null，pre指向最后一次反转的节点(头结点)，因此返回pre就行
双指针解法
class Solution {
public ListNode reverseList(ListNode head) {
//初始化两个指针
ListNode cur=head;//指向头结点
ListNode pre=null;//指向空指针
//pre.next=cur;这行代码是错的，因为pre已经是空了，再对其进行操作就会报空指针异常
while(cur!=null){
ListNode tmp=cur.next;
//关键代码
//1.必须给个临时节点tmp用于存cur.next
tmp=cur.next;
//2.翻转指针(每次指向前一位，这样每次都将当前节点指针有后指向了前)
cur.next=pre;
//3.将cur和pre都后移一位，下面这两行代码顺序不能反了
pre=cur;
cur=tmp;
}
return pre;
}
}力扣24.两两交换链表中的节点
关键点：
-
要做操作两个节点，需要每次将指针指向这两个节点的前一个节点
-
dummyNode先指向第二个节点后，再用第二个节点指向第一个节点时，第二个节点这样表示：cur.next。注意不是cur.next.next
-
要将第一，三两个节点用两个临时指针temp和temp1保存起来
-
因为dummy指向节点2时，就已经找不到节点了
-
节点2指向节点时，就已经找不到节点3了
-
双指针解法
class Solution {
public ListNode swapPairs(ListNode head) {
//造虚拟头结点
ListNode dummyNode=new ListNode(-1);
dummyNode.next=head;
ListNode cur=dummyNode;
//循环，奇偶节点都要判断
while(cur.next!=null && cur.next.next!=null){
//保存两个临时节点
ListNode temp=cur.next;//保存第一个节点
ListNode temp1=cur.next.next.next;//保存第三个节点
//虚拟头节点先指向节点2
cur.next=cur.next.next;
//再将节点2指针指向节点1
cur.next.next=temp;//注意注意：此时节点2已变为cur.next，cur.next.next表示2节点的指针，它指向1节点
//再将节点1的指针指向节点3
temp.next=temp1;//temp是1节点
//此时cur还并没有动，依旧指向dummyNode节点（前面操作的都是cur.next或cur.next.next，并未直接操作cur），将cur往后移动2位
//移动两位以后，cur指针依旧指向下次要操作的两个节点的前一个节点
cur=cur.next.next;//此时一轮循环结束，改变了两个节点指针的指向。后面每两个指针进行相同操作
}
//返回dummyNode的next
return dummyNode.next;
}
}递归解法
class Solution {
public ListNode reverseList(ListNode head) {
return reverse(null,head);//对应双指针中赋初始值：cur=head;prev=null
}
private ListNode reverse(ListNode prev, ListNode cur) {
if(cur==null){
return prev;
}
ListNode temp=cur.next;
cur.next=prev;//反转指针
return reverse(cur,temp);//对应双指针中给双指针各向后移动一位：pre=cur;cur=temp
}
}力扣19.删除链表的倒数第 N 个结点
关键点：
-
dummyNode.next=head;//不关联会报操作空指针异常
-
快指针和慢指针距离差n个节点
-
这样快指针指向null时，慢节点正好指向操作的前一节点
-
双指针解法
class Solution {
public ListNode removeNthFromEnd(ListNode head, int n) {
//输入：head = [1,2,3,4,5], n = 2
//输出：[1,2,3,5]
ListNode dummyNode=new ListNode(-1),cur=dummyNode;
dummyNode.next=head;
//快慢指针同时指向头结点
ListNode fast=dummyNode;
ListNode slow=dummyNode;
//先让快指针移动n个节点
for(int i=0;i<=n;i++){
fast=fast.next;
}
//再让快慢指针同时开始向后移动节点
while(fast!=null){
fast=fast.next;
slow=slow.next;
}
//此时的slow指向删除节点的前一节点
slow.next=slow.next.next;
//返回虚拟头节点的next
return dummyNode.next
}
}力扣160.链表相交
下面这个视频讲的不错的
[160. 相交链表 | 手写图解版思路 + 代码讲解] https://www.bilibili.com/video/BV1xS4y1v7pp/?spm_id_from=333.337.search-card.all.click&vd_source=3c0c84befaea55842fa8622aa89e5300
关键点：
-
要让两个链表走过相同长度
-
三元运算符
-
判断条件要用变量接收，不能直接写p==null?
-
public class Solution {
public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
ListNode p=headA,q=headB;
//本题关键思路：p和q要走过相同的长度
while(p!=q){//p和q不相等时，两个指针同时向后移动
//关键代码：
//三元运算：p(q)此时是否走到空（末尾），如果没有，继续往下走。走到末尾，p(q)的指针指向另一个链表的头结点位置
p=p==null?headB:p.next;
q=q==null?headA:q.next;
} // while循环结束时，保证了两个链表一定会走过相同距离。
//当走过相同距离时，看它两指针指向的是什么。
//如果是null，表示两节点不想交。
//如果指向某个内存地址，表示两个节点在该处相交。此时返回任意指针即可。
return p;
}
}力扣142.环形链表||
-
思路
环形链表需要先定义一快一慢两个指针，，然后循环[终止条件：快指针没有走到null]，快指针一次走两格，慢指针一次走一格。然后是关键：看快慢指针是否会相等[即走到一起，此刻已说明该链表是个环形链表]，如果会，再定义一个临时指针指向头节点，一个临时指针指向此刻相交节点[fast，slow都行]。然后在子循环中让两个临时指针再每次以相同步速向后移动[此时的终止条件也是返回条件，即任意一个临时指针，即环链表的入口]，然后这个临时指针即可。 如果外层循环结束后，仍然没有返回临时指针，说明该链表不是环链表，返回null。
关键点：
-
在链表中，有一个指针cur指向当前节点，如果节点下一位不为空，但下下一位为空，那么cur.next.next会报空指针异常么
如果 cur.next 不为空（即 cur 的下一个节点存在），那么你可以安全地访问 cur.next.next（即 cur 的下下个节点）。“节点下一位不为空，但下下一位为空”，这意味着 cur.next 存在但 cur.next.next 为 null。这种情况下，尝试访问 cur.next.next 不会报空指针异常，因为它只是返回一个 null 值，表示没有下下个节点。但是，如果你尝试对 cur.next.next 进行某些操作（比如解引用它），并且没有检查它是否为 null，那么可能会导致空指针异常。 如果 cur.next 为空（即 cur 的下一个节点不存在），那么尝试访问 cur.next.next 将会导致空指针异常，因为 cur.next 是 null，【你不能在 null 上调用 .next。】
-
while(fast!=null && fast.next!=null){...}
加粗红色的这个也要加，因为如果链表本身为空，对null.next会报空指针异常
/**
* Definition for singly-linked list.
* class ListNode {
* int val;
* ListNode next;
* ListNode(int x) {
* val = x;
* next = null;
* }
* }
*/
public class Solution {
public ListNode detectCycle(ListNode head) {
ListNode fast=head;
ListNode slow=head;
while(fast!=null && fast.next!=null){
fast=fast.next.next;
slow=slow.next;
if(fast==slow){
ListNode index1=fast;
ListNode index2=head;
while(index1!=index2){
index1=index1.next;
index2=index2.next;
}
return index1;
}
// return null;这行代码不能加，因为如果快慢指针不想等，外面这一层循环还没走完
}
return null;
}
}
1077
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
