006 | 线性表面试经典下

最新推荐文章于 2025-12-12 10:48:03 发布

原创最新推荐文章于 2025-12-12 10:48:03 发布 · 227 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#list

数据结构与算法专栏收录该内容

12 篇文章

订阅专栏

本文深入探讨了链表算法中的三个关键问题：寻找链表环的入口节点、以给定值分割链表以及检查链表是否为回文。通过详细的代码实现和逻辑解析，帮助读者理解并掌握这些链表操作的核心技巧。

写在前面：最近公司有奔向996的趋势了，传统行业都要如此了！

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

思路：假设x为环前面的路程（黑色路程），a为环入口到相遇点的路程（蓝色路程，假设顺时针走）， c为环的长度（蓝色+橙色路程）当快慢指针相遇的时候：此时慢指针走的路程为Sslow =x + m * c + a
快指针走的路程为Sfast = x + n * c + a，2 Sslow =Sfast，所以 2 * ( x + m*c + a ) = (x + n *c + a)
从而可以推导出：
x = (n - 2 * m )*c - a= (n - 2 *m -1 )*c + c - a
即环前面的路程 = 数个环的长度（为可能为0） + c - a
什么是c - a？这是相遇点后，环后面部分的路程。（橙色路程）所以，我们可以让一个指针从起点A开始走，让一个指针从相遇点B开始继续往后走，2个指针速度一样，那么，当从原点的指针走到环入口点的时候（此时刚好走了x）从相遇点开始走的那个指针也一定刚好到达环入口点。所以2者会相遇，且恰好相遇在环的入口点。

package link;

/**
 * Create by IDEA
 * User: zhangqi
 * Date: 2019/3/11
 * Desc: 给一个链表，若其中包含环，请找出该链表的环的入口结点，否则，输出null
 */
public class Solution {

    public ListNode EntryNodeOfLoop(ListNode pHead) {
        
        if (pHead == null || pHead.next == null) return null;
        /** 定义快慢指针，快指针走两步，慢指针走一步 */
        ListNode fast = pHead.next.next;
        ListNode show = pHead.next;
        /** 判断是否存在环 */
        while (fast != show) {
            if (fast != null && fast.next != null) {
                fast = fast.next.next;
                show = show.next;
            } else {
                return null;
            }
        }

        /** fast从新指向头指针处，然后快慢指针一起向后遍历 */
        fast = pHead;
        while (fast != show) {
            fast = fast.next;
            show = show.next;
        }
        return show;
    }
}

编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前

package link;

/**
 * Create by IDEA
 * User: zhangqi
 * Date: 2019/3/11
 * Desc: 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前
 */
public class Solution {

    /**
     * 思路：新建两个链表，链表lit存比x小的结点，链表big存其他的结点
     *      然后将big.next置空，并将big置位lit链表的尾结点next
     * @param pHead
     * @param x
     * @return
     */
    public ListNode partition(ListNode pHead, int x) {
        if (pHead == null) return null;
        /** 定义大小两个链表，并创建两个结点记录两个链表的初始位置 */
        ListNode big = new ListNode(-1);
        ListNode b = big;
        ListNode lit = new ListNode(-1);
        ListNode l = lit;
        
        /** 遍历链表对比x值，分别存入大小链表中 */
        while (pHead != null) {
            if (pHead.val < x) {
                lit.next = pHead;
                lit = pHead;
            } else {
                big.next = pHead;
                big = pHead;
            }
            pHead = pHead.next;
        }
        big.next = null; //注意置空，不然会陷入死循环
        lit.next = b.next;

        return l.next;
    }
}

请编写一个函数，检查链表是否为回文:给定一个链表ListNode* pHead，请返回一个bool，代表链表是否为回文。

package link;

import java.util.ArrayList;

/**
 * Create by IDEA
 * User: zhangqi
 * Date: 2019/3/11
 * Desc: 请编写一个函数，检查链表是否为回文:给定一个链表ListNode* pHead，请返回一个bool，代表链表是否为回文。
 */
public class Solution {

    /**
     * 思路：没有用快慢指针，想着就是反转链表并在反转的过程中将值存到数组中
     *      然后再比较反转后的链表和数组中的值是否相等
     * @param pHead
     * @return
     */
    public boolean isPalindrome(ListNode pHead) {
        /** 反转链表并将值存入数组中 */
        if (pHead == null) return false;
        ListNode list = null;
        ListNode next = null;
        ArrayList<Integer> arr = new ArrayList<>();
        while (pHead != null) {
            arr.add(pHead.val);
            next = pHead.next;
            pHead.next = list;
            list = pHead;
            pHead = next;
        }

        /** 对比是否相等，有一个不相等则返回false */
        for (int i = 0; i < arr.size(); i++) {
            if (arr.get(i) != list.val) return false;
            list = list.next;
        }
        return true;
    }
}