代码随想录--链表

最新推荐文章于 2024-07-20 11:22:21 发布
最新推荐文章于 2024-07-20 11:22:21 发布
阅读量844 收藏 24
点赞数 21
分类专栏： 代码随想录 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_46042803/article/details/136320993
版权
本文详细介绍了链表的基本概念，包括单链表、双链表、循环链表以及它们的存储方式。重点讲解了移除链表元素的方法，设计MyLinkedList类并实现各种链表操作，如翻转、交换节点和检测环形链表。
摘要由CSDN通过智能技术生成

链表

理论基础

链表分为几种类型：

  • 单链表
// 定义链表--java
public class ListNode{
	// 结点的值
	int val;
	
	// 下一个结点
    ListNode next;

    // 节点的构造函数(无参)
    public ListNode() {
    }

    // 节点的构造函数(有一个参数)
    public ListNode(int val) {
        this.val = val;
    }

    // 节点的构造函数(有两个参数)
    public ListNode(int val, ListNode next) {
        this.val = val;
        this.next = next;
    }
}
  • 双链表
  • 循环链表

存储方式

在内存中不是连续分布的，而是散乱分布在内存中的某地址上。

移除链表元素

方法1：迭代

  1. 分析头节点即为需要删除元素
  2. 删除头节点后，判断链表是否为空
  3. 不为空，则利用一个临时指针来遍历链表，删除元素
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        // 删除头结点
        while (head != null && head.val == val){
            head = head.next;
        }
        if (head == null)  return head;
        // 删除后续结点
        ListNode cur = head;
        while(cur.next != null){
            if (cur.next.val == val){
                cur.next = cur.next.next;
            }else {
                cur = cur.next;
            }
        }
        return head;
    }
}

方法2：递归

class Solution {
    public ListNode removeElements(ListNode head, int val) {
       if(head==null)
           return null;
        head.next=removeElements(head.next,val);
        if(head.val==val){
            return head.next;
        }else{
            return head;
        }
    }
}

设计链表

实现 MyLinkedList 类：

  • MyLinkedList() 初始化 MyLinkedList 对象。
  • int get(int index) 获取链表中下标为 index 的节点的值。如果下标无效，则返回 -1 。
  • void addAtHead(int val) 将一个值为 val 的节点插入到链表中第一个元素之前。在插入完成后，新节点会成为链表的第一个节点。
  • void addAtTail(int val) 将一个值为 val 的节点追加到链表中作为链表的最后一个元素。
  • void addAtIndex(int index, int val) 将一个值为 val 的节点插入到链表中下标为 index 的节点之前。如果 index 等于链表的长度，那么该节点会被追加到链表的末尾。如果 index 比长度更大，该节点将 不会插入 到链表中。
  • void deleteAtIndex(int index) 如果下标有效，则删除链表中下标为 index 的节点。

思路

  1. 首先需要定义结点（代码中提供的是链表的创建，不是结点的定义，不要混淆）
  2. 再分别设计不同方法
    单链表
// 定义结点
class ListNode{
    int val;
    ListNode next;

    public ListNode(int val){
        this.val = val;
    }
}

// 链表定义
class MyLinkedList {

    // 记录链表中结点数量
    int size;
    ListNode head;

    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
    }
    
    public int get(int index) {
        if (index < 0 || index >= size){
            return -1;
        }
        ListNode cur = head;
        for (int i = 0; i <= index; i++ ){
            cur = cur.next;
        }
        return cur.val;
    }
    
    public void addAtHead(int val) {
        addAtIndex(0, val);

    }
    
    public void addAtTail(int val) {
        addAtIndex(size, val);
    }
    
    public void addAtIndex(int index, int val) {
        if (index > size){
            return;
        }
        index = Math.max(0, index);
        size++;
        ListNode pred = head;
        for (int i = 0; i < index; i++){
            pred = pred.next;
        }
        ListNode addL = new ListNode(val);
        addL.next = pred.next;
        pred.next = addL;
    }
    
    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size){
            return;
        }
        size--;
        ListNode cur = head;
        for (int i = 0; i < index; i++ ){
            cur = cur.next;
        }
        if (cur.next != null){
            cur.next = cur.next.next;
        }
    }
}

/**
 * Your MyLinkedList object will be instantiated and called as such:
 * MyLinkedList obj = new MyLinkedList();
 * int param_1 = obj.get(index);
 * obj.addAtHead(val);
 * obj.addAtTail(val);
 * obj.addAtIndex(index,val);
 * obj.deleteAtIndex(index);
 */

