【LeetCode、牛客】链表分割、链表的回文结构、160.相交链表

于 2024-07-25 11:23:22 发布
阅读量1.2k 收藏 32
点赞数 36
分类专栏： 数据结构 文章标签： leetcode 数据结构 算法 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2201_75724363/article/details/140685065
版权

Hi~！这里是奋斗的明志，很荣幸您能阅读我的文章，诚请评论指点，欢迎欢迎 ~~
🌱🌱个人主页：奋斗的明志
🌱🌱所属专栏：数据结构

在这里插入图片描述

📚本系列文章为个人学习笔记，在这里撰写成文一为巩固知识，二为展示我的学习过程及理解。文笔、排版拙劣，望见谅。

在这里插入图片描述

链表面试题

一、链表分割

链表分割

1. 题目

在这里插入图片描述

2. 方法一解析

初始化准备：

ListNode newHead1 = new ListNode(0);
ListNode tmp1 = newHead1;
ListNode newHead2 = new ListNode(0);
ListNode tmp2 = newHead2;

newHead1 和 tmp1 是用来存放小于 x 的节点的链表头和当前节点。
newHead2 和 tmp2 是用来存放大于等于 x 的节点的链表头和当前节点。
这里的 new ListNode(0) 是为了简化逻辑而创建的哨兵节点（dummy node），也就是虚拟节点不存储实际数据。

遍历原链表：

ListNode cur = pHead;
while (cur != null) {
    if (cur.val < x) {
        tmp1.next = cur;
        cur = cur.next;
        tmp1 = tmp1.next;
    } else {
        tmp2.next = cur;
        cur = cur.next;
        tmp2 = tmp2.next;
    }
}

使用 cur 作为遍历原链表 pHead 的指针。
如果 cur.val < x，将当前节点 cur 追加到 newHead1 的末尾，并更新 tmp1 指向最后一个节点。
如果 cur.val >= x，将当前节点 cur 追加到 newHead2 的末尾，并更新 tmp2 指向最后一个节点。
每次追加后，更新 cur 到下一个节点。

连接两个分区：

tmp2.next = null; // 将大于等于 x 的链表部分的末尾置空，避免形成环。
tmp1.next = newHead2.next; // 将小于 x 的链表部分的末尾连接到大于等于 x 的链表部分的头部。

返回结果：

return newHead1.next; // 返回重新排列后的链表头节点。

返回 newHead1.next，即小于 x 的部分的头节点，因为 newHead1 的头节点是一个哨兵节点。

3. 方法二解析

在这里插入图片描述

  • 初始化变量：

bs, be: 分别表示小于 x 的部分的头节点和尾节点。
as, ae: 分别表示大于等于 x 的部分的头节点和尾节点。

  • 遍历链表：

使用 cur 指针遍历整个链表。
根据节点的值 cur.val 和给定的 x 进行判断，将节点加入对应的链表部分。

  • 连接两部分：

如果 bs（小于 x 的部分）为空，则直接返回 as（大于等于 x 的部分）的头节点。 否则，将 be（小于 x 的部分的尾节点）的next 指向 as 的头节点，连接两部分链表。
最后，将 ae 的 next 设置为 null，防止出现循环链表。

  • 返回结果：

返回重新排列后的链表的头节点 bs。

4. 方法一完整代码

  • 方法一：
import java.util.*;

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        if(pHead == null){
            return null;
        }
        if(pHead.next == null){
            return pHead;
        }
        ListNode newHead1 = new ListNode(0);
        ListNode tmp1 = newHead1;
        ListNode newHead2 = new ListNode(0);
        ListNode tmp2 = newHead2;
        ListNode cur = pHead;

        while(cur != null){
            if(cur.val < x){
                tmp1.next = cur;
                cur = cur.next;
                tmp1 = tmp1.next;
            }else{
                tmp2.next = cur;
                cur = cur.next;
                tmp2 = tmp2.next;
            }
        }
        tmp2.next = null;
        tmp1.next = newHead2.next;
        return newHead1.next;
    }
}

5. 方法二完整代码

import java.util.*;

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

    ListNode(int val) {
        this.val = val;
    }
}*/
public class Partition {
    public ListNode partition(ListNode pHead, int x) {
        if (pHead == null) {
            return null;
        }
        if (pHead.next == null) {
            return pHead;
        }

        ListNode cur = pHead;
        ListNode bs = null;
        ListNode be = null;
        ListNode as = null;
        ListNode ae = null;

        while (cur != null) {
            if (cur.val < x) {
                if (bs == null) {
                    //说明一个节点都没有
                    bs = cur;
                    be = cur;
                } else {
                    be.next = cur;
                    be = be.next;
                }
            } else {
                if (as == null) {
                    //说明一个节点都没有
                    as = cur;
                    ae = cur;
                } else {
                    ae.next = cur;
                    ae = ae.next;
                }
            }
            cur = cur.next;
        }
        if (bs == null) {
            return as;
        }
        be.next = as;
        if (as != null) {
            ae.next = null;
        }
        return bs;
    }
}

