力扣hot100-链表

已于 2024-07-23 22:34:25 修改
阅读量491 收藏 4
点赞数 4
分类专栏： 算法 文章标签： leetcode 链表 算法
于 2024-07-05 21:36:02 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_64289188/article/details/140217896
版权

文章目录

概要

链表（Linked List）是数据结构中的一种，用于存储具有线性关系的数据。在链表中，每个元素称为一个节点（Node），每个节点包含两个部分：一个是数据域（存储数据），另一个是指针域（指向下一个节点）。链表的结构使得它在某些情况下比数组更加高效，特别是在插入和删除操作上。

链表的类型

  1. 单向链表（Singly Linked List）：

    • 每个节点只有一个指向下一个节点的指针。
    • 头节点（Head）是链表的起点，尾节点（Tail）指向 null。

  2. 双向链表（Doubly Linked List）：

    • 每个节点有两个指针，分别指向前一个节点和下一个节点。
    • 头节点的前指针和尾节点的后指针都指向 null。

  3. 循环链表（Circular Linked List）：

    • 单向链表或双向链表的变种。
    • 尾节点的下一个指针指向头节点，形成一个循环。

题目：相交链表

原题链接：相交链表

题解

核心：其实就是让2个指针走一样的距离，消除步行差，那就一定可以一起走到相交点

因为两个链表如果相交，则它们从相交点到结尾的所有节点都是相同的。因此，我们让指针 p1 和 p2 分别遍历两个链表。如果 p1 到达链表 A 的末尾，则将其重定位到链表 B 的头部；同样地，如果 p2 到达链表 B 的末尾，则将其重定位到链表 A 的头部。这样，两指针最终会在相交点处相遇，即第一个共同节点，即为相交点。

    public static ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode p1 = headA;
        ListNode p2 = headB;
        while (p1 != p2) {
            p1 = p1 == null ? headB : p1.next;
            p2 = p2 == null ? headA : p2.next;
        }
        return p1;
    }

评论区看到一个【还有句话：走到尽头见不到你，于是走过你来时的路，等到相遇时才发现，你也走过我来时的路。】

    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode she = headA;
        ListNode he = headB;
        // 直到两人相遇
        while (she != he) {
            if (she != null) {
                she = she.next;// 如果她没走到尽头就一直走下去
            } else {
                she = headB;// 直到尽头也没遇见他，所以她去往他走过的路
            }
            if (he != null) {
                he = he.next;
            } else {
                he = headA;
            }
        }
        return he;// 返回两人第一次相遇的地方
    }

题目：反转链表

原题链接：反转链表
在这里插入图片描述

题解

方法1：创建新节点并插入新链表头部，更新新链表头指针


 public static ListNode reverseList(ListNode head) {
    // 如果链表为空，直接返回null
    if (head == null) {
        return null;
    }

    // 初始化新链表的头节点
    ListNode root = null;

    // 遍历原链表，将节点逐个插入到新链表的头部
    while (head != null) {
        // 保存当前节点的值
        ListNode temp = new ListNode(head.val);
        // 将新节点插入到新链表的头部
        temp.next = root;
        // 更新新链表的头节点
        root = temp;
        // 移动到下一个节点
        head = head.next;
    }

    // 返回新链表的头节点
    return root;
}

下面这个是用next记录了下一节点

public static ListNode reverseList(ListNode head) {
    ListNode prev = null; // 用于指向当前节点的前一个节点
    while (head != null) {
        ListNode next = head.next; // 保存当前节点的下一个节点
        head.next = prev; // 反转当前节点的指针
        prev = head; // 将 prev 移动到当前节点
        head = next; // 将 head 移动到下一个节点
    }
    return prev; // prev 最后指向的新头节点
}