双链表

  • 实现双向链表，即每个节点要存储本身的值，后继节点和前驱节点。
  • 除此之外，需要一个哨兵节点作为头节点 head 和一个哨兵节点作为尾节点 tail。
  • 仍需要一个 size参数保存有效节点数。
    【注意】双链表遍历下标为index的时候，要考虑是从前还是从后开始遍历
class MyLinkedList {
    int size;
    ListNode head;
    ListNode tail;

    public MyLinkedList() {
        size = 0;
        head = new ListNode(0);
        tail = new ListNode(0);
        head.next = tail;
        tail.prev = head;
    }

    public int get(int index) {
        if (index < 0 || index >= size) {
            return -1;
        }
        ListNode curr;
        if (index + 1 < size - index) {
            curr = head;
            for (int i = 0; i <= index; i++) {
                curr = curr.next;
            }
        } else {
            curr = tail;
            for (int i = 0; i < size - index; i++) {
                curr = curr.prev;
            }
        }
        return curr.val;
    }

    public void addAtHead(int val) {
        addAtIndex(0, val);
    }

    public void addAtTail(int val) {
        addAtIndex(size, val);
    }

    public void addAtIndex(int index, int val) {
        if (index > size) {
            return;
        }
        index = Math.max(0, index);
        ListNode pred, succ;
        if (index < size - index) {
            pred = head;
            for (int i = 0; i < index; i++) {
                pred = pred.next;
            }
            succ = pred.next;
        } else {
            succ = tail;
            for (int i = 0; i < size - index; i++) {
                succ = succ.prev;
            }
            pred = succ.prev;
        }
        size++;
        ListNode toAdd = new ListNode(val);
        toAdd.prev = pred;
        toAdd.next = succ;
        pred.next = toAdd;
        succ.prev = toAdd;
    }

    public void deleteAtIndex(int index) {
        if (index < 0 || index >= size) {
            return;
        }
        ListNode pred, succ;
        if (index < size - index) {
            pred = head;
            for (int i = 0; i < index; i++) {
                pred = pred.next;
            }
            succ = pred.next.next;
        } else {
            succ = tail;
            for (int i = 0; i < size - index - 1; i++) {
                succ = succ.prev;
            }
            pred = succ.prev.prev;
        }
        size--;
        pred.next = succ;
        succ.prev = pred;
    }
}

class ListNode {
    int val;
    ListNode next;
    ListNode prev;

    public ListNode(int val) {
        this.val = val;
    }
}

翻转链表

方法一：迭代

class Solution {
    public ListNode reverseList(ListNode head) {
        ListNode pre = null, curr = head;
        while(curr != null) {
            ListNode next = curr.next;
            curr.next = pre;
            pre = curr;
            curr = next;
        }
        return pre;
    }
}

方法二：递归
假设链表的其余部分已经被反转了

class Solution {
    public ListNode reverseList(ListNode head) {
        if (head == null || head.next == null) {
            return head;
        }
        ListNode newHead = reverseList(head.next);
        /**
        第一轮出栈  head=5 head.next为空 返回5
        第二轮出栈  head=4 head.next=5 head.next.next=5.next=head=4  4.next=null
        ......
        同上述 
         */
        head.next.next = head;
        head.next = null;
        return newHead;
    }
}

两两交换链表中的节点

方法一：迭代

class Solution {
    public ListNode swapPairs(ListNode head) {
        ListNode tempNode = new ListNode(0);
        tempNode.next = head;
        ListNode temp = tempNode;
        while( temp.next != null && temp.next.next != null){
            ListNode node1 = temp.next;
            ListNode node2 = temp.next.next;
            temp.next = node2;
            node1.next = node2.next;;
            node2.next = node1;
            temp = node1;
        }
        return tempNode.next;
    }
}

方法二：递归

class Solution {
    public ListNode swapPairs(ListNode head) {
        if (head == null && head.next == null ){
            return head;
        }
        ListNode newHead = head.next;
        head.next = swapPairs(newHead.next);
        newHead.next = head;
        return newHead;
    }
}

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

思路

利用快慢指针，两个指针相差n+1个结点，最后，快指针到链表末端的时候，慢指针指向需要删除的结点的前一个结点

class Solution {
    public ListNode removeNthFromEnd(ListNode head, int n) {
         ListNode newHead = new ListNode(0);
        newHead.next = head;
        ListNode fast = newHead, slow = newHead;
        for(int i = 0; i<=n; i++){
            fast = fast.next;
        }
        while(fast != null){
            fast = fast.next;
            slow = slow.next;
        }
        slow.next = slow.next.next;
        return newHead.next;
    }
}

