链表题型思路错误总结

已于 2024-08-04 23:20:32 修改
阅读量351 收藏 3
点赞数 9
分类专栏： Leetcode 文章标签： 链表 数据结构
于 2024-08-04 17:05:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Dcwjh/article/details/140903945
版权

常见题目

206. 反转链表

在这里插入图片描述

关键点：定义前置指针。
在给cur.next复制前，需要定义好next节点防止断链。

	public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode pre = null;
        ListNode cur = head;
        while(cur!=null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;

    }

21. 合并两个有序链表

在这里插入图片描述
关键点：需要一个实质的头节点

class Solution {
    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
        if (l1 == null) {
            return l2;
        }
        if (l2 == null) {
            return l1;
        }
        ListNode pre = new ListNode();
        ListNode cur = pre;
        while (l1 != null && l2 != null) {
            if (l1.val < l2.val) {
                cur.next = l1;
                l1 = l1.next;
            } else {
                cur.next = l2;
                l2 = l2.next;
            }
            cur = cur.next;
        }
        while (l1 != null) {
            cur.next = l1;
            l1 = l1.next;
            cur = cur.next;
        }
        while (l2 != null) {
            cur.next = l2;
            l2 = l2.next;
            cur = cur.next;
        }
        return pre.next;
    }
}

109. 有序链表转换二叉搜索树

在这里插入图片描述
关键点：如何对链表进行分割。

class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        if (head == null) {
            return null;
        }
        if (head.next == null) {
            return new TreeNode(head.val);
        }
        return curser(head, null);
    }

    private TreeNode curser(ListNode head, ListNode tail) {
        if (head == tail) {
            return null;
        }
        ListNode slow = head;
        ListNode fast = head;
        while(fast != tail && fast.next != tail) {
            slow = slow.next;
            fast = fast.next.next;
        }
        TreeNode root = new TreeNode(slow.val);
        root.left = curser(head, slow);
        root.right = curser(slow.next, tail);
        return root;
    }

}

234. 回文链表

思路1：转换成数组，按照定义进行判断

class Solution {
    public boolean isPalindrome(ListNode head) {
         if(head == null || head.next == null){
            return true;
        }
        int length = 0;
        ListNode cur = head;
        while (cur != null) {
            length ++;
            cur = cur.next;
        }
        int[] array = new int[length];
        cur = head;
        for (int i = 0; i < length; i++) {
            array[i] = cur.val;
            cur = cur.next;
        }
        for (int i = 0; i < length/2; i++) {
            if(array[i] != array[length - i - 1]) {
                return false;
            }
        }
        return true;
    }
}

思路2：找到中间节点，进行反转

为什么设置：ListNode slow = head; ListNode fast = head.next; 而不是ListNode slow = head; ListNode fast = head;

  • 找到需要反转链表的前一个节点，为了统一
    在这里插入图片描述
    在这里插入图片描述
    1 3 5 3 1是找到了饭互赞链表的前一个，但是1 2 2 1却找到了需要反转的当前这个。
    所以需要将fast往后移动一位，如下：
    在这里插入图片描述

在这里插入图片描述

class Solution {
    public boolean isPalindrome(ListNode head) {
        if (head == null || head.next == null) {
            return true;
        }
        // 找到中间节点
        ListNode slow = head;
        ListNode fast = head.next;
        while(fast !=null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        // 反转后半部分
        ListNode second = slow.next;
        slow.next = null;
        second = reverse(second);
        while(second != null) {
            if (head.val != second.val){
                return false;
            }
            second = second.next;
            head = head.next;
        }
        return true;

    }

    private ListNode reverse(ListNode head){
        if(head == null ||head.next == null){
            return head;
        }
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    } 
}

876. 链表的中间结点

思路：如上题解题思路

class Solution {
    public ListNode middleNode(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }

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

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

在这里插入图片描述

  • 为什么新加一个头结点
  • 为了防止删除第一节点，例如n = 5时，不好操作，加一个头结点有些解决这类问题。
class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
        if (head == null){
            return head;
        }
        ListNode pre = new ListNode();
        pre.next = head;
        ListNode cur = pre;
        ListNode fast = head;
        for (int i = 0; i < n; i++) {
            if (fast != null) {
                fast = fast.next;
            }
        }
        while(fast != null) {
            cur = cur.next;
            fast = fast.next;
        }