注意：root = temp; 表示 root 指向 temp 所指向的节点

  • head 的定义：

    head 是一个指向链表头节点的指针。它用于表示整个链表的起点。
    例如，在一个链表 1 -> 2 -> 3 -> null 中，head 指向节点 1。

  • ListNode p = head; 的作用：
    这行代码创建了一个新的指针p，并使它指向与 head 相同的节点（即链表的头节点）。

在这里插入图片描述

题目：回文链表

原题链接：回文链表

在这里插入图片描述

方法1

方法1：把链表的值用数组记录下来

    public static boolean isPalindrome(ListNode head) {
        ArrayList<Integer> list = new ArrayList<>();
        while (head != null) {
            list.add(head.val);
            head = head.next;
        }
        for (int i = 0; i < list.size() / 2; i++) {
            if (list.get(i) != list.get(list.size() - i - 1)) {
                return false;
            }
        }
        return true;
    }

方法2

方法2：快慢指针找链表中点+翻转

public boolean isPalindrome(ListNode head) {
    if (head == null || head.next == null) {
        return true;
    }

    // 使用快慢指针找到链表的中间节点
    ListNode fast = head, slow = head;
    while (fast != null && fast.next != null) {
        fast = fast.next.next;
        slow = slow.next;
    }

    // 反转后半部分链表
    ListNode secondHalfStart = reverseList(slow);
    ListNode firstHalfStart = head;

    // 比较前半部分和反转后的后半部分
    while (secondHalfStart != null) {
        if (firstHalfStart.val != secondHalfStart.val) {
            return false;
        }
        firstHalfStart = firstHalfStart.next;
        secondHalfStart = secondHalfStart.next;
    }

    return true;
}

private ListNode reverseList(ListNode head) {
    ListNode prev = null;
    while (head != null) {
        ListNode next = head.next;
        head.next = prev;
        prev = head;
        head = next;
    }
    return prev;
}

题目：环形链表

原题链接：环形链表
在这里插入图片描述

题解

    public static boolean hasCycle(ListNode head) {
        HashSet<ListNode> set = new HashSet<>();
        while (head != null) {
            if (!set.add(head)) {
                return true;
            }
            head = head.next;
        }
        return false;
    }

因为 set 中存储的是链表节点的引用（即 ListNode 对象的引用）。因为 HashSet 使用的是对象的引用进行比较，所以如果两个节点是同一个节点（即内存地址相同）,HashSet 会检测到这个重复的引用，从而判断链表中存在环。

题目：环形链表Ⅱ

原题链接：环形链表Ⅱ
在这里插入图片描述

题解

    public ListNode detectCycle(ListNode head) {
        ListNode res = new ListNode();
       HashSet<ListNode> set = new HashSet<>();
        while (head != null) {
            if (!set.add(head)) {
                return head; //返回节点即可
            }
            head = head.next;
        }
        return null;
    }

其实理解了环形链表这个题就很简单。在环形链表中，只需改动：返回true的时候返回节点即可，返回false的时候返回null

题目：合并两个有序链表

原题链接：合并两个有序链表

在这里插入图片描述

题解

  1. 初始化：创建一个哑节点 res 作为合并后链表的头节点，temp 用于构建新链表。【哑节点简化了边缘情况处理，不需要特别处理头节点】
  2. 遍历和比较：同时遍历 list1 和 list2，将较小节点链接到 temp 后，并移动 list1 或 list2 的指针。
  3. 处理剩余节点：在遍历结束后，将剩余的非空链表直接链接到 temp 后。
  4. 返回结果：返回 res.next，跳过哑节点，得到合并后的链表。
    public static ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode res = new ListNode(0);
        ListNode temp = res;

        while (list1 != null && list2 != null) {
            if (list1.val < list2.val) {
                temp.next = list1;
                list1 = list1.next;
            } else {
                temp.next = list2;
                list2 = list2.next;
            }
            //temp节点始终指向末尾节点 每次将一个节点添加到合并链表后，temp会移动到新的末尾节点
            temp = temp.next;
        }
        temp.next = list1 == null ? list2 : list1;
        return res.next;
    }