二、链表的回文结构

链表的回文结构

1. 了解链表的回文结构

链表的回文结构指的是链表从头到尾和从尾到头遍历得到的序列是相同的。
换句话说，正序和逆序遍历得到的节点值序列完全一致。

  • 判断链表是否回文的方法

    • 要判断一个链表是否为回文结构，可以采用以下方法之一：

    • 利用额外空间：

    • 将链表节点的值复制到数组中，然后利用数组的回文性质来判断。这种方法需要 O(n) 的额外空间，其中 n 是链表的长度。

    • 利用快慢指针和翻转：

      使用快慢指针找到链表的中点。
      将后半部分链表进行翻转。
      然后同时从头部和中点开始遍历比较节点值，看是否相等。
      最后恢复链表原始结构（可选）。

2. 题目

在这里插入图片描述

3. 解析

  • 空链表检查：
if (A == null) {
    return true;
}

如果输入的链表头节点 A 为空，直接返回 true，因为空链表被认为是回文的。

  • 找到中间节点：
    使用快慢指针法找到链表的中间节点：

在这里插入图片描述

在这里插入图片描述

ListNode fast = A;
ListNode slow = A;
while (fast != null && fast.next != null) {
    fast = fast.next.next;
    slow = slow.next;
}

快指针 fast 每次移动两步，慢指针 slow 每次移动一步，当快指针到达末尾时，慢指针恰好在链表的中间。

  • 反转后半部分链表：
    在这里插入图片描述
ListNode cur = slow.next;
while (cur != null) {
    ListNode curNext = cur.next;
    cur.next = slow;
    slow = cur;
    cur = curNext;
}

将从中间节点 slow.next 开始的链表部分进行反转，slow 成为反转后的头节点，最终 slow 指向反转后链表的尾节点。

  • 比较前半部分和后半部分链表：
  • 偶数情况见图：
    在这里插入图片描述
while (slow != A) {
    if (slow.val != A.val) {
        return false;
    }

    if (A.next == slow) {
        return true;
    }
    A = A.next;
    slow = slow.next;
}

通过两个指针 A 和 slow 分别从链表头和中间向两端移动，比较节点值是否相等。如果任何时候值不相等，则返回 false，表示不是回文链表；如果 A 和 slow 指向同一个节点，说明链表比较完毕，返回 true，表示是回文链表。

  • 总结:

这段代码通过快慢指针找到链表中间节点，反转后半部分链表，然后将前半部分和反转后的后半部分进行比较，来判断链表是否为回文链表。这种方法的时间复杂度为 O(n)，空间复杂度为 O(1)，是一种比较高效的实现方式。

4. 完整代码

import java.util.*;

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

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

public class PalindromeList {
    public boolean chkPalindrome(ListNode A) {
        if(A == null){
            return true;
        }

        //1.找中间节点
        ListNode fast = A;
        ListNode slow = A;
        while(fast != null && fast.next != null){
            fast = fast.next.next;
            slow = slow.next;
        }

        //cur代表要反转的链表
        ListNode cur = slow.next;

        while(cur != null){
            ListNode curNext = cur.next;
            cur.next = slow;
            slow = cur;
            cur = curNext;
        }
        //一个向前，一个向后
        while(slow != A){
            if(slow.val != A.val){
                return false;
            }

            if(A.next == slow){
                return true;
            }
            A = A.next;
            slow = slow.next;
        }
        return true;
    }
}

三、相交链表

160.相交链表

1. 题目

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

2. 解析

在这里插入图片描述
在这里插入图片描述

  • 计算链表长度：

    • 首先通过遍历两个链表分别计算它们的长度 lenA 和 lenB。

  • 调整指针位置：

    • 将 pl 指向较长的链表头，ps 指向较短的链表头，以便后续步骤中两个指针同时遍历，确保它们从同一起点开始。

  • 移动指针到相同起点：

    • 如果两个链表长度不同，先让较长链表的指针 pl 先走 len 步，使得 pl 和 ps 位于同一起点。

  • 寻找交点：

    • 同时移动 pl 和 ps 直到它们相遇（即找到交点）或者同时到达链表尾部（即没有交点）。

  • 返回结果：

    • 如果找到了交点，返回交点节点；否则返回 null。

这种方法的时间复杂度是 O(m + n)，其中 m 和 n 是两个链表的长度，因为需要分别遍历两个链表来计算长度和寻找交点。

