线性表 —— 链表

最新推荐文章于 2024-07-25 16:50:09 发布
最新推荐文章于 2024-07-25 16:50:09 发布
阅读量928 收藏 17
点赞数 21
分类专栏： 数据结构与算法 文章标签： 链表 数据结构 线性表 递归 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43220213/article/details/136019126
版权

与数组对比

◼ 数组：
 要存储多个元素，数组（或选择链表）可能是最常用的数据结构。
 我们之前说过，几乎每一种编程语言都有默认实现数组结构。

◼ 但是数组也有很多缺点：
 数组的创建通常需要申请一段连续的内存空间(一整块的内存)，并且大小是固定的(大多数编程语言数组都是固定的)，所以当当前数组不能满足容量需求时，需要扩容。 (一般情况下是申请一个更大的数组，比如2倍。 然后将原数组中的元素复制过去，比如 Java 的 ArrayList)
 而且在数组开头或中间位置插入数据的成本很高，需要进行大量元素的位移。
 尽管JavaScript的Array底层可以帮我们做这些事，但背后的原理依然是这样。

概念

◼ 要存储多个元素，另外一个选择就是链表。
◼ 但不同于数组，链表中的元素在内存中不必是连续的空间。
 链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用(有些语言称为指针或者链接)组成。
◼ 相对于数组，链表有一些优点：
 内存空间不是必须连续的。
✓ 可以充分利用计算机的内存，实现灵活的内存动态管理。
链表不必在创建时就确定大小，并且大小可以无限的延伸下去。
 链表在插入和删除数据时，时间复杂度可以达到O(1)。
✓ 相对数组效率高很多。
◼ 相对于数组，链表有一些缺点：
 链表访问任何一个位置的元素时，都需要从头开始访问。(无法跳过第一个元素访问任何一个元素)。
 无法通过下标直接访问元素，需要从头一个个访问，直到找到对应的元素。

image.png

实现

基本结构

实现链表包含两个类，一个是节点类，一个就是链表本身。

class Node<T> {
    value: T;
    next: Node<T> | null = null;
  
    constructor(value: T) {
        this.value = value;
    }
}

export class LinkedList<T> {
    head: Node<T> | null = null;
    size: number = 0;

    get length(): number {
        return this.size;
    }

    // 链表方法
}

常见操作

 append(element)：向链表尾部添加一个新的项
 insert(position，element)：向链表的特定位置插入一个新的项。
 get(position) ：获取对应位置的元素
 indexOf(element)：返回元素在链表中的索引。如果链表中没有该元素则返回-1。
 update(position，element) ：修改某个位置的元素
 removeAt(position)：从链表的特定位置移除一项。
 remove(element)：从链表中移除一项。
 isEmpty()：如果链表中不包含任何元素，返回true，如果链表长度大于0则返回false。
 size()：返回链表包含的元素个数。与数组的length属性类似。

可以看到，链表的方法和数组的基础方法几乎是一样的。因为链表本身就是数组的替代数据结构，只是两者的底层存储结构不一样罢了。

append 添加 、traverse 遍历

追加有两种情况：

  1. 链表为空，直接追加在 head 后面
  2. 不为空，在末尾追加
export class LinkedList<T> {
    head: Node<T> | null = null;
    size: number = 0;

    get length(): number {
        return this.size;
    }

    append(value: T): void {
        const newNode = new Node(value);
        if (!this.head) {
            this.head = newNode;
        } else {
            let current = this.head;
          	// 临时变量 current 指向最后一个节点
            while (current.next) {
                current = current.next;
            }
            current.next = newNode;
        }
        this.size++;
    }

    traverse() {
        const result: T[] = [];
        let current = this.head;
        while (current) {
            result.push(current.value);
            current = current.next;
        }
        console.log(result.join(" -> "));
        return result;
    }
}

insert 插入

插入也有两种种情况：

  1. 从头插入
  2. 中间和尾部插入

注意：插入位置 position 或 index 是从 0 开始的。position 为 2，表示插入完成后，插入的新数据处于链表索引为 2 的地方。也就是插入操作是在原先 2 位置节点的前面插入。

