🔥博客主页： 小扳_-CSDN博客
❤感谢大家点赞👍收藏⭐评论✍  

 

 

 

文章目录

        1.0 链表的创建

        2.0 链表的经典算法 - 根据值来删除节点

        2.1 根据值来删除节点 - 遍历链表来实现

        2.2 根据值来删除节点 - 递归实现

        3.0 链表的经典算法 - 删除倒数第 n 个节点

        3.1 删除倒数第 n 个节点 - 使用递归来实现

        3.2 删除倒数第 n 个节点 - 快慢指针来实现

        4.0 本篇链表的经典算法的完整实现代码

---

        1.0 链表的创建

        为了更好的讲解算法的具体内容，先创建好链表，实现一个带哨兵的单链表。

代码如下：

import java.util.Iterator;public class List implements Iterable<Integer>{private  Node hand;static class Node {public int value;public Node next;public Node() {}public Node(int value, Node next) {this.value = value;this.next = next;}}public List() {hand = new Node(0,null);}@Overridepublic Iterator<Integer> iterator() {return new Iterator<Integer>() {Node p = hand.next;@Overridepublic boolean hasNext() {return p != null;}@Overridepublic Integer next() {int value = p.value;p = p.next;return value;}};}}

        之前的篇章都有讲解过以上的每一个方法及其作用，需要了解的点击一下链接：

Java 算法篇-深入了解单链表的反转（实现：用 5 种方式来具体实现）-CSDN博客

        2.0 链表的经典算法 - 根据值来删除节点

        介绍两种方式来实现该算法：

        一、遍历链表来实现

        二、使用递归来实现

        2.1 根据值来删除节点 - 遍历链表来实现

        实现思路为：设置两个节点分别为： o1， 一开始指向哨兵节点。o2，一开始指向头节点（也就是 哨兵节点指向的节点），想让 o2 节点往后走一步，来判断当前 o2 的节点的值是否为需要的节点，若是，则让 o1 指向 o2.next 节点，然后 o2 = o1.next  接着往后走；若不是，则让 o1 = o2 完成赋值（意味着 o1 永远跟着 o2 节点后面，o2 永远比 o1 走前一步），接着 o2 = o2.next 往后走。循环终止的条件为，当 o2 == null 就该停止了。

代码如下：

    //根据值来删除节点public void removeValue( List list, int value) {Node o1 = list.hand;Node o2 = list.hand.next;while (o2 != null) {if (o2.value == value) {o1.next = o2.next;o2 = o1.next;}else {o1 = o2;o2 = o2.next;}}}

        再讲个好理解的思路：把 o1 比作战场上的大部队，把 o2 比作地雷兵，每一次往前走的时候，都需要让地雷兵先去排雷，若前方没雷时，这时候 o1 紧跟着 o2 走过的路径；若前方发现雷时，需要排除掉，以此类推，直到走完。

        2.2 根据值来删除节点 - 递归实现

        实现的思路：先把需要删除节点的链表进行递归到底进行展示出来，也就是一直递归到底，然后在回归的时候，当 p == null 说明了已经到了链表的底部了，直接返回 null 就好了。需要来判断该节点的值是否需要删除：若不需要删除的节点，在回归的时候需要返回自己的节点，然后需要更新该节点的指向。若需要删除的节点，在回归的时候直接返回 下一个节点。

代码如下：

    private Node recursion1(Node p, int value) {if (p == null) {return null;}if (p.value == value) {return recursion1(p.next, value);}else {p.next = recursion1(p.next, value);return p;}}

结合代码来具体的实现流程：

        

        3.0 链表的经典算法 - 删除倒数第 n 个节点

        介绍两种方式来实现该算法：

        一、使用递归来实现

        二、使用快慢指针来实现

        3.1 删除倒数第 n 个节点 - 使用递归来实现

        实现思路：先递出到底 p == null 返回 0 ，接着然后每一次回归都对当前的 i 进行 i++，再来判断是否 i == n，但是我们细想一下，我们得到了 i == n 这个要删除的节点是不是没有什么用，因此，我们实际需要找的节点是 n + 1，当 i == n + 1 时，就可以删除倒数第 n 个节点了 p.next = p.next.next 这样就删除了节点了。

