JS数据结构3：链表

最新推荐文章于 2024-07-09 23:17:59 发布
最新推荐文章于 2024-07-09 23:17:59 发布
阅读量108 收藏
点赞数
分类专栏： JS数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44145258/article/details/106382431
版权

文章目录

单链表链表结构的实现

在这里插入图片描述

class Node {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

class LinkedList {
    constructor() {
        this.length = 0;
        this.head = null;
    }

    equalsFn(a, b) {
        return a === b;
    }
}

功能

  1. push(element)：向链表尾部添加一个新元素。
  2. insert(element, position)：向链表的特定位置插入一个新元素。
  3. getElementAt(index)：返回链表中特定位置的元素。如果链表中不存在这样的元素，则返回undefined。
  4. remove(element)：从链表中移除一个元素。
  5. indexOf(element)：返回元素在链表中的索引。如果链表中没有该元素则返回-1。
  6. removeAt(position)：从链表的特定位置移除一个元素。
  7. isEmpty()：如果链表中不包含任何元素，返回true，如果链表长度大于0 则返回false。
  8. size()：返回链表包含的元素个数，与数组的length 属性类似。
  9. toString()：返回表示整个链表的字符串。由于列表项使用了Node 类，就需要重写继承自JavaScript 对象默认的toString 方法，让其只输出元素的值。

push

    push(val) {
        let newNode = new Node(val);
        let curr;
        if (!this.head) {   // 刚开始链表为空，就把这个设置为head
            this.head = newNode;
        } else {
            curr = this.head;
            while (curr.next) {    // 一直找到链表末尾
                curr = curr.next;
            }
            curr.next = newNode;
        }
        this.length++;
    }

removeAt

在这里插入图片描述

    removeAt(index) {
        if (index < this.length && index >= 0) {
            let curr = this.head;
            if (index === 0) {
                this.head = curr.next;
            } else {
                // 找到index前一个后停止，下一个就是要删除的结点
                for (let i = 1; i < index; i++) {
                    curr = curr.next;
                }
                let beRemove = curr.next;
                // 改变要被删除结点的上一个结点的指向
                curr.next = beRemove.next;
                this.length--;
                return beRemove;
            }
        }
    }

getElementAt

    getElementAt(index) {
        if (index < this.length && index >= 0) {
            let curr = this.head;
            if (index === 0) return curr;
            else {
                for (let i = 1; i <= index; i++) {
                    curr = curr.next;
                }
                return curr;
            }
        }
    }

重写removeAt

