（最新版2022版）剑指offer之链表题解

于 2022-10-23 18:25:46 发布
阅读量362 收藏 1
点赞数 2
分类专栏： LeetCode 文章标签： 链表 数据结构 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51405802/article/details/127477869
版权

（最新版2022版）剑指offer之链表题解

1、《剑指offer》JZ6从尾到头打印链表

题目描述：

输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。

解题思路：

(三种方法：借助栈、递归、列表的首位插入)

从头到尾打印链表比较简单，从尾到头很自然的可以想到先将链表进行反转，然后再打印。但是，通常我们不希望改变原链表的结构，这是一个只读操作。

因此，我们进一步分析，可以发现排在后面的先输出，这是一个典型的“后入先出”的思想，因此很自然的可以想到用栈来实现，每遍历一个结点，可以将其压入栈中，遍历结束后再逐个弹栈，将结点值存入ArrayList，这样就实现了从尾到头的打印。

更进一步，既然想到了用栈，那一定可以通过递归来实现。每访问到一个结点，先递归输出其后的结点，在输出该结点自身即可。

另外，当我们使用Java或者python语言时，有一种比较巧妙的方法就是使用列表的插入方法，每次插入数据，都总是插入到首位，这样得到的List就是从尾到头的链表序列。

编程实现（Java）：

/**
*    public class ListNode {
*        int val;
*        ListNode next = null;
*
*        ListNode(int val) {
*            this.val = val;
*        }
*    }
*
*/
import java.util.ArrayList;
public class Solution {
    public ArrayList<Integer> printListFromTailToHead(ListNode listNode) {
        ArrayList<Integer> list = new ArrayList<>();

        if (listNode == null) {
            return list;
        }

        ListNode pre = null;
        ListNode cur = listNode;
        ListNode temp = cur.next;

        while (cur != null) {
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }

        while (pre != null) {
            list.add(pre.val);
            pre = pre.next;
        }

        return list;
    }
}

2、《剑指offer》JZ22链表中倒数最后k个结点

题目描述：

输入一个链表，输出该链表中倒数第k个结点。为了符合习惯，从1开始计数，即链表的尾结点是倒数第1个节点。例如，一个链表有6个结点，从头结点开始，它们的值依次是1,2,3,4,5,6。则这个链表倒数第三个结点是值为4的结点。

解题思路：

对于单链表来说，没有从后向前的指针，因此一个直观的解法是先进行一次遍历，统计出链表中结点的个数n，第二次再进行一次遍历，找到第n-k+1个结点就是我们要找的结点，但是这需要对链表进行两次遍历。

为了实现一次遍历，我们这里采用双指针解法。我们可以定义两个指针，第一个指针从链表的头指针开始先向前走k步，第二个指针保持不动，从第k+1步开始，第二个指针也从头开始前进，两个指针都每次前进一步。这样，两个指针的距离都一直保持在k，当快指针（走在前面的）到达null时，慢指针（走在后面的）正好到达第k个结点。注意：要时刻留意空指针的判断。

举例：
在这里插入图片描述
编程实现：

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param pHead ListNode类 
     * @param k int整型 
     * @return ListNode类
     */
    public ListNode FindKthToTail (ListNode pHead, int k) {
        // write code here
        if(pHead == null){
           return null; 
        }

        int n = 0;
        ListNode cur = pHead;
        while(cur != null){
            n++;
            cur = cur.next;
        }

        if(n < k){
            return null;
        }
        for(int i = 0; i < n - k; i++){
            pHead = pHead.next;
        }

        return pHead;
    }
}

3、《剑指offer》JZ24反转链表

题目描述：

输入一个链表，反转链表后，输出新链表的表头。

解题思路：

本题比较简单，有两种方法可以实现：（1）三指针。使用三个指针，分别指向当前遍历到的结点、它的前一个结点以及后一个结点。将指针反转后，三个结点依次前移即可。（2）递归方法。同样可以采用递归来实现反转。将头结点之后的链表反转后，再将头结点接到尾部即可。