        cur.next = cur.next.next;
        return pre.next;
    }
}

86. 分隔链表

在这里插入图片描述

class Solution {
    public ListNode partition(ListNode head, int x) {
        if (head == null) {
            return head;
        }
        ListNode l1 = new ListNode();
        ListNode l2 = new ListNode();
        ListNode cur = head;
        ListNode small = l1;
        ListNode big = l2;
        while(cur != null) {
            ListNode next = cur.next;
            if (cur.val < x) {
                small.next = cur;
                small = small.next;
            } else {
                big.next = cur;
                big = big.next;
            }
             cur.next = null;
             cur = next;
        }
        small.next = l2.next;
        return l1.next;
        
    }
}

92. 反转链表 II

在这里插入图片描述

  • left需要指向移动前一个，right移动到需要反转的位置。
class Solution {
    public ListNode reverseBetween(ListNode head, int left, int right) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode pre = new ListNode();
        pre.next = head;
        ListNode le = pre;
        ListNode rt = pre;
        
        for (int i = 0; i < left - 1; i++){
            le = le.next;
        }
        ListNode l1 = null;
        if(le != null) {
            l1 = le.next;
        }
        for (int i = 0; i < right; i++){
            rt = rt.next;
        }
        ListNode l2 = null;
        if(rt != null) {
            l2 = rt.next;
            rt.next = null;
        }
        le.next = reverseListNode(l1);
        l1.next = l2;
        return pre.next;
        

    }

    private ListNode reverseListNode(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null) {
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;
    }
}

143. 重排链表

  • 思路：
      1. 找到中间节点
      1. 反转中间节点后的顺序
      1. 合并节点

第一步：找到中间节点
在这里插入图片描述

    private ListNode getMid(ListNode head) {
        if(head == null || head.next == null) {
            return head;
        }
        ListNode slow = head;
        ListNode fast = head.next;
        while (fast != null && fast.next != null) {
            slow = slow.next;
            fast = fast.next.next;
        }
        return slow;
    }
  • 第二步：反转链表
    private ListNode reverse(ListNode head){
        if(head == null || head.next == null) {
            return head;
        }
        ListNode pre = null;
        ListNode cur = head;
        while(cur != null){
            ListNode next = cur.next;
            cur.next = pre;
            pre = cur;
            cur = next;
        }
        return pre;

    }
  • 第三步：合并链表
/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {
    public void reorderList(ListNode head) {
        if (head == null || head.next == null) {
            return;
        }
        ListNode mid = getMid(head);
        ListNode l1 = head;
        ListNode temp = mid.next;
        mid.next = null;
        ListNode l2 = reverse(temp);
        ListNode pre = new ListNode();
        ListNode  cur = pre;
        while(l1 != null && l2 != null) {
            cur.next = l1;
            l1 = l1.next;
            cur = cur.next;
            cur.next = l2;
            l2 = l2.next;
            cur = cur.next;
        }
        while(l1 != null) {
            cur.next = l1;
            l1 = l1.next;
            cur = cur.next;
        }
        while (l2 != null) {
            cur.next = l2;
            l2 = l2.next;
            cur = cur.next;
        }
        head = pre.next;
    }
}

从尾到头打印链表

删除链表的节点

链表中倒数第K个节点

反转链表

合并两个排序的链表

复杂两个链表的复制

两个链表的第一个公共节点

