深入解析链表:解锁数据结构核心奥秘

一. 链表的定义

链表是一种线性数据结构,由一系列节点组成。每个节点包含两个部分:

  1. 数据域(Data):存储节点的数据。
  2. 指针域(Pointer):存储指向下一个节点的地址。

链表的第一个节点称为头节点(Head),最后一个节点的指针域指向空(NULL),表示链表的结束。

二. 链表的结构

1) 单向 / 双向
2) 带头 / 不带头
3) 循环 / 非循环

链表种类丰富多样 重点掌握 单向不带头非循环 链表 可作为其他数据结构的子结构,如 哈希桶、图的邻接表等 笔试常考

三. 实现链表

1) 节点类

定义链表节点类,每个节点包含数据和指向下一个节点的指针。

java 复制代码
public class Node {
    int data;
    Node next;

    public Node(int data) {
        this.data = data;
        this.next = null;
    }
}

2) 链表类:

用于实现链表的功能

java 复制代码
public class MySingleList {
    private ListNode head;

    static class ListNode {
        int val;
        ListNode next;

        ListNode(int val) {
            this.val = val;
            this.next = null;
        }
    }
    public ListNode cur; // 临时头节点
}
插入节点:

插入节点 图示

java 复制代码
// 在链表的末尾插入一个新节点
    void append(int data) {
        Node newNode = new Node(data);
        if (head == null) {
            head = newNode;
        } else {
            Node current = head;
            while (current.next != null) {
                current = current.next;
            }
            current.next = newNode;
        }
        usedSize++;
    }

    // 在链表的开头插入一个新节点
    void prepend(int data) {
        Node newNode = new Node(data);
        newNode.next = head;
        head = newNode;
        usedSize++;
    }

    // 在指定位置插入一个新节点
    void insertAt(int index, int data) {
        if (index < 0 || index > usedSize) {
            throw new IndexOutOfBoundsException("Index out of bounds");
        }
        Node newNode = new Node(data);
        if (index == 0) {
            newNode.next = head;
            head = newNode;
        } else {
            Node current = head;
            for (int i = 0; i < index - 1; i++) {
                current = current.next;
            }
            newNode.next = current.next;
            current.next = newNode;
        }
        usedSize++;
    }
删除节点:
java 复制代码
// 删除指定位置的节点
    void deleteAt(int index) {
        if (index < 0 || index >= usedSize) {
            throw new IndexOutOfBoundsException("Index out of bounds");
        }
        if (index == 0) {
            head = head.next;
        } else {
            Node current = head;
            for (int i = 0; i < index - 1; i++) {
                current = current.next;
            }
            current.next = current.next.next;
        }
        usedSize--;
    }
查找节点:
java 复制代码
// 查询指定位置的节点
    Node getNodeAt(int index) {
        if (index < 0 || index >= usedSize) {
            throw new IndexOutOfBoundsException("Index out of bounds");
        }
        Node current = head;
        for (int i = 0; i < index; i++) {
            current = current.next;
        }
        return current;
    }

四. 链表OJ 实战 !

1) 开胃小菜 删除所有值域为val的节点

力扣链接: . - 力扣(LeetCode)

java 复制代码
class Solution {
    public ListNode removeElements(ListNode head, int val) {
        while(head!= null && head.val == val){
            head = head.next;
        }
        ListNode cur = head;
        while(cur != null && cur.next != null){
            if(cur.next.val == val){
                cur.next = cur.next.next;
            }else{
            cur = cur.next;
            }
        }
        return head;
    } 
}

2) 反转链表 重要程度 五颗星 !!!

力扣链接: . - 力扣(LeetCode)

java 复制代码
//    反转链表
    public ListNode reverseList(ListNode head) {
        // 定义两个指针,pre初始化为null,用于存储反转后的链表
        ListNode pre = null;
        // cur初始化为head,表示当前处理的节点
        ListNode cur = head;
    
        // 循环直到cur为null,表示已经处理完所有节点
        while(cur != null){
            // temp临时存储cur的下一个节点,因为接下来要修改cur.next
            ListNode temp = cur.next;

            // 将cur的next指针指向pre,实现反转
            cur.next = pre;

            // pre和cur都前进一步
            pre = cur; // pre移动到cur的位置
            cur = temp; // cur移动到下一个待处理的节点
        }

        // 当cur为null时,pre就是新链表的头节点
        return pre;
    }