实现：头插入不用说，中间或尾部插入，只要找到原位置上节点的前一个节点，然后把这个节点它的 next ，也就是原位置上的节点给新节点的 next；它的 next 重新指向新节点即可。

insert(value: T, position: number): boolean {
    if (position < 0 || position > this.size) return false;
    if (position === 0) {
        const newNode = new Node(value);
        newNode.next = this.head;
        this.head = newNode;
    } else {
        const newNode = new Node(value);
        let preNode = this.head;
        for (let i = 0; i < position - 1; i++) {
            preNode = preNode!.next;
        }
        newNode.next = preNode!.next;
        preNode!.next = newNode;
    }
    this.size++;
    return true;
}

removeAt 删除

根据给定索引删除元素，并返回被删除的元素。

和插入差不多，有两种情况。首位和非首位，非首位情况核心就是找到前一个节点。

removeAt(position: number): T | null {
    if (position < 0 || position >= this.size) return null;
    let deletedValue: T;
    if (position === 0) {
        deletedValue = this.head!.value;
        this.head = this.head!.next;
    } else {
        let preNode = this.head;
        for (let i = 0; i < position - 1; i++) {
            preNode = preNode!.next;
        }
        deletedValue = preNode!.next!.value;
        preNode!.next = preNode!.next?.next ?? null;
    }
  	this.size--;
    return deletedValue;
}

get 读取

根据索引获取值。

这个就更简单了，直接遍历到索引的节点即可。

get(position: number): T | null {
    if (position < 0 || position >= this.size) return null;
    let current = this.head;
    for (let i = 0; i < position; i++) {
        current = current!.next;
    }
    return current!.value;
}

封装私有方法：根据索引获取节点

可以看到上面的几个方法实现中，都有一个共同的核心逻辑，就是根据索引获取节点。因此可以将这个逻辑封装成一个私有方法。

private getNode(position: number): Node<T> | null {
    if (position < 0 || position >= this.size) return null;
    let node = this.head;
    for (let i = 0; i < position; i++) {
        node = node!.next;
    }
    return node;
}

update 更新

update(value: T, position: number): boolean {
    const node = this.getNode(position);
    if (!node) return false;
    node.value = value;
    return true;
}

indexOf 根据值获取索引

while 循环，只要节点存在就比较它的值。

indexOf(value: T): number {
    let current: Node<T> | null = this.head;
    let index = 0;
    while (current) {
        if (value === current.value) return index;
        current = current.next;
        index++;
    }
    return -1;
}

remove 根据值删除

remove(value: T): T | null {
    const index = this.indexOf(value);
    return this.removeAt(index);
}

isEmpty 判空

isEmpty(): boolean {
    return !!this.head;
}

链表完整实现

class Node<T> {
    value: T;
    next: Node<T> | null = null;
    constructor(value: T) {
        this.value = value;
    }
}

export class LinkedList<T> {
    private head: Node<T> | null = null;
    size: number = 0;

    get length(): number {
        return this.size;
    }

    private getNode(position: number): Node<T> | null {
        if (position < 0 || position >= this.size) return null;
        let node = this.head;
        for (let i = 0; i < position; i++) {
            node = node!.next;
        }
        return node;
    }

    append(value: T): void {
        const newNode = new Node(value);
        if (!this.head) {
            this.head = newNode;
        } else {
            let current = this.head;
            while (current.next) {
                current = current.next;
            }
            current.next = newNode;
        }
        this.size++;
    }

    traverse() {
        const result: T[] = [];
        let current = this.head;
        while (current) {
            result.push(current.value);
            current = current.next;
        }
        console.log(result.join(" -> "));
        return result;
    }