Dcwjh
关注
  • 9
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
链表题型汇总
weixin_43693143的博客
03-08 136
牛客链表题简单：1.判断链表中是否有环2.合并有序链表3.反转链表4.两个链表的第一个公共结点5.判断一个链表是否为回文结构中等6.链表中环的入口7.两个链表生成相加链表8.重排链表困难9.链表中的节点每k个一组翻转10.合并k个已排序的链表 简单： 1.判断链表中是否有环 问题描述： 判断给定的链表中是否有环。如果有环则返回true，否则返回false。要求空间复杂度为O(1)。 思路： 快慢指针，相遇则有环。 代码： /** * Definition for singly-linked lis
代码随想录一刷题型总结pdf
04-21
1. **数据结构与算法**：总结涵盖了数组、链表、栈、队列、哈希表、二叉树、图等基础数据结构，以及排序、搜索、动态规划、回溯、贪心等经典算法。每个题型下都会有具体的LeetCode题目作为示例，帮助读者理解并应用...
02 链表-常见题型及思路总结
weixin_52115065的博客
08-11 227
本文主要是代码随想录训练营第20期链表的内容，包含了链表的主要题型以及两个解法、解题思路。
环形链表、回文链表题型总结
热门推荐
卜大爷的博客
06-22 2万+
1. 环形链表（力扣：141） 2. 环形链表II（力扣：142） 3. 回文链表（力扣：234） 4. 链表中环的大小
详细总结快慢指针的在链表中的常见题型
xiaoyubuhuiqiche的博客
12-05 1062
双指针进阶解法用两个指针 与 一起遍历链表。 一次走一步， 一次走两步。那么当 到达链表的末尾时， 必然位于中间。 看图可以知道，无论该链表是奇数个还是偶数个，都不会影响最终的结果。代码如下 复杂度分析：解题思路：究竟上面的原理是如何推理出来的呢？我们看图演示具体过程如下代码入下 注意注释！！！ 作者总结：有一个极端条件就是当倒数第K个结点是头节点时，不能将if放到我在代码注释的那个位置，如下图 输入一个链表，输出该链表中倒数第k个结点oj题题目描述：快慢指针解法：我们可以借助上面的思路来解决本题：我
数据结构-链表题型-剑指offer25
weixin_46254542的博客
07-11 67
剑指 Offer 25. 合并两个排序的链表 输入两个递增排序的链表，合并这两个链表并使新链表中的节点仍然是递增排序的。 思路： 声明一个新链表的head，依次去遍历这两个链表，看谁的值小就取谁，当某个链表为null时，取剩下那个链表即可 1、如果其中一个链表为null，直接返回另一个链表即可 2、p1、p2节点，用于遍历链表。声明虚拟头节点，用于生产新的链表 这里为什么用虚拟头节点，而不能用头节点，val是int，它的默认值是0，如果你把头节点的val赋值为0，那合并后的链表就多了一个节点 同理，val
c语言使用链表 常犯的错误,C语言—链表面试题之带环问题的总结
weixin_28931735的博客
05-19 369
链表带环问题昨天在网上看到一个挺有趣的东西，链表带环问题，感觉很烧脑，但是可以锻炼我们的思想，我就闲来无事写一个博客总结一下。所谓链表带环其实也就是让他最后一个结点的next成员指向自己第一个元素的，好开始！首先我们创建一个带环的链表。这个自己写一个链表的后插函数，然后找到最后一个成员的next成员的地址，将它的内容改为你的头结点的地址，这样的一个环就成功了。pList plist = NULL;...
【剑指 Offer】链表-反转链表（经典题型）
码农研究僧的博客
06-24 164
题目： 定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 限制： 0 <= 节点个数 <= 5000 注意：本题与主站 206 题相同：https://leetcode-cn.com/problems/reverse-linked-list/ 思路一： 将其转换为链表 再将链表倒置过来 但返回类型与条
【力扣精选】3分钟拿下反转链表所有题型
秋刀鱼与猫的博客
04-13 2648
用画图的方式带你轻松解决面试高频题 -- 反转链表
数据结构——经典链表题
sun_0228的博客
05-16 358
1、删除链表元素 https://leetcode.cn/problems/remove-linked-list-elements/https://leetcode.cn/problems/remove-linked-list-elements/ 思路一 遍历链表，找出需要删除的，记住删除元素下一个位置，使其与需要删除的前一个链接起来，进而释放掉需要删除的节点 大致如图所示——这段代码很容易实现 struct ListNode* removeElements(struct Lis.
ACM题型_《数据结构》课程设计报告模版.docx
04-12
本课程设计报告主要围绕ACM题型，详细介绍了四个不同的编程问题，并提供了清晰的解题思路、算法设计以及结果分析。以下是针对每个题目的详细说明： ### 题目一：你的大佬 这个题目可能涉及到排序或查找问题。在描述...
c语言编程题库集合(题型）
08-11
这个题库集合涵盖了从基础到高级的各种编程题目，旨在通过实践来提升编程能力，理解数据结构、算法以及程序设计思路。 1. **基础知识**：C语言是计算机科学的基础，它提供了低级内存操作和高效的数据处理能力。在...
C语言实例代码
11-29
- 链表：单链表、双向链表的结构与操作，包括插入、删除节点。 - 树：二叉树、AVL树、红黑树等，包括遍历和搜索算法。 - 图：邻接矩阵和邻接表表示，Dijkstra、Floyd等路径查找算法。 4. **算法**： - 排序：...
二级上机常用库函数和上机题型
03-19
在计算机等级考试中，二级考试通常涉及...备考时，考生应多做练习，熟悉各类题型的解题思路，熟练掌握常用库函数的用法，并具备一定的算法设计能力。通过反复的上机实践，可以提高解决问题的能力，为考试做好充分准备。
数据结构(面试)
Anterior_condyle的博客
08-01 996
在含有n个带权叶节点的二叉树中，其中带权路径（WPL）最小的二叉树称为哈夫曼树，也称最优二叉树。
2024.7.24 作业
qq_64434282的博客
07-24 3034
【代码】2024.7.24 作业。
数理方法习题 前六章.pdf
08-03
数理方法习题 前六章
某大型制造企业IT蓝图规划及实施路线.pptx
最新发布
08-03
某大型制造企业IT蓝图规划及实施路线.pptx
阐述双向链表实现思路
08-24
双向链表是一种常见的数据结构，它可以在链表中的每个节点中保存指向前一个节点和后一个节点的引用。这使得在双向链表中，我们可以在 O(1) 的时间复杂度内访问前一个节点和后一个节点。 实现双向链表的思路如下： 1. 定义节点类：首先，我们需要定义一个节点类作为双向链表的基本单位。节点类应该包含两个重要的属性：数据和指针。数据用于存储节点中的值，指针用于指向前一个节点和后一个节点。 ```python class Node: def __init__(self, data): self.data = data self.prev = None self.next = None ``` 2. 构建双向链表类：接下来，我们需要构建一个双向链表类来管理整个链表。该类应该包含头节点和尾节点的引用。 ```python class DoublyLinkedList: def __init__(self): self.head = None self.tail = None ``` 3. 实现插入操作：要在双向链表中插入一个新节点，我们需要考虑两种情况：插入在链表的开头和插入在链表的其他位置。 - 插入在开头：如果要插入一个新节点作为链表的新头部，我们只需要将新节点的 next 指针指向当前头部节点，同时将当前头部节点的 prev 指针指向新节点。最后，更新链表的头部引用即可。 - 插入在其他位置：如果要插入一个新节点在链表的其他位置，我们需要先找到插入位置的前一个节点。然后，将新节点的 prev 指针指向前一个节点，将新节点的 next 指针指向前一个节点的下一个节点，再将前一个节点的 next 指针指向新节点，最后将新节点的下一个节点的 prev 指针指向新节点。 ```python def insert(self, data): new_node = Node(data) if self.head is None: self.head = new_node self.tail = new_node else: new_node.next = self.head self.head.prev = new_node self.head = new_node ``` 4. 实现删除操作：要在双向链表中删除一个节点，我们需要考虑几种情况：删除头节点、删除尾节点以及删除其他位置的节点。 - 删除头节点：如果要删除头节点，我们只需要将头节点的下一个节点作为新的头节点，并将新头节点的 prev 指针设为 None。 - 删除尾节点：如果要删除尾节点，我们只需要将尾节点的前一个节点作为新的尾节点，并将新尾节点的 next 指针设为 None。 - 删除其他位置的节点：如果要删除其他位置的节点，我们需要先找到要删除的节点。然后，将要删除节点的前一个节点的 next 指针指向要删除节点的下一个节点，将要删除节点的下一个节点的 prev 指针指向要删除节点的前一个节点。 ```python def delete(self, data): if self.head is None: return current = self.head while current: if current.data == data: if current.prev: current.prev.next = current.next else: self.head = current.next if current.next: current.next.prev = current.prev else: self.tail = current.prev break current = current.next ``` 这样，双向链表的基本实现就完成了。当然，还可以根据需要添加其他操作，比如查找节点、获取链表长度等。请注意，在操作双向链表时，我们需要特别注意处理边界情况，比如链表为空或只有一个节点的情况。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值