金典链表算法题（Java实现，简单详细）+题目链接

目录

力扣21. 合并两个有序链表

力扣203. 移除链表元素

力扣206. 反转链表

力扣876. 链表的中间结点

剑指 Offer 22. 链表中倒数第k个节点

剑指 Offer II 027. 回文链表

---

力扣21. 合并两个有序链表

题目：将两个升序链表合并为一个新的 升序 链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。 

题目链接：21. 合并两个有序链表 - 力扣（Leetcode）

本题思路就是创造一个哨兵结点，然后比较list1和list2结点所对应的值，小的那一个结点的值就插到哨兵后面，一旦有链表为空，停止循环，然后看哪个链表不为空，不为空的肯定是比前面要大的，所以直接把这个条剩下的链表查到新链表后面

最后，因为哨兵结点的数据是无效值，所以应返回哨兵结点.next

代码实现：

class Solution {
    public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode head=new ListNode(-1);
        ListNode cur = head;
        while (list1!=null&&list2!=null){
            if (list1.val>=list2.val){
                cur.next=list2;
                list2=list2.next;
            }else {
                cur.next=list1;
                list1=list1.next;
            }
            cur=cur.next;
        }
        if (list1!=null){
            cur.next=list1;
        }else {
            cur.next=list2;
        }
        return head.next;
    }
}

力扣203. 移除链表元素

题目：给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。

题目链接：203. 移除链表元素 - 力扣（Leetcode）

本题是采用了双指针的思想，保存前一个结点和当前结点，便于删除，先比较head后面的结点是否为要删除的值，如果为要删除的值，前面结点的下一个指向修改为被删除结点的下一个结点

最后比较head结点的值是否为要被删除的值，如果是就直接指向head.next，还有，思考要全面，不要忘了head为空的情况噢。

代码实现：

class Solution {
    public ListNode removeElements(ListNode head, int val) {
        if (head==null){
            return null;
        }
        ListNode p=head;
        ListNode q=p.next;
        while (q!=null){
            if (q.val==val){
                p.next=q.next;

            }else {
                p = q;
            }
            q = p.next;
        }
        if (head.val==val){
            head=head.next;
        }
        return head;
    }
}

力扣206. 反转链表

题目：给你单链表的头节点 head ，请你反转链表，并返回反转后的链表。

题目链接：206. 反转链表 - 力扣（Leetcode）

话不多说，首先上图

 

本题就是不断利用头插法去反转链表

假设有这么个链表，利用cur把head的下一个结点保存下来，然后把head置空，保存cur的下一个结点，把cur用头插法插入到head的前面，然后更新头节点，把cur往后移，temp往后移，不断重复，当cur为空的时候，循环也就停止了

最后不要忘记考虑只有一个结点的或者为空的链表噢

 代码实现：

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head==null) {
            return null;
        }
        if(head.next==null){
            return head;
        }
        ListNode cur=head.next;
        head.next=null;
        ListNode temp;
        while (cur!=null){
            temp=cur.next;
            cur.next=head;
            head=cur;
            cur=temp;
        }
        return head;
    }
}

力扣876. 链表的中间结点

题目： 给定一个头结点为 head 的非空单链表，返回链表的中间结点。如果有两个中间结点，则返回第二个中间结点。

题目链接：876. 链表的中间结点 - 力扣（Leetcode）

本题是利用了快慢指针的思想，定义一个快指针，一个慢指针，快指针每次走两个长度，慢指针每次走一个长度，当快指针不为空且下一个也不为空时，快指针走两个长度，慢指针走一个长度，最后返回慢指针所指向的结点，不论结点数量为奇数还是偶数，都可以实现

代码实现：

class Solution {
    public ListNode middleNode(ListNode head) {
        if (head==null){
            return null;
        }
        if (head.next==null){
            return head;
        }
        ListNode fast=head;
        ListNode slow=head;
        while (fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        }
        return slow;
    }
}

剑指 Offer 22. 链表中倒数第k个节点

题目：输入一个链表，输出该链表中倒数第k个节点。为了符合大多数人的习惯，本题从1开始计数，即链表的尾节点是倒数第1个节点。

例如，一个链表有 6 个节点，从头节点开始，它们的值依次是 1、2、3、4、5、6。这个链表的倒数第 3 个节点是值为 4 的节点。

题目链接：剑指 Offer 22. 链表中倒数第k个节点 - 力扣（Leetcode）

本题思路：也是利用了快慢指针的思想

1. 先让fast走k-1步，2. fast走完之后和slow一步一步走，3. 当fast.next为空的时候，slow所指的位置就是倒数第k个

别忘了先要判断k的合法性噢~

如下图，k=2，即我们要找值为4的结点，

也就是说，fast向前走一步，然后fast和slow要同时往后走

 直到fast.next为空的时候，slow指向在值为4的结点，正是本题中需要找的倒数第k结点

 代码实现：

class Solution {
    public ListNode getKthFromEnd(ListNode head, int k) {
        if(k<=0){
            return null;
        }
        ListNode fast=head;
        ListNode slow=head;
        while(k-1!=0){
            fast=fast.next;
            k--;
        }
        while(fast.next!=null){
            fast=fast.next;
            slow=slow.next;
        }
        return slow;
    }
}

剑指 Offer II 027. 回文链表

题目： 给定一个链表的 头节点 head ，请判断其是否为回文链表。如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。

题目链接：剑指 Offer II 027. 回文链表 - 力扣（Leetcode）

这个放一个小小的预告，下期讲这题，先把代码放在这

代码实现：

class Solution {
    public boolean isPalindrome(ListNode head) {
        if(head==null){
            return false;
        }
        if(head.next==null){
            return true;
        }
        ListNode fast=head;
        ListNode slow=head;
        while(fast!=null&&fast.next!=null){
            fast=fast.next.next;
            slow=slow.next;
        
        }
        ListNode cur=slow.next;
        while(cur!=null){
            ListNode curNext=cur.next;
            cur.next=slow;
            slow=cur;
            cur=curNext;
        }
        while(slow!=fast){
            if(slow.val!=head.val){
                return false;
            }
            if(head.next==slow){
                return true;
            }
            slow=slow.next;
            head=head.next;
        }
        return true;
    }
}

关注我，下期更精彩