数据结构-链表笔记

已于 2024-10-30 10:52:56 修改
阅读量406 收藏 3
点赞数 10
分类专栏： 算法 文章标签： 数据结构 链表 笔记
于 2024-10-01 17:54:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_80490510/article/details/142650934
版权

移除节点

203. 移除链表元素 - 力扣（LeetCode）

/**
 * 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 ListNode removeElements(ListNode head, int val) {
        // 创建一个虚拟头节点，方便处理删除头节点的情况
        ListNode dummyHead = new ListNode();
        dummyHead.next = head;

        // 初始化双指针
        ListNode pre = dummyHead; // pre指向当前节点的前一个节点
        ListNode cur = head;      // cur指向当前节点

        // 遍历链表
        while (cur != null) {
            // 如果当前节点的值等于要删除的值
            if (cur.val == val) {
                // 跳过当前节点，直接链接前一个节点到当前节点的下一个节点
                pre.next = cur.next;
            } else {
                // 如果当前节点的值不等于要删除的值，更新 pre 指针为当前节点
                pre = cur;
            }
            // 无论当前节点的值是否被删除，都移动 cur 指针到下一个节点
            cur = cur.next;
        }

        // 返回新的头节点，跳过虚拟头节点
        return dummyHead.next;
    }
}

设计链表

在链表类中实现这些功能：得到第 index 个节点的值，

在链表的第一个元素之前添加一个值为 val 的节点，

将值为 val 的节点追加到链表的最后一个元素，

在链表中的第 index 个节点之前添加值为 val  的节点，

删除链表中的第 index 个节点

707. 设计链表 - 力扣（LeetCode）

解法:单链表

class ListNode {
    int val; // 节点的值
    ListNode next; // 指向下一个节点的指针
    
    ListNode() {} // 默认构造函数
    ListNode(int val) { // 带值的构造函数
        this.val = val;
    }
}

class MyLinkedList {
    // size 存储链表元素的个数
    int size;
    // 虚拟头结点，便于处理头节点的插入和删除
    ListNode dummyHead;

    public MyLinkedList() {
        size = 0; // 初始化链表大小为 0
        dummyHead = new ListNode(0); // 创建虚拟头结点
    }
    
    // 获取链表中第 index 个节点的值，索引从 0 开始
    public int get(int index) {
        // 检查索引是否有效
        if (index < 0 || index >= size) {
            return -1; // 返回 -1 表示索引无效
        }

        ListNode curNode = dummyHead; // 从虚拟头节点开始
        // 遍历到目标索引的节点
        for (int i = 0; i <= index; i++) {
            curNode = curNode.next; // 移动到下一个节点
        }

        return curNode.val; // 返回目标节点的值
    }
    
    // 在链表头部添加一个新节点
    public void addAtHead(int val) {
        ListNode newNode = new ListNode(val); // 创建新节点
        newNode.next = dummyHead.next; // 新节点指向当前头节点
        dummyHead.next = newNode; // 虚拟头节点指向新节点
        size++; // 更新链表大小
    }
    
    // 在链表尾部添加一个新节点
    public void addAtTail(int val) {
        ListNode curNode = dummyHead; // 从虚拟头节点开始
        // 遍历到链表尾部
        while (curNode.next != null) {
            curNode = curNode.next; // 移动到下一个节点
        }
        ListNode newNode = new ListNode(val); // 创建新节点
        curNode.next = newNode; // 尾节点指向新节点
        size++; // 更新链表大小
    }
    
    // 在指定索引处添加一个新节点
    public void addAtIndex(int index, int val) {
        // 如果索引大于链表大小，无法添加
        if (index > size) {
            return;
        }
        // 如果索引小于 0，从头部插入
        if (index < 0) {
            index = 0;
        }
        ListNode newNode = new ListNode(val); // 创建新节点
        ListNode curNode = dummyHead; // 从虚拟头节点开始
        // 遍历到目标索引的前一个节点
        for (int i = 0; i < index; i++) {
            curNode = curNode.next; // 移动到下一个节点
        }
        // 插入新节点
        newNode.next = curNode.next; // 新节点指向当前位置的下一个节点
        curNode.next = newNode; // 前一个节点指向新节点
        size++; // 更新链表大小
    }
    
    // 删除指定索引的节点
    public void deleteAtIndex(int index) {
        // 检查索引是否有效
        if (index < 0 || index >= size) {
            return; // 索引无效，不进行任何操作
        }
        size--; // 先减少链表大小
        ListNode curNode = dummyHead; // 从虚拟头节点开始
        // 遍历到目标索引的前一个节点
        for (int i = 0; i < index; i++) {
            curNode = curNode.next; // 移动到下一个节点
        }
        // 删除目标节点
        curNode.next = curNode.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);
 */