链表相交

思路

  1. 首先遍历两个链表，获取链表长度
  2. 对齐链表尾部，使得两个链表指针对齐，按短的链表对齐
  3. 移动指针直至两个链表的结点相同
    【注意】是保证结点相等，而不是结点的值相等
public class Solution {
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        ListNode curA = headA, curB = headB;
        int lenA = 0, lenB = 0;
        while(curA != null){
            lenA++;
            curA = curA.next;

        }
        while(curB != null ){
            lenB++;
            curB = curB.next;
        }
        curA = headA;
        curB = headB;
        if (lenA <= lenB){
            for(int i = 0; i < lenB - lenA; i++){
                curB = curB.next;
            }
        }else {
            for(int i = 0; i < lenA - lenB; i++){
                curA = curA.next;
            }
        }
        while (curA != null){
            if(curA == curB){    // 是两个结点相等，不是结点的值
                return curA;   // 返回的是结点，也不是结点的值
            }
            curA = curA.next;
            curB = curB.next;
        }
        return null;
    }
}

环形链表

力扣链接（不是很懂）

public class Solution {
    public ListNode detectCycle(ListNode head) {
        ListNode fast = head, slow = head;
        while (true){
            if(fast == null || fast.next == null) return null;
            slow = slow.next;
            fast = fast.next.next;
            if(fast == slow) break;
        }
        fast = head;
        while(fast != slow){
            slow = slow.next;
            fast = fast.next;
        }
        return fast;
    }
}
Lilili..
关注
  • 21
    点赞
  • 踩
  • 24
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
代码随想录-八股文 pdf
04-25
代码随想录-八股文 PDF 代码随想录-八股文 PDF 是一个涵盖了程序员学习必备的内容的知识星球精华，总结了包括 C++、Java、Go 在内的多种编程语言，数据结构和算法、操作系统、数据库、计算机网络、设计模式、Linux ...
代码随想录-大厂八股文稀有资源好几百页
04-19
代码随想录-大厂八股文稀有资源好几百页 本资源是一个关于代码面试和算法的综合资源，涵盖了C++、Java、Go等多种编程语言，涉及到Linux操作系统和数据结构等多个领域。以下是从该资源中提取的知识点： 一、C++基础...
代码随想录--链表--环形链表
weixin_52297290的博客
05-16 1381
题意： 给定一个链表，返回链表开始入环的第一个节点。如果链表无环，则返回 null。为了表示给定链表中的环，使用整数 pos 来表示链表尾连接到链表中的位置（索引从 0 开始）。如果 pos 是 -1，则在该链表中没有环。说明：不允许修改给定的链表。
代码随想录 --链表
bossDDYY的博客
02-18 757
操作链表的时候尽量定义一个虚拟的头节点，这样方便处理删除实际头结点的逻辑。
代码随想录--链表--设计链表
weixin_52297290的博客
05-02 893
题意：在链表类中实现这些功能：get(index)：获取链表中第 index 个节点的值。如果索引无效，则返回-1。addAtHead(val)：在链表的第一个元素之前添加一个值为 val 的节点。插入后，新节点将成为链表的第一个节点。addAtTail(val)：将值为 val 的节点追加到链表的最后一个元素。addAtIndex(index,val)：在链表中的第 index 个节点之前添加值为 val 的节点。如果 index 等于链表的长度，则该节点将附加到链表的末尾。
代码随想录--链表--移除链表元素
weixin_52297290的博客
04-24 1435
题意：删除链表中等于给定值 val 的所有节点。示例 1： 输入：head = [1,2,6,3,4,5,6], val = 6 输出：[1,2,3,4,5]示例 2： 输入：head = [], val = 1 输出：[]示例 3： 输入：head = [7,7,7,7], val = 7 输出：[]
代码随想录--链表--移除链表元素题型
m0_64931189的博客
03-11 412
①注意，最终返回的是虚拟结点dummy head的指针next，而不是head，因为此时head可能已经被删掉了（因为删除操作有可能删除头结点，而head是指向头结点的，所以如果删除了头结点那head也就不在了），现在的头结点是虚拟结点的next指针。数组在内存中是连续分布的，但是链表在内存中可不是连续分布的。如果是头结点，因为是头结点，所以头结点没有前一个结点，所以不能用非头结点的方式去删除元素，只能让指向头结点的head指针指向头结点的下一个结点，即让原头结点的下一个结点做头结点。
代码随想录--链表--链表相交
weixin_52297290的博客
05-16 665
给你两个单链表的头节点 headA 和 headB ，请你找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null。图示两个链表在节点 c1 开始相交：题目数据 保证 整个链式结构中不存在环。注意，函数返回结果后，链表必须 保持其原始结构。
代码随想录--链表--设计链表题型
m0_64931189的博客
03-14 233
然后怎么找到这第n个节点，while循环，这里又要注意括号里的n，直接考虑极端情况，如果是在头结点前插入，那cur应该等于dummyhead，而不是dummyhead->next，并且是n开始循环不是n+1或者n-1开始循环，比如是头结点前插入，那cur指向虚拟结点，因为n=0，所以不进入循环，所以就能正好让cur指向虚拟结点，cur->next指向头结点。举个例子，比如链表1-2-3-4，获取第2个节点的值，因为下标是从0开始，所以是获取节点3，刚开始设cur指向1，while循环条件是n大于0。
代码随想录--链表--环形链表题型
m0_64931189的博客
03-16 396
fast为空你还往后走那就是对空指针进行操作是出错的，fast的next为空例1-null，那你fast走next再走next，那就是1走向next即到null，还next即对null操作，那就是对空指针进行操作即错，fast的next的next就可以为空例1-2-null，那快指针就从1跳到null，没问题，指针可以指向null啊，可是你要是继续在null的位置上继续往后即操作null让其->next即对空指针进行操作就错所以不进入循环了。一个是链表有没有环，一个是环的入口是哪个。
代码随想录--链表--删除链表的倒数第N个节点
weixin_52297290的博客
05-16 267
给你一个链表，删除链表的倒数第 n 个结点，并且返回链表的头结点。进阶：你能尝试使用一趟扫描实现吗？示例 1：输入：head = [1,2,3,4,5], n = 2 输出：[1,2,3,5] 示例 2：输入：head = [1], n = 1 输出：[] 示例 3：输入：head = [1,2], n = 1 输出：[1]
代码随想录-最强八股文（第五版）
03-01
《代码随想录-最强八股文（第五版）》是一部综合性的编程知识合集，旨在帮助程序员，尤其是面试者，提升在前端、后端以及Java和Go等领域的技术素养。这一版本的内容涵盖了大量的面试常见问题，是程序员们准备技术...
代码随想录 面试大厂必备八股文
07-03
《代码随想录》是众多程序员面试准备的重要参考资料，尤其对于目标是大厂的开发者来说，这本书中的“面试大厂必备八股文”更是不容忽视的内容。这里的“八股文”并非传统意义上的文学形式，而是指在编程面试中经常被...
代码随想录算法PDF.zip
05-29
《代码随想录》是一本深受程序员喜爱的算法学习书籍，其PDF版本为读者提供了方便的电子阅读体验。这本书主要针对准备参加编程面试或者想要提升自己算法能力的开发者，通过实例解析和实战演练，帮助读者深入理解算法...
数组算法--基本查找
最新发布
2303_78660417的博客
07-20 170
基本查找就是从数组的0索引处开始，依次往后查找，如果找到了对应索引处的值，就会，如果没有找到。因为数组的索引号是没有-1的，当返回-1的时候，就能明白没有找到。
数据结构专项-字符串
qq_52241267的博客
07-16 396
面向字符的操作为以字符为单位对数据进行操作，在读的时候将二进制数据转为字符，在写的时候将字符转为二进制数据，这些类都是Reader和Writer的子类。深拷贝和浅拷贝：浅拷贝实际上是复制了被拷贝对象的引用，也就是说浅拷贝的和被拷贝对象指向的是同一块内存空间，而深拷贝则是连同引用的对象也被拷贝，两者指向的是不同的内存空间。然后计算乘法，故之后是*，再计算加法，因此+要在6的前面，不然就是计算4*(x+3)+6了，故选D。中缀表达式中应该先计算x+3，因此后缀表达式中+应该出现在x和3的后面，排除BC。
【Java--数据结构】二叉树
2301_80898480的博客
07-16 1063
如有错误，欢迎指出~
数据结构第32节 无锁编程
hummhumm的专栏
07-17 842
在Java中，无锁编程是一种在多线程环境下避免使用传统锁机制（如关键字或）的技术。这种技术可以提高程序的并发性能，尤其是在高并发场景下，因为它减少了锁的竞争和上下文切换的开销。
代码随想录的python版本
07-27
抱歉，我无法理解你的问题。你可以提供更多的上下文或者明确你的问题吗？谢谢！ #### 引用[.reference_title] - *1* [leetcode 刷题记录，链表部分，代码随想录刷题顺序（python实现）](https://blog.csdn.net/yyy199869/article/details/121777716)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^control_2,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值