编程实现（Java）：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode ReverseList(ListNode head) {
        if(head == null){
            return null;
        }

        ListNode pre = null;
        ListNode cur = head;
        ListNode temp = cur.next;

        while(cur != null){
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }

        return pre;
    }
}

4、《剑指offer》JZ25合并两个排序的链表

题目描述：

输入两个单调递增的链表，输出两个链表合成后的链表，当然我们需要合成后的链表满足单调不减规则。

解题思路：

首先需要判断几个特殊情况，即判断输入的两个指针是否为空。如果第一个链表为空，则直接返回第二个链表；如果第二个链表为空，则直接返回第一个链表。如果两个链表都是空链表，合并的结果是得到一个空链表。

两个链表都是排序好的，我们只需要从头遍历链表，判断当前指针，哪个链表中的值小，即赋给合并链表指针，剩余的结点仍然是排序的，所以合并的步骤和之前是一样的，所以这是典型的递归过程，用递归可以轻松实现。

举例：
在这里插入图片描述
编程实现（Java)：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode Merge(ListNode list1, ListNode list2) {
        ListNode dummy = new ListNode(-1);
        ListNode pre = dummy;
        while (list1 != null && list2 != null) {
            if (list1.val < list2.val) {
                pre.next = list1;
                list1 = list1.next;
            } else {
                pre.next = list2;
                list2 = list2.next;
            }
            pre = pre.next;
        }

        if (list1 != null) {
            pre.next = list1;
        }

        if (list2 != null) {
            pre.next = list2;
        }

        return dummy.next;
    }
}

5、《剑指offer》JZ35复杂链表的复制

题目描述：

输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）。

解题思路：

本题有以下三种解法：

第一种：先按照next复制，然后依次添加random指针，添加时需要定位random的位置，定位一次需要一次遍历，需要O（n^2）的复杂度。

第二种：先按照next复制，然后用一个hashmap保存原节点和复制后节点的对应关系，则用O（n）的空间复杂度使时间复杂度降到了O（n）。

第三种（最优方法）：同样先按next复制，但是把复制后的节点放到原节点后面，则可以很容易的添加random，最后按照奇偶位置拆成两个链表，时间复杂度O（n），不需要额外空间。

举例：
在这里插入图片描述

/*
public class RandomListNode {
    int label;
    RandomListNode next = null;
    RandomListNode random = null;

    RandomListNode(int label) {
        this.label = label;
    }
}
*/
import java.util.HashMap;
public class Solution {
    public RandomListNode Clone(RandomListNode pHead) {
        if(pHead == null){
            return null;
        }

        HashMap<RandomListNode,RandomListNode> map = new HashMap<>();
        RandomListNode head = pHead;
        while(head != null){
            RandomListNode node = new RandomListNode(head.label);
            map.put(head,node);
            head = head.next;
        }

        head = pHead;
        while(head != null){
            RandomListNode node = map.get(head);
            node.next = map.get(head.next);
            node.random = map.get(head.random);
            head = head.next;
        }

        return map.get(pHead);
    }
}

6、《剑指offer》JZ52两个链表的第一个公共结点

题目描述：

输入两个链表，找出它们的第一个公共结点。

解题思路：

本题首先可以很直观的想到蛮力法，即对链表1(假设长度为m)的每一个结点，遍历链表2(假设长度为n)，找有没有与其相同的结点，这显然复杂度为O(mn)。

进一步考虑，我们可以得到以下三种改进的解法：

方法一：借助辅助栈。我们可以把两个链表的结点依次压入到两个辅助栈中，这样两个链表的尾结点就位于两个栈的栈顶，接下来比较两个栈顶的结点是否相同。如果相同，则把栈顶弹出继续比较下一个，直到找到最后一个相同的结点。此方法也很直观，时间复杂度为O(m+n)，但使用了O(m+n)的空间，相当于用空间换区了时间效率的提升。

方法二：将两个链表设置成一样长。具体做法是先求出两个链表各自的长度，然后将长的链表的头砍掉，也就是长的链表先走几步，使得剩余的长度与短链表一样长，这样同时向前遍历便可以得到公共结点。时间复杂度为O(m+n)，不需要额外空间。