双指针

反转链表  (难）

206. 反转链表 - 力扣（LeetCode）

class Solution {
    // 反转链表的核心方法，传入链表的头节点 head
    public ListNode reverseList(ListNode head) {
        // 如果链表为空或链表只有一个节点，则不需要反转，直接返回原链表的头节点
        if (head == null || head.next == null) {
            return head;  // 终止条件：空链表或只有一个节点
        }

        // 初始化两个指针：pre 用来跟踪已经反转的部分，cur 用来跟踪未反转的部分
        ListNode pre = head;   // pre 指向当前节点，初始时为链表的头节点
        ListNode cur = head.next;   // cur 指向下一个节点，初始时为头节点的下一个节点

        // 将头节点的 next 设为 null，因为反转后原来的头节点会成为尾节点，尾节点的 next 应该是 null
        head.next = null;

        // 开始遍历链表，直到 cur 为空（即链表末尾）
        while (cur != null) {
            ListNode temp = cur.next;   // 暂存 cur 的下一个节点，防止链表断开后丢失后续节点
            cur.next = pre;   // 将当前节点 cur 的 next 指向 pre，从而实现反转
            pre = cur;   // pre 前进到 cur，表示反转后的部分已经包括当前节点
            cur = temp;   // cur 前进到下一个节点（即之前暂存的节点），继续反转
        }

        // 当 cur 为 null 时，pre 指向的是反转后的新头节点，返回该节点
        return pre;
    }
}

两两交换链表中的节点

24. 两两交换链表中的节点 - 力扣（LeetCode）

// 定义链表节点类
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 ListNode swapPairs(ListNode head) {
        // 定义一个虚拟头节点 dummyHead，用来简化链表头部的操作
        ListNode dummyHead = new ListNode(0);  // 虚拟头节点，值为0，指向实际链表的头节点
        dummyHead.next = head;  // 将虚拟头的 next 指向传入的 head，便于处理链表的开头

        // 定义临时指针 temp，用来遍历链表。初始指向 dummyHead，方便处理链表头部
        ListNode temp = dummyHead;
        
        // node1 和 node2 分别用于指向要交换的两个相邻节点
        ListNode node1;
        ListNode node2;

        // 只要 temp 后面有两个节点存在（即 temp.next 和 temp.next.next 都不为空），就可以继续交换
        while (temp.next != null && temp.next.next != null) {
            // node1 指向第一对中第一个节点
            node1 = temp.next;
            // node2 指向第一对中第二个节点
            node2 = temp.next.next;

            // 开始交换：将 temp 的 next 指向第二个节点（node2）
            temp.next = node2;
            // 将第一个节点 node1 的 next 指向第二个节点 node2 的下一个节点，即交换后第一个节点应该指向的节点
            node1.next = node2.next;
            // 将第二个节点 node2 的 next 指向第一个节点 node1，完成交换
            node2.next = node1;

            // 将 temp 指向 node1，继续处理下一对
            temp = node1;  // node1 是交换后的第二个节点，所以 temp 移动到这里准备处理下一对节点
        }

        // 返回新链表的头节点，即 dummyHead 的 next
        return dummyHead.next;  // dummyHead 是虚拟头节点，实际链表的头节点在 dummyHead.next
    }
}

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

19. 删除链表的倒数第 N 个结点 - 力扣（LeetCode）

// 定义链表节点类
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 {
    // 移除链表中倒数第 n 个节点
    public ListNode removeNthFromEnd(ListNode head, int n) {
        // 边界检查，如果链表为空，直接返回 null
        if (head == null) {
            return null;
        }

        // 定义一个虚拟头节点，dummyHead 用来处理链表头部的特殊情况（例如删除头节点）
        ListNode dummyHead = new ListNode(0);
        dummyHead.next = head; // dummyHead.next 指向链表头节点

        // 定义快指针 fast 和慢指针 slow，都初始化为 dummyHead
        ListNode fast = dummyHead;
        ListNode slow = dummyHead;

        // 快指针 fast 先前进 n+1 步，以便与慢指针 slow 之间的距离为 n
        for (int i = 0; i <= n; i++) {
            fast = fast.next;
        }

        // 快慢指针同时向前移动，直到 fast 到达链表末尾
        while (fast != null) {
            fast = fast.next;
            slow = slow.next;
        }

        // 此时慢指针 slow 指向待删除节点的前一个节点，执行删除操作
        slow.next = slow.next.next;

        // 返回新的链表头节点（dummyHead.next），此时 dummyHead.next 是链表的头节点
        return dummyHead.next;
    }
}