    insert(value: T, position: number): boolean {
        if (position < 0 || position > this.size) return false;
        if (position === 0) {
            const newNode = new Node(value);
            newNode.next = this.head;
            this.head = newNode;
        } else {
            const newNode = new Node(value);
            // let preNode = this.head;
            // for (let i = 0; i < position - 1; i++) {
            //     preNode = preNode!.next;
            // }
            const preNode = this.getNode(position - 1);
            newNode.next = preNode!.next;
            preNode!.next = newNode;
        }
        this.size++;
        return true;
    }

    removeAt(position: number): T | null {
        if (position < 0 || position >= this.size) return null;
        let deletedValue: T;
        if (position === 0) {
            deletedValue = this.head!.value;
            this.head = this.head!.next;
        } else {
            // let preNode = this.head;
            // for (let i = 0; i < position - 1; i++) {
            //     preNode = preNode!.next;
            // }
            const preNode = this.getNode(position - 1);

            deletedValue = preNode!.next!.value;
            preNode!.next = preNode!.next?.next ?? null;
        }
        this.size--;
        return deletedValue;
    }

    get(position: number): T | null {
        // if (position < 0 || position >= this.size) return null;
        // let current = this.head;
        // for (let i = 0; i < position; i++) {
        //     current = current!.next;
        // }
        const node = this.getNode(position);
        return node?.value ?? null;
    }

    update(value: T, position: number): boolean {
        const node = this.getNode(position);
        if (!node) return false;
        node.value = value;
        return true;
    }

    indexOf(value: T): number {
        let current: Node<T> | null = this.head;
        let index = 0;
        while (current) {
            if (value === current.value) return index;
            current = current.next;
            index++;
        }
        return -1;
    }

    remove(value: T): T | null {
        const index = this.indexOf(value);
        return this.removeAt(index);
    }

    isEmpty(): boolean {
        return !!this.head;
    }
}

题目

设计链表

删除链表中的节点

这个题目的难点在于，它不给你头节点，只给你要删除的节点。说白了就是不让你拿到要删除节点的前一个节点。
显然，拿不到前一个节点，那么不可能做到真的删除该节点，所以题目也说了该节点可以不必在内存中删除，只要删除值就可以。

那么我们就可以删除本该被删除节点的下一个节点，因为目标删除节点是下一个节点的前节点，做到删除很容易。
那这样岂不是删除了不该删除的内容？
是的，所以提前将下一个节点的内容保存到目标删除节点即可，这样目标删除节点的内容就被覆盖删除了，然后内存释放的节点其实是下一个节点。

以 1234 4个节点为例，删除节点2：

  1. 把节点 3 的内容覆盖节点 2 的内容，这样节点 2 算是删除了
  2. 然后让节点 2 的 next 指向节点 4,
function deleteNode(node: ListNode | null): void {
    node.val = node.next.val;
    node.next = node.next.next;
};

反转链表

非递归解法

笨笨解法：先用数组保存所有链表值，然后重新生成链表。

这其实是栈的解法：

function reverseList(head: ListNode | null): ListNode | null {
    const val = [];
    let node = head;
    while(node) {
        val.push(node.val);
        node = node.next;
    }
    let _head = new ListNode();
    let curNode = _head;
    while(val.length > 0) {
        const item = val.pop();
        const newNode = new ListNode();
        newNode.val = item;
        curNode.next = newNode;
        curNode = newNode;
    }
    _head = _head.next;
    return _head;
};

优化一下：原地修改链表。

反转链表的本质是什么？是遍历链表，然后一个一个从头插入进新链表。

function reverseList(head: ListNode | null): ListNode | null {
    if (head === null || head.next === null) return head;
    let _head: ListNode | null = null;
    let nextNode: ListNode | null;
    while (head) {
        nextNode = head.next;
        head.next = _head;
        _head = head;
        head = nextNode;
    }
    return _head;
};