方法三：将两个链表拼接起来。 将两个链表进行拼接，一个链表1在前链表2在后，另一个链表2在前链表1在后，则合成的两个链表一样长，然后同时遍历两个链表，就可以找到公共结点，时间复杂度同样为O(m+n)。

举例：
在这里插入图片描述
编程实现（Java）：

/*
public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Solution {
    public ListNode FindFirstCommonNode(ListNode pHead1, ListNode pHead2) {
        int len1 = getLength(pHead1);
        int len2 = getLength(pHead2);
        if (len1 > len2) {
            int n = len1 - len2;
            for (int i = 0; i < n; i++) {
                pHead1 = pHead1.next;
            }
            while (pHead1 != pHead2) {
                pHead1 = pHead1.next;
                pHead2 = pHead2.next;
            }
        } else {
            int n = len2 - len1;
            for (int i = 0; i < n; i++) {
                pHead2 = pHead2.next;
            }
            while (pHead1 != pHead2) {
                pHead1 = pHead1.next;
                pHead2 = pHead2.next;
            }
        }

        return pHead1;
    }

    public int getLength(ListNode head) {
        int n = 0;
        while (head != null) {
            n++;
            head = head.next;
        }
        return n;
    }
}

7、《剑指offer》JZ23链表中环的入口结点

题目描述：

给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null。

解题思路：

本题是一个比较典型的链表题目，难度适中。首先，对于大多人来说，看到这道题是比较开心的，因为判断一个链表是否存在环的方法，基本上大家都知道，就是快慢指针法，但是再仔细一看，本题除了判断是否有环之外，还要找到这个环的入口点，这就略有些复杂了。

具体思路如下：

第一步：确定一个链表是否有环。这一步就是快慢指针法，定义两个指针，同时从链表的头结点出发，快指针一次走两步，慢指针一次走一步。如若有环，两个指针必定相遇，也就是如果快指针反追上了慢指针，说明存在环（这里要注意，两指针相遇的地方一定在环中，但不一定是环的入口），如果快指针走到了链表的末尾（指向了NULL），则说明不存在环。

第二步：找到环的入口点。这还是可以利用双指针来解决，两个指针初始都指向头结点，如果我们可以知道环中的结点个数，假设为n，那么第一个指针先向前走n步，然后两个指针（另一个从头结点开始）同时向前，当两个指针再次相遇时，他们的相遇点正好就是环的入口点。

这其实并不难理解，假设链表中共有m个结点，环中有n个结点，那么除环以外的结点数就是m-n，第一个指针先走了n步，然后两个指针一起向前，当他们一起向前m-n步时，第一个链表正好走完一遍链表，返回到环的入口，而另一个指针走了m-n步，也正好是到了环的入口。

现在，我们还有一个关键的问题：如何知道链表中的环包含了几个结点呢？也就是，怎么求这个n。

实际上这也不难，在第一步中，我们提到：快慢指针相遇的地方一定在环中，并且通过第一步我们已经找到了这个位置，接下来，只要从这个相遇的结点出发，一边移动一边计数，当它绕着环走一圈，再次回到这个结点时，就可以得到环中的结点数目n了。

举例：
在这里插入图片描述
编程实现（Java）：

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        if (pHead == null || pHead.next == null) {
            return null;
        }

        ListNode fast = pHead;
        ListNode slow = pHead;
        boolean flag = false;
        while (fast != null && fast.next != null) {
            fast = fast.next.next;
            slow = slow.next;
            if (fast == slow) {
                flag = true;
                break;
            }

        }

        if (!flag) {
            return null;
        } else {
            int n = 1;
            fast = fast.next;
            while (fast != slow) {
                n++;
                fast = fast.next;
            }
            fast = pHead;
            slow = pHead;
            for (int i = 0; i < n; i++) {
                fast = fast.next;
            }
            while (fast != slow) {
                fast = fast.next;
                slow = slow.next;
            }
        }
        return fast;
    }
}

8、《剑指offer》JZ76删除链表中重复的结点

题目描述：

在一个排序的链表中，存在重复的结点，请删除该链表中重复的结点，重复的结点不保留，返回链表头指针。 例如，链表1->2->3->3->4->4->5 处理后为 1->2->5。

解题思路：

关于链表的大多数题目还是比较简单的，本题也并不太难。

删除重复结点，也就是如果当前结点和下一个结点的值相同，那么就是重复的结点，都可以被删除，为了保证删除之后的链表的连通性，在删除之后，要把当前结点前面的结点和下一个没有重复的结点链接起来，为此，程序需要记录当前的最后一个不重复结点，即程序中的pre。重点在于：一定要确保当前链接到链表中的一定是不会再重复的结点，具体见代码实现。

关于第一个结点如果重复怎么办的问题，我们不用单独考虑，可以使用链表中一贯的做法，加一个头结点即可。

具体思路看代码比较直观，参考如下的代码实现。

举例：
在这里插入图片描述
编程实现（Java）：

/*
 public class ListNode {
    int val;
    ListNode next = null;

    ListNode(int val) {
        this.val = val;
    }
}
*/
public class Solution {
    public ListNode deleteDuplication(ListNode pHead) {
        if (pHead == null) {
            return null;
        }

        ListNode head = new ListNode(0);
        head.next = pHead;
        ListNode cur = head;
        ListNode temp = cur.next;

        while (temp != null) {
            if (temp.next != null && temp.val == temp.next.val) {
                while (temp.next != null && temp.val == temp.next.val) {
                    temp = temp.next;
                }
                temp = temp.next;
                cur.next = temp;
            } else {
                cur = cur.next;
                temp = temp.next;
            }
        }

        return head.next;
    }
}