题目：两数相加

原题链接：两数相加
在这里插入图片描述

题解

思路是通过遍历两个链表，计算对应节点值与进位的和，处理进位并构建新链表，最后返回不含虚拟头节点的结果链表。

    public static ListNode addTwoNumbers(ListNode l1, ListNode l2) {
        int carry = 0;
        ListNode dummy = new ListNode(0);
        ListNode temp = dummy;

        while (l1 != null || l2 != null) {
            // 简化写法
            int val1 = (l1 != null) ? l1.val : 0;
            int val2 = (l2 != null) ? l2.val : 0;
            int sum = val1 + val2 + carry;
            carry = sum / 10;

            temp.next = new ListNode(sum % 10);
            temp = temp.next;

            if (l1 != null) l1 = l1.next;
            if (l2 != null) l2 = l2.next;
        }

        if (carry > 0) {
            temp.next = new ListNode(carry);
        }

        return dummy.next;
    }

删除链表的倒数第 N 个结点

原题链接：删除链表的倒数第 N 个结点
在这里插入图片描述

方法1

先将链表节点值存入列表，移除列表中倒数第 n 个值，再重新构建链表返回。

    public static ListNode removeNthFromEnd(ListNode head, int n) {
        ArrayList<Integer> list = new ArrayList<>();
        while (head != null) {
            list.add(head.val);
            head = head.next;
        }
        list.remove(list.size() - n);
        ListNode res = new ListNode();
        ListNode temp = res;
        for (Integer i : list) {
            ListNode node = new ListNode();
            node.val = i;
            temp.next = node;
            temp = temp.next;
        }
        return res.next;
    }

方法2

创建一个虚拟头节点，通过计算链表长度找到要删除节点的前一个节点，然后将其指向删除节点的下一个节点，从而实现删除倒数第 n 个节点，其中链表长度通过单独的方法计算得出。

    public static ListNode removeNthFromEnd(ListNode head, int n) {
        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode cur = dummy;
        for (int i = 0; i < getLength(head) - n; i++) {
            cur = cur.next;
        }
        cur.next = cur.next.next;
        return dummy.next;
    }

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

题目：两两交换链表中的节点

原题链接：两两交换链表中的节点
在这里插入图片描述

题解

该方法创建虚拟头节点，遍历链表，对于每对相邻节点进行交换，交换后移动指针准备处理下一对节点，最终返回处理后的链表，其中虚拟头节点用于统一处理可能的边界情况。


  public static ListNode swapPairs(ListNode head) {
        if (head == null || head.next == null) return head;

        ListNode dummy = new ListNode(0);
        dummy.next = head;
        ListNode cur = dummy;

        // 遍历链表，并交换每对相邻的节点
        while (cur.next != null && cur.next.next != null) {
            ListNode first = cur.next;  // 第一个节点
            ListNode second = cur.next.next;  // 第二个节点

            // 交换这两个节点
            first.next = second.next;
            second.next = first;
            cur.next = second;

            // 移动指针，准备交换下一对节点
            cur = first;
        }
        return dummy.next;
    }