原地反转，没有使用栈结构：

  1. 准备新链表头指针 _head（默认为 null） 和 指向下一个节点的变量 nextNode，以及当前处理节点变量 cur。（实际没有使用 cur 变量，直接操作头指针 head，作为 cur）。
    1. 这里假设使用了 cur 变量，因为便于理解。let  cur = head;
  2. nextNode 指向下一个节点，比如索引 1 的节点。nextNode = cur.next;
  3. 此时 0 号节点被卸下，应挂在新链表 head 上_。_cur.next = head;
    1. 为啥被卸下节点直接指向新链表头指针head？因为head 将会一直指向新链表头节点，从头插入实现反转。
    2. 另外末尾节点应指向 null，所以 _head 默认值应为 null。
  4. 让新链表头指针 head 指向被卸下的节点 cur，也就是head 重新指向新链表的头。_head = cur;
  5. 当前处理节点指针往后移动cur = nextNode;
  6. 以 cur 节点是否存在循序上述步骤。

递归解法

function reverseList(head: ListNode | null): ListNode | null {
    // 1 个节点或者空节点，直接返回该链表
    if (head === null || head.next === null) return head;
    // 开始递归，每次传入的都是下一个节点，相当于一路往后遍历
    const _head = reverseList(head?.next ?? null);
    // 此处是递归结束会执行的代码，递归结束的条件是链表只有一个节点
    // 因此此时的 head.next 指向的就是整条链表的最后一个节点。那 head 指向的就是倒数第二个节点。
    // 并且递归结束条件都是返回参数 head，最后一个递归的 reverseList 函数，它的参数 head 接收的就是最后一个节点
    // 然后它被返回了 return head，因此递归函数返回的就是反转后的头结点指针。
    // 现在问题就简化成了怎么反转两个节点。倒数第一个和最后一个。
    head.next.next = head;
    head.next = null;
    return _head;
};

递归的一些感悟：

递归是缩小问题规模的思维方式。因此我们使用递归，直接看递归结束后的状态，不要关注中间过程，会把人弄晕。
递归函数这一行代码之前之后有很大区别，递归函数之后的代码，变量的状态已经变成递归结束后的状态，具体变成什么样，要看递归函数最后的结束条件是什么。