    removeAt(index) {
        let curr = this.getElementAt(index - 1);
        curr.next = curr.next.next;

insert

在这里插入图片描述

    insert(index, value) {
        let newNode = new Node(value);
        if (index < this.length && index >= 0) {
            let curr = this.head;
            if (index === 0) {  // index 为0，改变头结点指向就行了
                this.head = newNode;
                this.head.next = curr;
            } else {
                // 找到插入位置的前一个，
                for (let i = 1; i < index; i++) {
                    curr = curr.next;
                }
                let nextNode = curr.next;
                curr.next = newNode;
                newNode.next = nextNode;
            }
            this.length++;
        }
    }

indexOf

    indexOf(value) {
        let curr = this.head;   // 存入head
        if (this.equalsFn(curr.value, value)) {
            return 0;
        }
        for (let i = 1; i < this.length; i++) {
            curr = curr.next;
            if (this.equalsFn(curr.value, value)) {
                return i;
            }
        }

        return -1;
    }

removeValue

    removeValue(value) {
        let curr = this.head;
        let prev = null;
        if (this.equalsFn(curr.value, value)) {
            this.head = curr.next;
            this.length--;
        }
        for (let i = 1; i < this.length; i++) {
            prev = curr;
            curr = curr.next;
            if (this.equalsFn(curr.value, value)) {
                prev.next = curr.next;
                this.length--;
            }
        }
        return undefined;
    }

toString

    toString() {
        let objString = "";
        let curr = this.head;
        if (!curr) {
            return objString;
        } else {
            objString = `${curr.value}`;
            for (let i = 1; i < this.length; i++) {
                curr = curr.next;
                objString = `${objString}, ${curr.value}`;
            }
            return objString;
        }
    }

完整代码

class Node {
    constructor(value) {
        this.value = value;
        this.next = null;
    }
}

class LinkedList {
    constructor() {
        this.length = 0;
        this.head = null;
    }

    equalsFn(a, b) {
        return a === b;
    }

    push(val) {
        let newNode = new Node(val);
        let curr;
        if (!this.head) {   // 刚开始链表为空，就把这个设置为head
            this.head = newNode;
        } else {
            curr = this.head;
            while (curr.next) {    // 一直找到链表末尾
                curr = curr.next;
            }
            curr.next = newNode;
        }
        this.length++;
    }

    removeAt(index) {

        let curr = this.getElementAt(index - 1);
        curr.next = curr.next.next;
    }

    getElementAt(index) {
        if (index < this.length && index >= 0) {
            let curr = this.head;
            if (index === 0) return curr;
            else {
                for (let i = 1; i <= index; i++) {
                    curr = curr.next;
                }
                return curr;
            }
        }
    }

    insert(index, value) {
        let newNode = new Node(value);
        if (index < this.length && index >= 0) {
            let curr = this.head;
            if (index === 0) {  // index 为0，改变头结点指向就行了
                this.head = newNode;
                this.head.next = curr;
            } else {
                // 找到插入位置的前一个，
                for (let i = 1; i < index; i++) {
                    curr = curr.next;
                }
                let nextNode = curr.next;
                curr.next = newNode;
                newNode.next = nextNode;
            }
            this.length++;
        } else {
            throw "索引值错误";
        }
    }

    indexOf(value) {
        let curr = this.head;   // 存入head
        if (this.equalsFn(curr.value, value)) {
            return 0;
        }
        for (let i = 1; i < this.length; i++) {
            curr = curr.next;
            if (this.equalsFn(curr.value, value)) {
                return i;
            }
        }

        return -1;
    }

    removeValue(value) {
        let curr = this.head;
        let prev = null;
        if (this.equalsFn(curr.value, value)) {
            this.head = curr.next;
            this.length--;
        }
        for (let i = 1; i < this.length; i++) {
            prev = curr;
            curr = curr.next;
            if (this.equalsFn(curr.value, value)) {
                prev.next = curr.next;
                this.length--;
            }
        }
        return undefined;
    }

    toString() {
        let objString = "";
        let curr = this.head;
        if (!curr) {
            return objString;
        } else {
            objString = `${curr.value}`;
            for (let i = 1; i < this.length; i++) {
                curr = curr.next;
                objString = `${objString}, ${curr.value}`;
            }
            return objString;
        }
    }

    getHead() {
        return this.head;
    }

    isEmpty() {
        return this.length === 0 ? true : false;
    }

    size() {
        return this.length;
    }
}

let linkedList = new LinkedList();
linkedList.push("a");
linkedList.push("b");
linkedList.push("c");
// linkedList.removeAt(1);
linkedList.insert(1, "aa");
console.log(linkedList.getElementAt(2));
console.log(linkedList.indexOf("a"));
console.log(linkedList.removeValue("c"));
console.log(linkedList.size());
console.log(linkedList.isEmpty());
console.log(linkedList);
console.log(linkedList.toString());

双向链表的实现

在这里插入图片描述

class Node {
    constructor(value) {
        this.value = value;
        this.next = null;
        this.prev = null;
    }
}

class DBLinkedList {
    constructor() {
        this.length = 0;
        this.head = null;
    }

    equalsFn(a, b) {
        return a === b;
    }
}

双向链表需要讨论的情况

  1. 当结点为头结点时
  2. 当结点为最后一个结点时
  3. 当结点有且只有一个结点时

重构链表方法

class Node {
    constructor(value) {
        this.value = value;
        this.next = null;
        this.prev = null;
    }
}

class DBLinkedList {
    constructor() {
        this.length = 0;
        this.head = null;
    }

    equalsFn(a, b) {
        return a === b;
    }

    push(val) {
        let newNode = new Node(val);
        let prev = this.head;
        let curr;
        if (!this.head) {   // 刚开始链表为空，就把这个设置为head
            this.head = newNode;
        } else {
            curr = this.head;
            while (curr.next) {    // 一直找到链表末尾
                curr = curr.next;
                prev = curr;
            }
            curr.next = newNode;
            newNode.prev = prev;
        }
        this.length++;
    }

    removeAt(index) {
        if (index < this.length && index >= 0) {
            let curr = this.head;
            if (index === 0) {
                this.head = curr.next;
                if (this.length !== 1) {
                    this.head.prev = null;
                }
                this.length--;
            } else {
                // 找到index前一个后停止，下一个就是要删除的结点
                for (let i = 1; i < index; i++) {
                    curr = curr.next;
                }
                let beRemove = curr.next;
                // 改变要被删除结点的上一个结点的指向
                curr.next = beRemove.next;
                if (index !== this.length - 1) {
                    beRemove.next.prev = curr;
                }
                this.length--;
                return beRemove;
            }
        }
    }

    getElementAt(index) {
        if (index < this.length && index >= 0) {
            let curr = this.head;
            if (index === 0) return curr;
            else {
                for (let i = 1; i <= index; i++) {
                    curr = curr.next;
                }
                return curr;
            }
        }
    }

    insert(index, value) {
        let newNode = new Node(value);
        if (index < this.length && index >= 0) {
            let curr = this.head;
            if (index === 0) {  // index 为0，改变头结点指向就行了
                this.head = newNode;
                this.head.next = curr;
                if (this.length > 1) {
                    this.head.prev = null;
                }
            } else {
                // 找到插入位置的前一个，
                for (let i = 1; i < index; i++) {
                    curr = curr.next;
                }
                let nextNode = curr.next;
                curr.next = newNode;
                newNode.prev = curr;
                newNode.next = nextNode;
                if (index !== this.length - 1) {
                    nextNode.prev = newNode;
                }
            }
            this.length++;
        } else {
            throw "索引值错误";
        }
    }

    indexOf(value) {
        let curr = this.head;   // 存入head
        if (this.equalsFn(curr.value, value)) {
            return 0;
        }
        for (let i = 1; i < this.length; i++) {
            curr = curr.next;
            if (this.equalsFn(curr.value, value)) {
                return i;
            }
        }

        return -1;
    }

    removeValue(value) {
        let curr = this.head;
        let prev = null;
        if (this.equalsFn(curr.value, value)) {
            this.head = curr.next;
            if (this.head) {
                this.head.prev = null;
            }
            this.length--;
        }
        for (let i = 1; i < this.length; i++) {
            prev = curr;
            curr = curr.next;
            if (this.equalsFn(curr.value, value)) {
                prev.next = curr.next;
                if (curr.next) {
                    curr.next.prev = prev;
                }
                this.length--;
            }
        }
        return undefined;
    }

    toString() {
        let objString = "";
        let curr = this.head;
        if (!curr) {
            return objString;
        } else {
            objString = `${curr.value}`;
            for (let i = 1; i < this.length; i++) {
                curr = curr.next;
                objString = `${objString}, ${curr.value}`;
            }
            return objString;
        }
    }

    getHead() {
        return this.head;
    }

    isEmpty() {
        return this.length === 0 ? true : false;
    }

    size() {
        return this.length;
    }
}

循环链表的概念

在这里插入图片描述

  • 循环链表可以像链表一样只有单向引用，也可以像双向链表一样有双向引用。
  • 循环链表和链表之间唯一的区别在于，最后一个元素指向下一个元素的指针不是引用undefined，而是指向第一个元素（head）
斜光
关注
专栏目录
JavaScript数据结构——链表
郊眠寺
05-30 1274
前言 嘿，掘友们！今天我们来了解并实现数据结构 —— 链表。 本文主要内容 单向链表 双向链表 循环链表 链表 要存储多个元素，数组可能是最常用的数据结构。但是这种数据结构有一个缺点，数组的大小是固定的，从数组的起点或中间插入或移除的成本很高，因为需要移动元素。 链表存储有序的元素集合，不同于数组的是，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（指针或链接）组成。下图是一个链表的结构。 相比数组，链表的一个好处在于，添加或移除元素的时候不需要移动其
JavaScript中数据结构与算法(三)：链表
12-02
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和数据结构的实现。相对于数组，链表在处理动态数据变化时具有显著优势。在JavaScript中，由于数组的优化，如快速的push、pop、shift和unshift等操作...
JS 数据结构：链表
weixin_46015333的博客
11-24 4235
本文介绍了什么是链表以及他的优缺点，并分别介绍了单链表、双向链表和循环链表之间的细微差别和各自的特点，一些有明显差异的操作都分别给出了图和代码，更易于理解和实践。
js数据结构与算法：链表
m0_51311990的博客
06-20 1426
目录1.链表初认识1.1链表1.2为什么使用链表2.链表的各种方法2.1搭建链表2.2 push()2.3 removeAt(index)2.4 getElement(index)2.5 isEmpty()和size()2.6 toString()3.使用链表并总结3.1使用链表3.2总结 head用作指向第一个元素的指针（引用）node里面的value代表数据，next代表指向下一项的指针当node.next指向的为空时，代表此时的node为最后一个元素链表的最后一个元素，他的next指向一定是undef
javascript：数据结构——链表
weixin_42924369的博客
08-23 394
什么是链表？ 链表是有序的列表， 链表是以节点的方式来存储，是链式存储。 每个节点包含item域，next指针（指向下一个节点），即就是链表中的每一个元素都带有下一个元素的位置(next) 链表的节点不一定连续存储，是离散的状态 双向链表 每个链表不仅带有next这一项，还有previous这一项 双向循环列表 链表操作 1、添加（指定添加元素 尾部添加元素） 2、移除（指定位置(下标)移除元素 移除元素元素） 链表尾添加元素 1、如果链表为空的情况下，给链表尾添加元素，同时要把链表头
在JavaScript中的数据结构（链表）
肥晨开发的学习之路
06-16 1588
链表是多个元素组成的列表，元素存储不连续，用next指针连接到一起，JS中没有链表，但是可以用Object模拟链表。
数据结构：链表的基本用法（逆置）
study_jiang_up的博客
11-17 2633
单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。
深入理解基本数据结构：链表详解
qq_40254606的博客
07-09 1183
链表是一种线性数据结构，由一系列节点组成，每个节点包含数据和指向下一个节点的指针。链表的特点是节点在内存中不一定是连续存储的。链表作为一种重要的数据结构，具有动态大小插入和删除操作高效不连续存储和随机访问不方便的特点。通过对链表的基本操作和实现的学习，我们可以更好地理解和使用链表。在实际编程中，链表的应用广泛且灵活，是每个程序员都必须掌握的基础知识。
js(JavaScript)数据结构之链表（Linked List）
星辰迷上大海的博客
01-12 1718
链表（Linked List）是一种常见的数据结构，它由一系列节点组成，每个节点都包含了数据和指向下一个节点的指针。
JS数据结构:链表
Preshine
09-17 375
数组不总是组织数据的最佳数据结构，原因如下。在很多编程语言中，数组的长度是固定的，所以当数组已被数据填满时，再要加入新的元素就会非常困难。在数组中，添加和删除元素也很麻烦，因为需要将其他元素向前或向后平移。然后JavaScript的数组并不存在上述问题，因为使用splice()方法不需要再访问数组中其他元素了。
JS数据结构学习：链表
weixin_33717298的博客
02-23 54
在存储多个元素时，我们最常用的数据结构可能是数组，究其原因可能是数组访问方便，可以直接通过[]访问，但是数组也存在一定的缺点，数组的大小是固定，数组在执行插入或者删除的时候成本很高。链表存储的是有序的元素集合，和数组不同的是，链表中的元素在内存并不是连续放置，每个元素由一个存储元素本身的节点和一个指向下一个元素的引用组成，结构如下图所示：...
数据结构-使用javascript讲解数据结构之链表.zip
02-12
本资料包“数据结构-使用javascript讲解数据结构之链表.zip”将深入探讨链表的概念、实现以及其在JavaScript中的应用。 链表不同于数组，数组是连续的内存空间，而链表的元素在内存中是非连续存储的。每个元素称为...
基于asp.net的教师授课系统设计与实现.docx
最新发布
09-27
基于asp.net的教师授课系统设计与实现.docx
基于Springboot和Vue的精简博客系统源码 精简博客系统代码（程序，中文注释）
09-27
精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统-精简博客系统 1、资源说明：精简博客系统源码，本资源内项目代码都经过测试运行成功，功能ok的情况下才上传的。 2、适用人群：计算机相关专业(如计算计、信息安全、大数据、人工智能、通信、物联网、自动化、电子信息等)在校学生、专业老师或者企业员工等学习者，作为参考资料，进行参考学习使用。 3、资源用途：本资源具有较高的学习借鉴价值，可以作为“参考资料”，注意不是“定制需求”，代码只能作为学习参考，不能完全复制照搬。需要有一定的基础，能够看懂代码，能够自行调试代码，能够自行添加功能修改代码。 4. 最新计算机软件毕业设计选题大全(文章底部有博主联系方式): https://blog.csdn.net/2301_79206800/article/details/135931154 技术栈、环境、工具、软件： ① 系统环境:Windows ② 开发语言：Java ③ 框架：SpringBoot ④ 架构:B/S、MVC ⑤ 开发环境:IDE
基于asp.net的客户资源管理系统设计与实现.docx
09-27
基于asp.net的客户资源管理系统设计与实现.docx
嵌入式开发入门指南：硬件基础与软件实践
09-27
嵌入式系统是集成了计算机硬件和软件的专用计算系统，广泛应用于各种设备和行业，如家电、汽车、医疗设备和工业自动化等。嵌入式开发涉及
基于若依3.8.7版本的Java+Vue全栈框架设计源码
09-27
该项目是一款基于若依3.8.7版本的Java+Vue全栈框架设计源码，包含609个文件，涵盖259个Java源文件、95个Vue组件、87个SVG文件、76个JavaScript文件、28个XML配置文件、13个Vue模板文件、9个SCSS样式文件、7个批处理文件、5个YAML配置文件、4个PNG图片文件。该源码集成了lombok、knife4j、mybatis-plus等实用库，并需自行掌握具体实现细节。
基于React、Ant Design、Dva、Umi的SpringBlade前端UI项目设计源码
09-27
本项目是一款基于React、Ant Design、Dva、Umi框架构建的SpringBlade前端UI系统源码，旨在快速开发企业级中后台业务。项目包含536个文件，涵盖329个JavaScript文件、74个Markdown文件、61个LESS样式文件、38个TypeScript文件、10个JSON配置文件、4个YAML配置文件、4个PNG图片文件以及少量其他配置和忽略文件。该系统适用于快速构建高效的中后台界面，官网信息可访问：https://bladex.cn
JavaScript数据结构与算法：链表详解
"本文主要探讨了JavaScript中的链表数据结构，包括单链表、静态链表、循环链表和双向链表。文章通过代码实例详细解释了如何在JavaScript中实现链表的增加和删除操作，并对比了链表与数组的区别。" 在JavaScript中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值