3. 完整代码

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode(int x) {
 *         val = x;
 *         next = null;
 *     }
 * }
 */
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        //分别求两个链表的长度
        int lenA = 0;
        int lenB = 0;

        ListNode pl = headA;//永远指向最长的链表
        ListNode ps = headB;//永远指向最短的链表
        while(pl != null){
            lenA++;
            pl = pl.next;
        }
        while(ps != null){
            lenB++;
            ps = ps.next;
        }
        pl = headA;
        ps = headB;
        int len = lenA - lenB;
        if(len < 0){
            //说明 pl 应该指向 headB
            pl = headB;
            ps = headA;
            len = lenB - lenA;
        }
        //保证 len 一定是正数
        //pl 指向最长的
        //ps 指向最短的

        while(len != 0){
            pl = pl.next;
            len--;
        }
        //pl ps 走到相遇节点的路程是一样的
        while(pl != null && pl != ps){
            pl = pl.next;
            ps = ps.next;
        }
        if(pl == ps && pl == null){
            return null;
        }
        return pl;
    }
}

在这里插入图片描述

在这里插入图片描述

明志学编程-
关注
  • 36
    点赞
  • 踩
  • 32
    收藏
    觉得还不错? 一键收藏
  • 6
    评论
专栏目录
链表学会了没，会做这些题就足够了，思路全在动图里了，不懂直接剁手《下篇》
wh128341的博客
08-22 6万+
1.分割链表＜难度系数⭐⭐＞ ???? 题述：现有一链表的头指针 ListNode* pHead，给一定值x，编写一段代码将所有小于x的结点排在其余结点之前，且不能改变原来的数据顺序 (相对顺序不变)，返回重新排列后的链表的头指针。 ???? 示例1： 输入：head = [1,4,3,2,5,2], x = 3 输出：[1,2,2,4,3,5] ???? 示例2： 输入：head = [2,1], x = 2 输出：[1,2] ???? 平台：Visual studio 2017 &&
熬夜肝了这一份来自牛客，LeetCode，剑指 Offer大佬整理的前端常用算法面试题.pdf，你也能进大厂
weixin_56134381的博客
06-21 469
1.2021年已过半，“金九银十”笔试/面试即将要开始,整理一些算法题一起学习。 2.我统一使用JavaScript(V8/Node)解答,都已经调试通过。 3.一起加油！一起进步！
分割链表
Beverly_的博客
03-11 485
题目描述： 编写代码，以给定值x为基准将链表分割成两部分，所有小于x的结点排在大于或等于x的结点之前 给定一个链表的头指针ListNode* pHead，请返回重新排列后的链表的头指针。注意：分割以后保持原来的数据顺序不变 /* 遍历整个链表，把小于 x 的尾插到一个小链表，把大于等于 x 的尾插到一个大链表中 理想情况下，把大链表接到小链表后边 1) 如果没有...
【Leetcode刷题笔记之链表篇】234. 回文链表
大家好我叫张同学
01-15 1198
给你一个单链表的头节点 `head` ，请你判断该链表是否为`回文链表`。 如果`是`，返回 `true` ；否则，返回` false` 。 具有对称性的链表就具有回文结构 如果是单数个结点，中间的结点无需考虑，如果其他结点对称肯定是回文结构 例如：1 2 3 1 2 也是回文结构 这里借助求链表倒数第k个结点的思路。 只要链表的.....
【牛客力扣习题笔记】链表的回文结构
aitexuexue的博客
10-22 228
逆置后半截后，从头结点开始遍历到他的next为空时结束，中间结点同时开始遍历为空时结束，如果值都相等说明是回文结构。比如奇数个【1,2，3,2，1】从头结点和中间节点同时开始遍历，为空结束，如果都相等，说明是回文结构。两个指针用来反转指向，第三个指针用来保存第三个结点，用于继续下一步改变指向。利用快慢指针，slow指针走一步每次，fast指针每次走两步，快指针速度是慢指针的二倍。（原来的头结点要指向NULL，head->next->head;（当为偶数时，有两个中间结点，取第二个）偶数个【1,2，2,1】
Java-数据结构-链表＜一＞
weixin_45532984的博客
07-01 986
链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）[1]，通常链表的头被称为head，尾部一般用null表示。...............
链表常见面试题
weixin_45785104的博客
10-25 239
注：本文章练习题来自牛客和LeetCode，分享的是自己的练习总结 1.给你一个链表的头节点 head 和一个整数 val ，请你删除链表中所有满足 Node.val == val 的节点，并返回 新的头节点 。1.先不考虑头结点，因为优先考虑头结点值会产生循环处理较为复杂 2.先进行处理后面的普通的结点，如果该结点的值与val相等，则删除，若不相等则继续处理下一个结点，直到处理完所有的结点 3.再处理头结点 /** * Definition for singly-linked list....
【分割链表】
最新发布
m0_熊猫馆主的博客
11-08 698
分割链表的五种方法（来为大家拓展思路）。
链表的分割
anyway33的博客
05-06 374
链接: https://www.nowcoder.com/practice/0e27e0b064de4eacac178676ef9c9d70?tpId=8&&tqId=11004&rp=2&ru=/activity/oj&qru=/ta/cracking-the-coding-interview/question-ranking //1.哨兵位法 class Partition { public: ListNode* partition(ListNod.
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值