卡列尼娜翠花
关注
  • 21
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
线性表——链表PPT学习教案.pptx
10-01
链表的操作，如插入和删除，通常比顺序存储的线性表更灵活，因为它们主要涉及到节点之间的指针修改，而不需要像顺序表那样移动大量元素。然而，这也意味着链表的访问速度可能较慢，因为必须从头节点开始遍历，寻找...
线性表——顺序表PPT学习教案.pptx
10-04
线性表——顺序表PPT学习教案 线性表是一种典型的线性结构，其基本特点是线性表中的数据元素是有序且是有限的。线性表可以分为顺序表和链表两种存储结构，今天我们主要讨论顺序表。 1. 线性表的定义 线性表是具有...
线性表——链表的一般功能展示
10-28
对于新手具有参考作用，包括：1.插入一个字符到一个结点中；2.删除一个结点中的字符；3.插入一个结点到链表中；4.删除链表中的一个结点 等
线性表的链式存储——链表（带源码）
05-27
线性表是计算机科学中一种基础的数据结构，它是由n（n≥0）个相同类型元素构成的有限序列。在实际应用中，线性表的元素可以是整型、字符型或其他复杂的数据类型。线性表有两种常见的存储方式：顺序存储和链式存储。...
数据结构之线性表——一元稀疏多项式计算器
04-26
线性表作为数据结构的一种，是最基本的抽象数据类型之一，它由一系列相同类型的元素按照特定顺序排列组成。本话题我们将深入探讨线性表在实现一元稀疏多项式计算器中的应用。 一元稀疏多项式，顾名思义，是一系列...
数据结构(5.3_3)——由遍历序列构造二叉树
m0_65240792的博客
07-25 115
若只给出一棵二叉树的前/中/后/层 序遍历序列中的一种，不能唯一确定一棵二叉树 例：前序遍历序列：DAEFBCHGI 中序遍历序列：DAEFBCHGI
学习记录day19——数据结构 查找算法
weixin_64918301的博客
07-25 200
在给定数据元素的某个值，在查找表中确定一个其关键字等于给定值的数据元素的操作，叫做查找。
数据结构之初始二叉树（4）
我要学编程的博客
07-22 1239
二叉树的前序遍历、二叉树的层序遍历、根据二叉树的前序和中序遍历构造二叉树、二叉树的最近公共祖先、根据二叉树创建字符串
数据结构---二叉树
weixin_47808575的博客
07-22 276
参考：二叉树遍历方法——前、中、后序遍历（图解）_二叉树遍历前序中序后序-CSDN博客
数据结构——二叉树性质
鲸落博客
07-23 388
这个性质很好记忆，观察一下图6-5-5。第一层是根结点，只有一个，所以2^(1-1)=2^0=1。第二层有两个，2^(2-1)=2=2。第三层有四个，2^(3-1)=2^2=4。第四层有八个，2^(4-1)=2^3=8。通过数据归纳法的论证，可以很容易得出在二叉树的第i层上至多有2^(i-1)个结点(i≥1)的结论。
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 703
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构~~顺序表
TU^的博客
07-22 941
定义：顺序表是用一组连续的存储单元依次存储数据元素的线性结构。特点：1. 逻辑顺序与物理顺序一致：元素顺序存储，相邻元素物理位置相邻。2. 可以快速访问任意元素：通过索引直接访问元素。优点：1. 实现简单。2. 随机访问方便。缺点：1. 插入、删除操作可能需要移动大量元素，效率较低。2. 需要预先确定固定的存储空间，可能造成空间浪费或不足。基本操作：包括初始化、插入、删除、查找、遍历等。
【数据结构】搜索二叉树
dab112的博客
07-24 1130
介绍了二叉搜索树的实现与模拟
数据结构：顺序表的实现
2303_81073778的博客
07-25 169
3.test.c文件。
Java实现七大排序（一）
lllsure的博客
07-23 467
插入排序、希尔排序、选择排序、堆排序
【数据结构-前缀和】力扣2550.统计范围内的元音字符串数
sjsjs11的博客
07-22 445
计算前缀和数组的时间是 O(n)，然后计算 q 个查询的答案，计算每个查询的答案的时间是 O(1)，因此时间复杂度是 O(n+q)。输入：words = [“aba”,“bcb”,“ece”,“aa”,“e”], queries = [[0,2],[1,4],[1,1]]输入：words = [“a”,“e”,“i”], queries = [[0,2],[0,1],[2,2]]查询 [1,4] 结果为 3（字符串 “ece”、“aa”、“e”）。返回结果 [2,3,0]。输出：[3,2,1]
EXT4 数据结构
最新发布
弥川的博客
07-25 169
结构 ext4_inode 实际使用的超出最初 128 字节 ext2 inode 的字节数记录在每个 inode 的 i_extra_isize 字段中，这使得结构 ext4_inode 可以在新内核中增长，而无需升级所有磁盘上的 inode。ext4 开始，flex_bg 中几个块组被捆绑在一起作为一个 逻辑块组，bitmap 空间和 inode Table 空间 flex_bg 的第一个块组被扩展为包括位图以及 flex_bg 中所有其他块组的 inode 表。没有 inode 0。
数据结构·红黑树
atlanteep的博客
07-25 572
本节讲解了红黑树的结构和实现，红黑树是通过节点颜色来满足它的前四条规则，使得搜索树近似平衡的。
数据结构和算法入门
weixin_67852890的博客
07-25 971
链表（Linked List）是一种线性数据结构，由一系列节点（Node）组成。每个节点包含两部分：元素值（Element Value）和指向下一个节点的指针（Pointer）。链表可以分为多种类型，如单向链表、双向链表、循环链表等。元素在存储上并不连续。队列是一种基础且广泛应用的线性数据结构，它模拟了现实生活中的排队现象，遵循“先进先出”（First-In-First-Out, FIFO）原则。
高级线性表——静态链表
05-19
静态链表是一种使用数组来实现链表的数据结构。它的本质是利用数组来描述链表中结点之间的关系，数组中的每个元素存储着链表中一个结点的数据和指向下一个结点的指针，而指针则用数组下标来表示。 静态链表的实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值