js实现数据结构—链表

最新推荐文章于 2024-01-12 07:15:00 发布
原创 最新推荐文章于 2024-01-12 07:15:00 发布 · 244 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#链表 #前端

本文深入探讨了链表数据结构的实现，包括单链表和双向链表的构造函数，详细解释了节点的创建、数据的追加、插入、删除等操作，并提供了查找和打印链表元素的方法。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

一、单链表构造函数

function LinkedList() {

    /**
     * 数据节点构造函数
     *
     * @param {*} data
     */
    function Node(data) {
        this.data = data;
        this.next = null;
    }

    let length = 0;

    let head = null;
    let tail = null;

    /**
     * 链表尾部追加数据
     *
     * @param {*} item
     */
    this.append = function (item) {

        const newNode = new Node(item);

        if (0 < length) {
            tail.next = newNode;
            tail = newNode;
        } else {
            head = tail = newNode;
        }

        length++;

    };

    /**
     * 在指定索引位置的前面插入数据
     *
     * @param {number} index 指定的索引位置
     * @param {*} item
     * @returns {boolean} 返回是否成功
     */
    this.insert = function (index, item) {

        if (0 <= index && index <= length) {

            const newNode = new Node(item);

            if (0 < index && index < length) {

                // 在中间添加
                let prevNode = null;
                let targetNode = head;

                let prevIndex = 0;
                while ((prevIndex++) < index) {
                    prevNode = targetNode;
                    targetNode = targetNode.next;
                }

                prevNode.next = newNode;
                newNode.next = targetNode;

            } else if (0 === index) {

                // 在头部添加
                newNode.next = head;
                head = newNode;

            } else {

                // 在尾部添加
                this.append(item);

            }

            length++;

            return true;

        } else {

            return false;

        }

    };

    /**
     * 删除指定索引位置处的数据项。发生错误将throw一个Error
     *
     * @param {number} index 指定的索引位置
     * @returns {*} 返回被删除的数据
     */
    this.remove = function (index) {

        if (0 <= index && index < length) {

            let targetNode;

            if (0 < index) {

                // 删除非头部
                let prevNode = null;
                targetNode = head;

                let prevIndex = 0;
                while ((prevIndex++) < index) {
                    prevNode = targetNode;
                    targetNode = targetNode.next;
                }

                prevNode.next = targetNode.next;
                targetNode.next = null;

                // 如果删除的是最后一个，把tail指向倒数第二个
                if ((1 + index) === length) {
                    tail = prevNode;
                }

            } else if (0 === index) {

                targetNode = head;

                // 删除头部
                const nextNode = targetNode.next;
                targetNode.next = null;

                head = nextNode;

            }

            length--;

            return targetNode.data;

        } else {

            throw new RangeError(`out of range: must between 0 and ${length}`);

        }

    };

    /**
     * 查找数据项在链表中的索引位置
     *
     * @param {*} item
     * @returns {number} 索引位置，不存在则返回-1
     */
    this.indexOf = function (item) {

        let prevIndex = 0;

        let targetNode = head;
        while (!!targetNode) {
            if (item !== targetNode.data) {
                targetNode = targetNode.next;
                prevIndex++;
            } else {
                return prevIndex;
            }
        }

        return -1;

    };

    /**
     * 顺序打印出链表中的所有节点数据
     *
     */
    this.print = function () {

        let index = 0;

        let targetNode = head;
        while (!!targetNode) {
            console.log('[', index++, ']=>', targetNode.data);
            targetNode = targetNode.next;
        }

    };

    /**
     * 查找单链表中的第K个节点
     *
     * @param {number} index 索引位置
     * @returns {*} index位置的数据
     */
    this.findByIndex = function (index) {

        if (0 <= index && index < length) {

            let targetNode = head;
            while (0 < (index--)) {
                targetNode = targetNode.next;
            }

            return targetNode.data;

        } else {
            throw new RangeError(`out of range: must between 0 and ${length}`);
        }

    };

    /**
     * 查找单链表的中间位置的节点
     *
     * @returns {*} index位置的数据
     */
    this.findMiddle = function () {

        const index = Math.round(length / 2) - 1;

        return this.findByIndex(index);

    };

}