哈希表

判断是否存在同一个元素

链表相交

面试题 02.07. 链表相交 - 力扣（LeetCode）

public class Solution {
    // 定义一个方法来获取两个链表的交点节点
    public ListNode getIntersectionNode(ListNode headA, ListNode headB) {
        // 使用一个 HashSet 来存储链表 A 的所有节点
        Set<ListNode> hashset = new HashSet<ListNode>();

        // 创建一个指针 cur，用于遍历链表 A
        ListNode cur = headA;
        // 遍历链表 A，直到链表的末尾
        while(cur != null){
            // 将当前节点添加到 HashSet 中
            hashset.add(cur);
            // 移动到下一个节点
            cur = cur.next;
        }

        // 重新使用 cur 指针遍历链表 B
        cur = headB;
        // 遍历链表 B，直到链表的末尾
        while(cur != null){
            // 如果当前节点在 HashSet 中，说明找到了交点
            if(hashset.contains(cur)){
                // 返回交点节点
                return cur;
            }
            // 移动到下一个节点
            cur = cur.next;
        }
        // 如果没有交点，返回 null
        return null;
    }
}

环形链表

142. 环形链表 II - 力扣（LeetCode）

public class Solution {
    public ListNode detectCycle(ListNode head) {
        
        // 创建一个 HashSet 用来存储访问过的节点
        Set<ListNode> hashset = new HashSet<>();
        
        // 初始化当前节点为链表的头节点
        ListNode cur = head;
        
        // 循环遍历整个链表
        while (cur != null) {
            // 如果当前节点已经存在于 HashSet 中，说明链表有环，且该节点就是环的起点
            if (hashset.contains(cur)) {
                return cur;  // 返回环的起点节点
            } else {
                // 如果当前节点不在 HashSet 中，将其添加到集合中，表示已经访问过该节点
                hashset.add(cur);
            }
            // 移动当前指针到下一个节点
            cur = cur.next;
        }

        // 如果遍历完整个链表都没有找到重复的节点，说明链表无环，返回 null
        return null;
    }
}

总结