思路: 在遍历链表时逐步反转每个节点的指针方向

3) 快慢指针算法

快慢指针: 处理环形链表或数组非常有用

其实不单单是环形链表或者是数组,如果我们要研究的问题出现循环往复的情况时,均可考虑使用快慢指针的思想。

力扣链接: 876. 链表的中间结点 - 力扣(LeetCode)

java 复制代码
public ListNode middleNode(ListNode head) {
        // 定义快慢指针,都初始化为头节点head
        ListNode fast = head;
        ListNode slow = head;

        // 循环条件,快指针fast及其next不为null
        while (fast != null && fast.next != null) {
            // 快指针fast每次向前移动两步
            fast = fast.next.next;
            // 慢指针slow每次向前移动一步
            slow = slow.next;
        }

        // 当快指针到达链表末尾时,慢指针正好到达中间节点
        return slow;
    }

原理 : 因为fast的速度是 slow的速度的二倍, 而fast走完,slow 必然在中间位置.

4) 合并两个有序链表:

思路 : 使用 虚拟节点 为了简化头节点的处理逻辑

比较大小 插入新链表

如果其中一个链表的节点全部被插入到新链表中,如果另一个链表还有剩余节点, 直 接将这些剩余节点链接到新链表的末尾。

记得最后返回虚拟节点的下一个节点.

力扣链接: . - 力扣(LeetCode)

java 复制代码
public ListNode mergeTwoLists(ListNode list1, ListNode list2) {
        ListNode dummy = new ListNode(-1);//虚拟节点

        // 创建一个指针cur,用来遍历并构建新的合并后的链表,初始指向哑节点
        ListNode cur = dummy;
        
        // 遍历链表直到其中一个为空
        while(list1 != null && list2 != null){
            if(list1.val > list2.val){
                cur.next = list2;
                list2 = list2.next;
            }else{
                cur.next = list1;
                list1 = list1.next;
            }
            cur = cur.next;
        }

        // 如果其中一个链表先遍历完,将另一个链表的剩余部分连接到新链表的末尾
        cur.next = (list1 == null) ? list2:list1;
        return dummy.next; //返回虚拟节点的下一个节点
    }

五. ArrayList和LinkedList的区别

  • 数组: 适用于需要快速访问和固定大小的情况。
  • 链表: 适用于频繁插入和删除、且大小动态变化的情况。

六. 总结

链表作为数据结构中的佼佼者,凸显了其在动态数据操作场景下的独特价值,特别是对于需要频繁执行插入和删除操作的应用来说,更是不可或缺。掌握链表的基础操作,包括但不限于节点的创建、插入、删除及遍历,以及进阶技巧如链表的反转、合并操作,以及利用快慢指针解决复杂链表问题,是深化链表理解和应用实践的关键步骤。在链表与数组的权衡选择上,认识到两者各自的强项------数组的快速随机访问与链表的高效动态修改能力,是根据具体需求制定数据结构策略的先决条件。总而言之,链表的灵活高效使其在众多计算领域内占有一席之地,而深入探索其特性和应用,则是对每一位技术探索者的智慧挑战与能力提升之旅。

相关推荐
让学习成为一种生活方式17 分钟前
R包下载太慢安装中止的解决策略-R语言003
java·数据库·r语言
晨曦_子画23 分钟前
编程语言之战:AI 之后的 Kotlin 与 Java
android·java·开发语言·人工智能·kotlin
南宫生1 小时前
贪心算法习题其三【力扣】【算法学习day.20】
java·数据结构·学习·算法·leetcode·贪心算法
Heavydrink1 小时前
HTTP动词与状态码
java
ktkiko111 小时前
Java中的远程方法调用——RPC详解
java·开发语言·rpc
计算机-秋大田1 小时前
基于Spring Boot的船舶监造系统的设计与实现,LW+源码+讲解
java·论文阅读·spring boot·后端·vue
神里大人1 小时前
idea、pycharm等软件的文件名红色怎么变绿色
java·pycharm·intellij-idea
weixin_432702262 小时前
代码随想录算法训练营第五十五天|图论理论基础
数据结构·python·算法·深度优先·图论
小冉在学习2 小时前
day53 图论章节刷题Part05(并查集理论基础、寻找存在的路径)
java·算法·图论
passer__jw7672 小时前
【LeetCode】【算法】283. 移动零
数据结构·算法·leetcode