9、《剑指offer》JZ18删除链表的节点

import java.util.*;

/*
 * public class ListNode {
 *   int val;
 *   ListNode next = null;
 *   public ListNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param head ListNode类 
     * @param val int整型 
     * @return ListNode类
     */
    public ListNode deleteNode (ListNode head, int val) {
        // write code here
        if(head == null){
            return null;
        }

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

        ListNode cur = head;
        ListNode temp = cur.next;

        while(temp != null){
            if(temp.val == val){
                cur.next = temp.next;
            }
            cur = temp;
            temp = temp.next;
        }

        return head;
    }
}
见面吃火锅
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
剑指offer——链表
happy_Jianghui的博客
06-19 163
链表算法
剑指offer题解(C++).docx
07-17
《剑指Offer题解》是针对面试准备的一份宝贵资源，由Sidney.Tan精心整理，结合了牛客网上的讨论、《剑指Offer》书中的解法以及个人的编程实践，提供了全面的代码和思路解析。这份文档按照牛客网上的题目顺序，覆盖了...
<剑指offer>之链表题目
leo_lou
09-13 1964
【引言】    这几天在看写的很好，跟July的各有千秋，更加注重归纳总结，笔试面试临时抱佛脚，决定要啃下这其中的46道题目。OK，把每道题目自己实现，相同的归成一类。这次把所有的与list相关的题目列出来。 【题目5】从尾到头打印list //思路：从尾到头打印list的话，考虑用stack先把各节点保存起来，遍历完以后再将stack弹出打印即可 #include void print
剑指offer之链表
最新发布
如月之恒，如日之升
08-20 181
个人学习
剑指offer-链表
qq_41784433的博客
10-16 130
文章目录[剑指 Offer 06. 从尾到头打印链表 - 力扣（LeetCode） (leetcode-cn.com)](https://leetcode-cn.com/problems/cong-wei-dao-tou-da-yin-lian-biao-lcof/)[剑指 Offer 22. 链表中倒数第k个节点 - 力扣（LeetCode） (leetcode-cn.com)](https://leetcode-cn.com/problems/lian-biao-zhong-dao-shu-di-kge
剑指offer题目题解java版+c++版+Python版.zip
07-15
总之，《剑指Offer》题解涵盖了编程基础、算法、设计模式等多个方面，通过不同语言的实现，帮助开发者巩固编程基础，提升解决实际问题的能力。无论是准备面试还是提升自身技术，都是不可或缺的学习资源。
牛客网剑指offer——Java题解.pdf
09-07
剑指offer Java题解 本资源总结了牛客网剑指offer Java题解的关键知识点，涵盖了Java基本概念、数据结构和算法等方面的知识。 JZ1 二维数组中的查找 * 题目描述：在一个二维数组中查找指定的整数。 * 解题思路：...
sword_offer:剑指offer题解Java版
05-09
《剑指Offer：Java版题解》是一本深入解析编程面试问题的书籍，主要针对Java开发者，涵盖了大量面试中常见的编程题目。这本书旨在帮助Java程序员提升技能，为求职面试做好充分准备。通过解决这些题目，读者可以巩固...
力扣剑指offer.pdf
10-09
剑指offer题解 sword指offer为一份IT行业的知识宝典，涵盖了数组、链表、二叉树等基础数据结构和算法的解决方案。以下是对剑指offer题解的详细介绍： 一、数组中重复的数字 剑指Offer 03.数组中重复的数字的解法...
《剑指Offer》刷题笔记——面试题06. 从尾到头打印链表
01-21
难度：简单 一、题目描述： 二、解题分析： 1、剑指解析： 2、代码实现： I、辅助栈 from typing import List ###### 代码主体 ###### class Solution: def reversePrint(self, head: ListNode) -> List[int]: stack = [] if head is None: return [] stack.append(head.val) while (head.next != None):
【剑指Offer】链表
Chris_Eddy的博客
09-08 199
今天是《剑指Offer》系列的第二天，主要内容是链表，题目还是比较容易的，三道题，两道简单一道中等，加油。 从尾到头打印链表 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 示例 1： 输入：head = [1,3,2] 输出：[2,3,1] 限制： 0 <= 链表长度 <= 10000 /** * Definition for singly-linked list. * struct ListNode { * int val; * ListNod
《剑指offer》：链表
u014509577的博客
04-25 132
一、从尾到头打印链表 题目：输入一个链表，按链表从尾到头的顺序返回一个ArrayList。 解题思路：使用栈作为中转，可以实现倒置打印 class Solution { public: vector<int> printListFromTailToHead(ListNode* head) { //使用栈完成中转 stack<int&...
链表（简单）【剑指offer】
dyh的博客
05-27 116
是啥
剑指offer之链表篇
01-25 640
算法是程序员必不可少的技能之一，而链表作为一种常用的数据结构更是重中之重，通过《剑指offer》链表篇的练习总结可以让我们对链表更加了解...
剑指offer-链表专栏
weixin_42036617的博客
05-19 230
本文是剑指offer链表专题，一般一般 从尾到头打印链表 题目描述 输入一个链表，按链表值从尾到头的顺序返回一个ArrayList。 算法思想： 建立栈来实现，将链表中所有元素都进栈后，出栈的顺序就是链表从尾到头打印的顺序。 代码: //链表结点定义 /** * struct ListNode { * int val; * struct ListNode *next...
剑指Offer-链表-（5）
qq_35649064的博客
12-05 119
知识/数据结构：复杂链表的复制 题目描述： 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针指向任意一个节点），返回结果为复制后复杂链表的head。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空） 思路： 第一步、复制每个结点，如复制结点A得到A1，将结点A1插到结点A后面； 第二步、重新遍历链表，复制老结点的随机指针给新结点，如A1....
剑指Offer-链表部分
JIMJJU的博客
05-11 89
剑指Offer链表部分从尾到头打印链表删除链表的节点解题思路1解题思路2链表中倒数第k个节点解题思路反转链表解题思路1解题思路2复杂链表的复制解题思路1两个链表的第一个公共节点解题思路1解题思路2 从尾到头打印链表 输入一个链表的头节点，从尾到头反过来返回每个节点的值（用数组返回）。 示例 1： 输入：head = [1,3,2] 输出：[2,3,1] var reversePrint = function(head) { if(head == null){ return []
Java版剑指Offer：编程题解
"这是《剑指Offer》一书的Java版代码实现，由GitHub用户Cyc2018贡献，仅供学习交流，禁止商业用途。书中涵盖了许多经典的算法和数据结构问题，适合准备面试和提升编程能力。" 这篇文章是关于《剑指Offer》一书中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值