二、实现双向链表的构造函数


function DoubleLinkedList() {
    let length=0,
        head=null,
        tail=null;


    /**
     * 数据节点构造函数
     *
     * @param {*} data
     */
    function Node(data) {

        this.data=data;
        this.next=null;
        this.previous=null;
    }

    /**
     * 链表尾部追加数据
     *
     * @param {*} item
     */
    this.append = function (item) {
        let newNode=new Node(item);
        //空链表
        if(null===head){
            head=newNode;
            tail=head;
        }else{
            tail.next=newNode;
            tail=newNode;
        }
        length++;
    };

    /**
     * 在指定索引位置的前面插入数据
     *
     * @param {number} index 指定的索引位置
     * @param {*} item
     */
    this.insert = function (index, item) {
        let newNode=new Node(item),
            current=head,
            previous=null,
            insetIndex=0;

        if(index < 0 || index > length){
            return false
        }else {
            //在第一个位置添加
            if(0 === index){
                newNode.next=current;
                current.previous=newNode;
                head=newNode
            }else if(index === index){
                //在末尾添加
                current=tail;
                current.next=newNode;
                newNode.previous=current;
                tail=newNode;
            }else {

                while (insetIndex < index){
                    previous=current;
                    current=current.next;
                    insetIndex++;
                }
                previous.next=newNode;
                newNode.previous=previous;
                newNode.next=current;
                current.previous=newNode;

            }
            length++;

        }
    };

    /**
     * 删除指定索引位置处的数据项
     *
     * @param {number} index 指定的索引位置
     */
    this.remove = function (index) {
        if (0 <= index && index < length) {
            let targetNode;
            if (0 < index) {
                // 删除非头部
                let prevNode = null;
                targetNode = head;
                let prevIndex = 0;
                while ((prevIndex++) < index) {
                    prevNode = targetNode;
                    targetNode = targetNode.next;
                }
                prevNode.next = targetNode.next;
                if (!!targetNode.next) {
                    targetNode.next.prev = prevNode;
                }
                targetNode.prev = null;
                targetNode.next = null;
                // 如果删除的是最后一个，把tail指向倒数第二个
                if ((1 + index) === length) {
                    tail = prevNode;
                }
            } else if (0 === index) {
                targetNode = head;
               // 删除头部
                const nextNode = targetNode.next;
                nextNode.prev = null;
                head = nextNode;
                targetNode.next = null;
            }
            length--;
            return targetNode.data;

        } else {

            throw new RangeError(`out of range: must between 0 and ${length}`);
        }
    };
    /**
     * 顺序打印出链表中的所有节点数据
     *
     */
     this.print = function () {

        console.log('顺序打印');

        let index = 0;

        let targetNode = head;
        while (!!targetNode) {
            console.log('[', index++, ']=>', targetNode.data);
            targetNode = targetNode.next;
        }

    };

    /**
     * 逆序打印出链表中的所有节点数据
     *
     */
     this.reversePrint = function () {

        console.log('逆序打印');

        let index = length - 1;

        let targetNode = tail;
        while (!!targetNode) {
            console.log('[', index--, ']=>', targetNode.data);
            targetNode = targetNode.prev;
        }

    };
}
JavaScript数据结构——链表
郊眠寺
05-30 1393
前言 嘿，掘友们！今天我们来了解并实现数据结构 —— 链表。 本文主要内容 单向链表 双向链表 循环链表 链表 要存储多个元素，数组可能是最常用的数据结构。但是这种数据结构有一个缺点，数组的大小是固定的，从数组的起点或中间插入或移除的成本很高，因为需要移动元素。 链表存储有序的元素集合，不同于数组的是，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（指针或链接）组成。下图是一个链表的结构。 相比数组，链表的一个好处在于，添加或移除元素的时候不需要移动其
JavaScript数据结构之链表的实现
10-20
总之，理解和掌握链表的实现对于提升JavaScript编程能力，特别是在设计复杂数据结构和算法时，都是非常有益的。在JavaScript中，我们可以利用面向对象编程的思想，创建自定义的链表类来满足特定需求。
js数据结构之链表
sharryling
04-15 182
单向链表： 双向链表： /* 链表 */ function Node(element) { this.element = element; //当前节点的元素 this.next = null; //下一个节点链接 } function LList () { this.head = new Node( 'head' ); //头节点 t...
JS 数据结构：链表
weixin_46015333的博客
11-24 4333
本文介绍了什么是链表以及他的优缺点，并分别介绍了单链表、双向链表和循环链表之间的细微差别和各自的特点，一些有明显差异的操作都分别给出了图和代码，更易于理解和实践。
js(JavaScript)数据结构之链表（Linked List）
星辰迷上大海的博客
01-12 2408
链表（Linked List）是一种常见的数据结构，它由一系列节点组成，每个节点都包含了数据和指向下一个节点的指针。
JavaScript数据结构之链表
橘猫吃不胖的博客
08-13 281
JavaScript数据结构之链表 1 数组与链表的优缺点 2 什么是链表 3 封装链表结构 4 向链表尾部添加一个新的项 5 向链表某个位置插入一个新的项 6 获取对应位置的元素 7 获取元素在链表中的索引 8 修改某个位置的元素 9 从链表中删除某位置节点 10 全部代码......
数据结构-使用javascript讲解数据结构之链表.zip
最新发布
02-12
本资料包“数据结构-使用javascript讲解数据结构之链表.zip”将深入探讨链表的概念、实现以及其在JavaScript中的应用。 链表不同于数组，数组是连续的内存空间，而链表的元素在内存中是非连续存储的。每个元素称为...
JavaScript数据结构链表知识详解
10-21
链表是一种重要的数据结构，它在JavaScript中被广泛用于实现高效的数据操作，特别是在需要频繁进行插入和删除操作的场景。链表与数组的主要区别在于，数组中的元素在内存中是连续存储的，而链表中的元素则分散在不同...
JavaScript实现的链表数据结构实例
10-24
以下是一个JavaScript实现的链表数据结构实例，包括链表的基本操作以及排序功能。 首先，我们定义了一个`Node`构造函数，用于创建链表中的节点。每个节点有两个属性：`data`用于存储数据，`next`用于指向下一个节点...
javascript：数据结构——链表
weixin_42924369的博客
08-23 456
什么是链表？ 链表是有序的列表， 链表是以节点的方式来存储，是链式存储。 每个节点包含item域，next指针（指向下一个节点），即就是链表中的每一个元素都带有下一个元素的位置(next) 链表的节点不一定连续存储，是离散的状态 双向链表 每个链表不仅带有next这一项，还有previous这一项 双向循环列表 链表操作 1、添加（指定添加元素 尾部添加元素） 2、移除（指定位置(下标)移除元素 移除元素元素） 链表尾添加元素 1、如果链表为空的情况下，给链表尾添加元素，同时要把链表头
JS数据结构与算法_链表
weixin_34152820的博客
01-22 203
上一篇：JS数据结构与算法_栈&队列下一篇：JS数据结构与算法_集合&字典 写在前面 说明：JS数据结构与算法 系列文章的代码和示例均可在此找到 上一篇博客发布以后，仅几天的时间竟然成为了我写博客以来点赞数最多的一篇博客。欢喜之余，不由得思考背后的原因，前端er离数据结构与算法太遥远了，论坛里也少有人去专门为数据结构与算法...
JS实现链表数据结构
q1312882392的博客
08-15 477
链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用(指针或链接)组成。 链表的一个好处在于，添加或者移除元素的时候不需要移动其他的元素。然而链表需要使用指针。数组可以直接访问任何位置的元素，而链表想要访问中间的一个元素，需要从起点(表头)开始迭代，直到找到所需的元素。 function LinkList(){ ...
js数据结构和算法(三)链表（linked list）
汉堡请不要欺负面条
03-20 1456
链表是一种常见的数据结构，也属于线性表，但不会按线性的顺序来储存数据。而是在每一个节点中，储存了下一个节点的指针。可以看图理解。使用链表结构可以克服数组需要预先知道数据大小的缺点，链表结构可以充分利用计算机内存空间，实现灵活的内存动态管理。链表一般有，单链表、静态链表、循环链表、双向链表1.单链表：就是很单一的向下传递，每一个节点只记录下一个节点的信息，就跟无间道中的梁朝伟一样做卧底都是通过中间人...
js数据结构 -- 链表, 双向链表，循环链表
xiaobing_hope的专栏
05-19 1479
数组作为js常用的数据结构，存取元素都非常的方便，但是其内部的实现原理跟其他计算机语言对数组的实现都是一样的。 由于数组在内存中的存储是连续的，所以当在数组的开头或者中间插入元素时，内部都需要去移动其他元素的位置，这个移动其他元素的成本很高。 而链表存储有序的元素集合，但不同于数组，链表中的元素在内存中的存放并不是连续的，每个元素有一个存储元素自身的节点和一个指向下一个元素引用（也称为指针）的...
js版数据结构_04链表（1）
宫小白
04-05 159
js版数据结构_04链表（1） 从本篇开始我将用三篇博文写总结js对链表的操作 在本篇博文你会了解到： 什么是链表 单链表的实现 1.什么是链表 这种东西有什么优点，先说说数组。所有的高级语言都有数组这一数据结构吧，我们都清除数组是一块地址连续的储存单元。以c为例，声明数组的变量名便是储存了这片连续空间的首地址。因为它连续我们可以很方便的存取数组中的每一个元素，但是我想增删元素呢。它的...
JS实现单链表
落枫秋歌
09-19 853
函数功能：实现单链表的初始化，插入节点、删除节点、查找节点和删除节点功能；/** * 单链表构造函数 */ function LinkedList () { this.ptr = null; this.head = null; this.length = 0; this.insert = insertNode; this.delete = deleteNod
JavaScript实现链表、双向链表、循环链表
weixin_41387874的博客
05-05 265
链表JS代码实现 function Node(element) //生成新结点的构造函数 { this.val = element; //数据域 this.next = null; //指向下一个结点 } function Linkedlist() //链表的构造函数 { this.head = new Node("head"); //每一个链表都存在头结点 this.find = function(target) //找到数据域为target的结点 {
JavaScript实现链表结构
li1522532686的博客
06-15 301
JavaScript实现链表结构
有一个无聊的人用JavaScript封装了单向链表LinkedList构造函数
DDboom的博客
06-15 401
都说对于程序员，数据结构算法才是ta的核心竞争力。 然而作为一个野蛮自学的JavaScript的拥护者，我，旦旦boom，至今还没对算法进攻，真是愧对csdn这么多资源。我有罪，我反省orz 栈和队列就直接跳过了，直接来搞链表的封装。 JavaScript中的构造函数 总所周知，js是没有类class这个东西的，虽然ES6提供了class的书写方式，但本质上也是用函数模拟出来的。 ...
JavaScript实现链表数据结构详解
本资源主要讲解了数据结构中的一个非常重要的概念——链表，以及如何使用JavaScript语言来实现链表的各种操作。 链表是一种物理存储单元上非连续、非顺序的存储结构，由一系列节点组成，每个节点都包含数据部分和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值