hac1322
关注
  • 4
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
力扣Hot100-148排序链表（插入排序/归并排序）
qq_52241267的博客
07-16 994
给你链表的头结点head，请将其按排列并返回。[1,2,3,4]head = [][]方法一：插入排序，但是由于链表是无序的，插入排序在最坏情况下的时间复杂度是 O(n^2)，这对于较大的输入会导致超时插入排序思想，依次对未排序的节点插入到已经有序的链表中你可以在O(nlogn)时间复杂度和常数级空间复杂度下，对链表进行排序吗方法二：归并排序归并排序在链表排序中表现良好，归并排序（Merge Sort）是一种基于分治法的排序算法，具有稳定的排序表现，时间复杂度为 O(nlog⁡n)。
力扣刷题集-更新至链表
06-21
力扣刷题集-更新至链表 本资源摘要信息主要涉及算法领域，着重于数组、链表、排序算法、二分查找等知识点。 数组 数组是存放在连续内存空间上的相同类型数据的集合。数组可以方便地通过下标索引的方式获取到下标...
力扣HOT100 - 206. 反转链表
qq_61504864的博客
04-17 336
【代码】力扣HOT100 - 206. 反转链表。
力扣HOT100 - 234. 回文链表
qq_61504864的博客
04-17 339
【代码】力扣HOT100 - 234. 回文链表。
力扣HOT100 - 148. 排序链表
qq_61504864的博客
04-21 233
【代码】力扣HOT100 - 148. 排序链表。
力扣HOT100 - 141. 环形链表
qq_61504864的博客
04-19 224
【代码】力扣HOT100 - 141. 环形链表。
力扣HOT100 - 160. 相交链表
qq_61504864的博客
04-11 311
【代码】力扣HOT100 - 160. 相交链表。
力扣HOT100 - 142. 环形链表 II
qq_61504864的博客
04-19 222
【代码】力扣HOT100 - 142. 环形链表 II。
力扣HOT100 - 138. 随机链表的复制
qq_61504864的博客
05-21 740
前者的p为一个指向head对象的引用，换句话说，p和head 指向同一个对象，它们共享相同的引用，后者则创建一个全新的Node节点，p与head的val值相同。与Node p=new Node(head.val);
力扣HOT100 - 114. 二叉树展开为链表
qq_61504864的博客
04-23 324
【代码】力扣HOT100 - 114. 二叉树展开为链表。
【力扣刷题】数组-链表-哈希-双指针
06-21
"数组-链表-哈希-双指针" 在计算机科学中，数组是一种基本的数据结构，用于存储相同类型的数据元素。数组中的每个元素都可以通过下标索引来访问，下标从0开始计数。数组的元素是不能删除的，只能覆盖。不能释放单个...
力扣题解大全-600多页版
08-29
2. **数据结构**：涉及二叉树（题目449，100），数组（题目396，905），链表（题目382，349），栈和队列（如题目258），哈希表（如题目392，442），图（如题目1345），堆（如题目340）等。 3. **数学问题**：包括...
leetcode力扣是什么-leetcode-exercise:leetcode练习
06-30
leetcode力扣是什么 leetcode-exercise 力扣练习题 28题：实现strStr() 实现 strStr() 函数。 给定一个 haystack 字符串和一个 needle 字符串，在 haystack 字符串中找出 needle 字符串出现的第一个位置 (从0开始...
leetcode力扣是什么-test:测试
06-30
leetcode力扣是什么 写给初中级前端的高级进阶指南 内容来自掘金文章 我的 github 地址: [2] 我的 blog 地址: [3] 写给女朋友的中级前端面试秘籍: [4] JavaScript 深入系列、JavaScript 专题系列、ES6 系列: [5] ...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 866
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
C++ | Leetcode C++题解之第283题移动零
Ddddddd_158的博客
07-25 343
C++ | Leetcode C++题解之第283题移动零
LeetCode707 设计链表
最新发布
daishabby2486的博客
07-25 599
LeetCode707 设计链表的解题记录。
Leetcode—769. 最多能完成排序的块【中等】
Atticus的博客
07-25 348
运行结果 之后我会持续更新，如果喜欢我的文章，请记得一键三连哦，点赞关注收藏，你的每一个赞每一份关注每一次收藏都将是我前进路上的无限动力 ！！！↖(▔▽▔)↗感谢支持！
力扣python160相交链表
12-14
以下是力扣python160相交链表的实现： ```python class Solution: def getIntersectionNode(self, headA: ListNode, headB: ListNode) -> ListNode: if not headA or not headB: return None pA, pB = headA, ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值