代码如下：

    //删除倒数第 n 个节点(递归法)public List deleteCount(List list, int n) {recursion(list.hand,n);return list;}private int  recursion(Node p, int n) {if (p == null) {return 0;}int i = recursion(p.next, n);i++;if (i == n + 1) {p.next = p.next.next;}return i;}

        需要注意的是，这里一定要用带上哨兵的链表，原因是：当我要删除的节点是第一个的时候，没哨兵是完成不了这个操作的。

        3.2 删除倒数第 n 个节点 - 快慢指针来实现

        思路：先定义两个 fast、slow 快慢指针，一开的时候都指向哨兵节点，然后让 slow 先跑 n+1个节点，然后就两个指针 一起跑，循环的结束条件为： slow == null ，因为当 slow == null是，fast.next 刚好指向了要删除的节点，那么直接就用 fast.next = fast.next.next 这就把第 n 个节点删除掉了。

代码如下：

    //删除倒数第n个节点(快慢指针)public List removeFastSlowPointers(List list, int n) {list.hand = fastSlowPointers(list.hand,n);return list;}private Node fastSlowPointers(Node hand, int n) {Node temp = hand;Node fast = hand;Node slow = hand;for (int i = 0; i < n + 1; i++) {slow = slow.next;}while (slow != null) {slow = slow.next;fast = fast.next;}fast.next = fast.next.next;return temp;}

        这里需要注意的是，当要删除第 1 个节点的时候，若没有哨兵节点的时候，是完成不了这个操作的。还有需要注意的是，关于要删除第 n 个节点，实际要找到第 n+1 个节点才能对第 n 个节点进行删除。

        4.0 本篇链表的经典算法的完整实现代码

import java.util.Iterator;public class List implements Iterable<Integer>{private  Node hand;static class Node {public int value;public Node next;public Node() {}public Node(int value, Node next) {this.value = value;this.next = next;}}public List() {hand = new Node(0,null);}@Overridepublic Iterator<Integer> iterator() {return new Iterator<Integer>() {Node p = hand.next;@Overridepublic boolean hasNext() {return p != null;}@Overridepublic Integer next() {int value = p.value;p = p.next;return value;}};}//头插节点public void addFirst(int value) {hand.next = new Node(value,hand.next);}//尾插节点public void addLst(int value) {Node p = hand;while (p.next != null) {p = p.next;}p.next = new Node(value,null);}//根据值来删除节点public void removeValue( List list, int value) {Node o1 = list.hand;Node o2 = list.hand.next;while (o2 != null) {if (o2.value == value) {o1.next = o2.next;o2 = o1.next;}else {o1 = o2;o2 = o2.next;}}}//根据值来删除节点(递归实现)public List removeRecursion(List list ,int value) {Node p = list.hand.next;Node tp = recursion1(p,value);list.hand.next = tp;return list;}private Node recursion1(Node p, int value) {if (p == null) {return null;}if (p.value == value) {return recursion1(p.next, value);}else {p.next = recursion1(p.next, value);return p;}}//删除倒数第n个节点(递归法)public List deleteCount(List list, int n) {recursion(list.hand,n);return list;}private int  recursion(Node p, int n) {if (p == null) {return 0;}int i = recursion(p.next, n);i++;if (i == n + 1) {p.next = p.next.next;}return i;}//删除倒数第n个节点(快慢指针)public List removeFastSlowPointers(List list, int n) {list.hand = fastSlowPointers(list.hand,n);return list;}private Node fastSlowPointers(Node hand, int n) {Node temp = hand;Node fast = hand;Node slow = hand;for (int i = 0; i < n + 1; i++) {slow = slow.next;}while (slow != null) {slow = slow.next;fast = fast.next;}fast.next = fast.next.next;return temp;}}