陈奕迅本讯
关注
专栏目录
初学算法的小菜鸡 - 自学笔记 (第九天): 数据结构-链表
qq_36751764的博客
03-29 582
初学算法的小菜鸡 - 自学笔记 (第九天): 数据结构-链表
leetcode-链表笔记
02-06
链表是一种基础且重要的数据结构，它在计算机科学和编程中扮演着至关重要的角色，特别是在算法和数据结构的学习中，LeetCode 是一个很好的实践平台。本笔记将深入探讨 LeetCode 中涉及的链表相关问题，旨在帮助你...
数据结构笔记--链表
QING_________的博客
01-23 389
【【强烈推荐】深入浅出数据结构 - 顶尖程序员图文讲解 - UP主翻译校对 (已完结)】 https://www.bilibili.com/video/BV1Fv4y1f7T1/?数组 可随时访问 每个元素都是恒定时间链表 不可随时访问 访问时间正比于n方块：bite。
数据结构-链表
qq_58240849的博客
08-26 2426
那么链表的结构定义是什么？他的物理结构和逻辑结构分别是什么？在学习一个新的数结构之前需要这要问一下自己，这样你的思路会更清晰，也不会混乱；
数据结构——学习笔记——入门必看【建议收藏】
热门推荐
刘鑫磊
02-09 44万+
（2）静态查找表&动态查找表的区别用法【顺序查找-线性查找-折半查找-二分查找-有序表查找-插值查找-斐波那契查找-索引顺序表查找-分块查找】单独使用顺序存储结构（即数组）无法很好地实现树的存储概念，不过如果充分利用顺序存储和链式存储结构的特点，则完全可以实现对数的存储结构的表示。深度为 2，则至多只有 3 个结点：根结点，根结点的左子树，根结点的右子树···指的是这样一个数列：1、1、2、3、5、8、13、21、……（3）四中常见的多路查找树【2-3 树$2-3-4 树$B 树$B+ 树】的区别用法。
数据结构-循环链表和双向链表
pyc68的博客
06-29 1364
本篇文章介绍数据结构中的循环链表和双向链表
Redis底层数据结构-链表
weixin_45275107的博客
07-28 379
Redis底层数据结构-链表
JAVA-数据结构-链表-附leetcode
jinghang2000的博客
03-13 1305
个人笔记
【尚硅谷】Java数据结构与算法笔记03 - 链表
知不足而奋进，望远山而前行
12-07 2万+
链表是有序的列表，它在内存中的存储如下：单链表(带头结点) 逻辑结构示意图如下：使用带 head 头的单向链表实现 - 水浒英雄排行榜管理完成对英雄人物的增删改查操作 输出： 2.3 面试题（新浪、百度、腾讯） 求单链表中有效节点的个数 查找单链表中的倒数第k个结点 单链表的反转 从尾到头打印单链表 合并两个有序链表 三、双向链表 3.1 思路分析 使用带 head 头的双向链表实现 - 水汻英雄排行榜管理单向链表的缺点分析:分析 双向链表的遍历, 添加, 修改, 删除的操作思路 ===>===>===
力扣刷题笔记丨算法数据结构--链表--反转链表
juehuan1999的博客
02-14 284
1 题目分析 定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 2 代码实现 思路：递归法，在回溯时修改链表指向 class Solution { public: ListNode* reverseList(ListNode* head) { return Recur(head, NULL); } ListNode* Recur(ListNode* cur, ListNode* pre) { if (cur
C语言数据结构——链表
wxk2227814847的博客
01-28 2117
在计算机科学中，数据结构是存储和组织数据的一种方式，它不仅影响数据的存储，也影响数据的检索和更新效率。C语言，作为一种经典的编程语言，提供了灵活的方式来处理数据结构，其中链表是最基本且重要的一种。
【数据结构学习】从零开始的学习笔记 - 链表 - 数 - 图
09-20
数据结构学习过程的笔记，看网课记录的
数据结构学习笔记-链表中的双向链表（JAVA）
08-10
在数据结构的学习中，链表是一种非常基础且重要的概念，特别是在Java编程中。本文将深入探讨标题中的主题——“双向链表”。双向链表是一种特殊形式的链表，每个节点不仅包含指向下一个节点的指针，还包含一个指向前...
数据结构知识点-个人笔记.pdf
03-13
本部分笔记主要涵盖了数据结构的基本概念、线性表的概念和特点以及存储结构。 首先，数据结构的基本概念包括数据、数据项、数据元素和数据对象。数据是所有能够输入计算机并被计算机程序处理的符号的总称，可以是...
数据结构之树
x6886_57的博客
11-03 606
树的定义，树的逻辑表示方法，树的基本术语，树的性质，树的存储结构
数据结构---链表实现栈
最新发布
Dragonlongbo的博客
11-04 253
/用链表作为底层数据结构实现-栈。
插入排序和希尔排序
b123321888的博客
11-04 545
定义：插入排序是一种简单且直观的排序算法，适用于小规模数据的排序。基本思想：通过构建有序序列，对于未排序的数据，在已排序序列中从后向前扫描，找到相应位置并插入。实现特点：使用双层循环，外层循环遍历每个元素，内层循环负责将当前元素插入到正确的位置。定义：希尔排序是一种基于插入排序的排序算法，但它通过将原始列表分割成多个子列表来改进性能，每个子列表使用插入排序进行排序。基本思想：通过比较相距一定间隔的元素来进行排序，逐步减少间隔，直到间隔为1，此时整个列表基本有序，最后进行一次插入排序。
数据结构---链表实现双端队列
Dragonlongbo的博客
11-04 273
/链表实现双端队列。
【数据结构】构造函数和析构函数
cocofu的博客
11-01 758
**构造函数的工作**：在编程中，构造函数的工作就像玩具制造师。每当我们需要一个新的对象，构造函数就会被调用，就像我们需要一个新玩具时，玩具制造师就开始工作。- **析构函数的工作**：在编程中，析构函数的工作就像玩具清理师。- **使用智能指针**：在需要时，建议使用智能指针（如C++中的`std::unique_ptr`和`std::shared_ptr`）来自动管理动态内存，减少手动释放的错误。在我们的程序里，当我们需要一个新的“玩具”时，构造函数就会像玩具制造师一样工作，帮我们准备好一切。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值