javascript 链表(lineked lists)算法与说明

最新推荐文章于 2023-03-21 21:34:36 发布
最新推荐文章于 2023-03-21 21:34:36 发布
阅读量1.1k 收藏 2
点赞数 1
分类专栏： 算法 文章标签： javascript 链表 es6 linkerlist 指针
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/rth362147773/article/details/77951773
版权

链表的介绍

链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称为指针或链接）组成。下图讲解：

相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。然而，链表需要使用指针，因此实现链表的时候需要注意。数组的另一个细节是可以直接访问任何位置元素，而要想访问链表中间的一个元素，需要从起点（表头）开始送达列表直到找到所需要元素。

现实实例就是火车，火车有多节车厢相互衔接，通过接轨来链接火车。车厢就是链表的元素，而接轨就是指针。

链表算法实例

1.链表增删改查。

let list = new LinkedList();
list.append(15);
list.append(10);
list.append(13);//15,10,13
list.indexOf(10);//1
list.removeAt(1)//15,13
list.insert(1,17);//15,17,13
list.remove(11);//17,13


ES6链表实现代码：

let LinkedList = (function () {

    class Node {//一个节点
        constructor(element){
            this.element = element;
            this.next = null;
        }
    }

    const length = new WeakMap();
    const head = new WeakMap();

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

        append(element) {//向列表尾部添加一个新的项
            let node = new Node(element),
                current;

            if (this.getHead() === null) { 
                head.set(this, node);
            } else {

                current = this.getHead();

                while (current.next) {
                    current = current.next;
                }

                current.next = node;
            }

            let l = this.size();
            l++;
            length.set(this, l);
        }

        insert(position, element) {//向列表的特定位置插入一个新的项

            if (position >= 0 && position <= this.size()) {

                let node = new Node(element),
                    current = this.getHead(),
                    previous,
                    index = 0;

                if (position === 0) { 
                    node.next = current;
                    head.set(this, node);
                } else {
                    while (index++ < position) {
                        previous = current;
                        current = current.next;
                    }
                    node.next = current;
                    previous.next = node;
                }
                let l = this.size();
                l++;
                length.set(this, l);

                return true;

            } else {
                return false;
            }
        }

        removeAt(position) {//从列表的特定位置移除一项
            if (position > -1 && position < this.size()) {

                let current = this.getHead(),
                    previous,
                    index = 0;

                if (position === 0) {
                    head.set(this, current.next);
                } else {

                    while (index++ < position) {

                        previous = current;
                        current = current.next;
                    }

                    previous.next = current.next;
                }

                let l = this.size();
                l--;
                length.set(this, l);

                return current.element;

            } else {
                return null;
            }
        }

        remove(element) {//移除一项

            let index = this.indexOf(element);
            return this.removeAt(index);
        }

        indexOf(element) {//返回元素在列表中的索引，没有返回-1

            let current = this.getHead(),
                index = 0;

            while (current) {
                if (element === current.element) {
                    return index;
                }
                index++;
                current = current.next;
            }

            return -1;
        }

        isEmpty() {//链表不包含任何元素，返回true，如果长度大于0返回false
            return this.size() === 0;
        }

        size() {//返回链表包含的元素个数
            return length.get(this);
        }

        getHead() {//获取链头项
            return head.get(this);
        }

        toString() {//已string输出链表
            let current = this.getHead(),
                string = '';

            while (current) {
                string += current.element + (current.next ? ', ' : '');
                current = current.next;
            }
            return string;

        }

        print() {//string格式打印到控制台上。
            console.log(this.toString());
        }
    }

    return LinkedList;
})();



双向链表

双向链表和普通链表的区别在于。在链表中，一个节点只有链向下一个节点的链接，而在双向链表中，链接是双向的：一个链向下一个元素，另一个链向前一个元素。如下图：


这里写图片描述

双向链表提供了两种送代列表的方法：从头到尾，或者反过来。我们也可以访问一个特定节点的下一个或前一个元素。在单向链表中，如果送代列表时错过了要找的元素，就需要回到列表起点，重新开始送代。这是双向链表的一个优点。


事例：

let list = new DoublyLinkedList();
list.append(15);
list.append(16);//15,16
list.print();//15,16
list.printInverse();//16, 15
list.insert(0,13);//13,15,16
list.removeAt(0);//15,16



ES6代码实例：

let DoublyLinkedList = (function () {

    class Node {
        constructor(element) {
            this.element = element;
            this.next = null;
            this.prev = null; //NEW
        }
    }

    const length = new WeakMap();
    const head = new WeakMap();
    const tail = new WeakMap(); //NEW

    class DoublyLinkedList {

        constructor () {
            length.set(this, 0);
            head.set(this, null);
            tail.set(this, null);
        }

        append(element) {

            let node = new Node(element),
                current, _tail;

            if (this.getHead() === null) { //first node on list
                head.set(this, node);
                tail.set(this, node); //NEW
            } else {
                //attach to the tail node //NEW
                _tail = this.getTail();
                _tail.next = node;
                node.prev = _tail;
                tail.set(this, node);
            }

            //update size of list
            let l = this.size();
            l++;
            length.set(this, l);
        }

        insert(position, element) {

            //check for out-of-bounds values
            if (position >= 0 && position <= this.size()) {

                let node = new Node(element),
                    current = this.getHead(),
                    previous,
                    index = 0;

                if (position === 0) { //add on first position

                    if (!this.getHead()) {       //NEW
                        head.set(this, node);
                        tail.set(this, node);
                    } else {
                        node.next = current;
                        current.prev = node; //NEW {1}
                        head.set(this, node);
                    }

                } else if (position === this.size()) { //last item //NEW

                    current = tail;     // {2}
                    current.next = node;
                    node.prev = current;
                    tail.set(this, node);

                } else {
                    while (index++ < position) { //{3}
                        previous = current;
                        current = current.next;
                    }
                    node.next = current;
                    previous.next = node;

                    current.prev = node; //NEW
                    node.prev = previous; //NEW
                }

                //update size of list
                let l = this.size();
                l++;
                length.set(this, l);

                return true;

            } else {
                return false;
            }
        }

        removeAt(position) {

            //check for out-of-bounds values
            if (position > -1 && position < this.size()) {

                let _head = this.getHead(),
                    _tail = this.getTail(),
                    current = _head,
                    previous,
                    index = 0;

                //removing first item
                if (position === 0) {

                    _head = current.next; // {1}

                    //if there is only one item, then we update tail as well //NEW
                    if (this.size() === 1) { // {2}
                        _tail = null;
                    } else {
                        _head.prev = null; // {3}
                    }

                } else if (position === this.size() - 1) { //last item //NEW

                    current = _tail; // {4}
                    _tail = current.prev;
                    _tail.next = null;

                } else {

                    while (index++ < position) { // {5}

                        previous = current;
                        current = current.next;
                    }

                    //link previous with current's next - skip it to remove
                    previous.next = current.next; // {6}
                    current.next.prev = previous; //NEW
                }

                head.set(this,_head);
                tail.set(this,_tail);

                //update size of list
                let l = this.size();
                l--;
                length.set(this, l);

                return current.element;

            } else {
                return null;
            }
        }

        remove(element) {

            let index = this.indexOf(element);
            return this.removeAt(index);
        }

        indexOf(element) {

            let current = this.getHead(),
                index = -1;

            //check first item
            if (element == current.element) {
                return 0;
            }

            index++;

            //check in the middle of the list
            while (current.next) {

                if (element == current.element) {
                    return index;
                }

                current = current.next;
                index++;
            }

            //check last item
            if (element == current.element) {
                return index;
            }

            return -1;
        }

        isEmpty() {
            return this.size() === 0;
        }

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

        toString() {

            let current = this.getHead(),
                s = current ? current.element : '';

            while (current && current.next) {
                current = current.next;
                s += ', ' + current.element;
            }

            return s;
        }

        inverseToString() {

            let current = this.getTail(),
                s = current ? current.element : '';

            while (current && current.prev) {
                current = current.prev;
                s += ', ' + current.element;
            }

            return s;
        }

        print() {
            console.log(this.toString());
        }

        printInverse() {
            console.log(this.inverseToString());
        }

        getHead() {
            return head.get(this);
        }

        getTail() {
            return tail.get(this);
        }
    }
    return DoublyLinkedList;
})();



循环链表

循环链表。就是最后一个元素指向不是null，而是指向第一个元素（head）。如下图。




实例用法：

let circularLinkedList = new CircularLinkedList();
circularLinkedList.append(15);
circularLinkedList.append(16);//15,16
circularLinkedList.insert(0,14);//14,15,16
circularLinkedList.removeAt(0);//15,16
circularLinkedList.indexOf(16)//1



ES6循环链表实例：

let CircularLinkedList = (function () {

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

    const length = new WeakMap();
    const head = new WeakMap();

    class CircularLinkedList {

        constructor () {
            length.set(this, 0);
            head.set(this, null);
        }

        append(element) {

            let node = new Node(element),
                current;

            if (this.getHead() === null) { //first node on list
                head.set(this, node);
            } else {

                current = this.getHead();

                //loop the list until find last item
                while (current.next !== this.getHead()) { //last element will be head instead of NULL
                    current = current.next;
                }

                //get last item and assign next to added item to make the link
                current.next = node;
            }

            //set node.next to head - to have circular list
            node.next = this.getHead();

            //update size of list
            let l = this.size();
            l++;
            length.set(this, l);
        }

        insert(position, element) {

            //check for out-of-bounds values
            if (position >= 0 && position <= this.size()) {

                let node = new Node(element),
                    current = this.getHead(),
                    previous,
                    index = 0;

              if (position === 0) { //add on first position

                    node.next = current;

                    //update last element
                    while (current.next !== this.getHead()) { //last element will be head instead of NULL
                        current = current.next;
                    }

                    head.set(this, node);
                    current.next = this.getHead();

                } else {
                    while (index++ < position) {
                        previous = current;
                        current = current.next;
                    }
                    node.next = current;
                    previous.next = node;
                }

                //update size of list
                let l = this.size();
                l++;
                length.set(this, l);

                return true;

            } else {
                return false;
            }
        }

        removeAt(position) {

            //check for out-of-bounds values
            if (position > -1 && position < this.size()) {

                let current = this.getHead(),
                    previous,
                    index = 0;

                //removing first item
                if (position === 0) {

                    while (current.next !== this.getHead()) { //needs to update last element first
                        current = current.next;
                    }

                    head.set(this, this.getHead().next);
                    current.next = this.getHead();

                } else { //no need to update last element for circular list

                    while (index++ < position) {

                        previous = current;
                        current = current.next;
                    }

                    //link previous with current's next - skip it to remove
                    previous.next = current.next;
                }

                let l = this.size();
                l--;
                length.set(this, l);

                return current.element;

            } else {
                return null;
            }
        }

        remove(element) {

            let index = indexOf(element);
            return removeAt(index);
        }

        indexOf(element) {

            let current = this.getHead(),
                index = -1;

            //check first item
            if (element == current.element) {
                return 0;
            }

            index++;

            //check in the middle of the list
            while (current.next !== this.getHead()) {

                if (element == current.element) {
                    return index;
                }

                current = current.next;
                index++;
            }

            //check last item
            if (element == current.element) {
                return index;
            }

            return -1;
        }

        isEmpty() {
            return this.size() === 0;
        }

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

        getHead() {
            return head.get(this);
        }

        toString() {

            let current = this.getHead(),
                s = current.element;

            while (current.next !== this.getHead()) {
                current = current.next;
                s += ', ' + current.element;
            }

            return s.toString();
        }

        print() {
            console.log(this.toString());
        }
    }
    return CircularLinkedList;
})();
JarunWang
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript 链表结构
yuan的博客
04-14 156
其实上面我们已经简单的提过了链表的结构, 我们这里更加详细的分析一下.链表类似于火车: 有一个火车头, 火车头会连接一个节点, 节点上有乘客, 并且这个节点会连接下一个节点, 以此类推.链表的火车结构:链表的数据结构。
JavaScript数据结构与算法之链表
10-22
这与JavaScript中的数组不同，数组在内存中是连续分配的，且支持快速随机访问，但在动态扩展时可能会导致内存碎片。 链表主要有两种类型：单向链表和双向链表。单向链表每个节点仅包含一个指向下一个节点的指针，而...
JavaScript【链表】
m0_63077733的博客
03-21 1631
双向链表：既可以从头遍历到尾，又可以从尾遍历到头。也就是说链表连接的过程是双向的，它的实现原理是：一个节点既有向前连接的引用，也有一个向后连接的引用。每次在插入或删除某个节点时，都需要处理四个引用，而不是两个，实现起来会困难些；相对于单向链表，所占内存空间更大一些；但是，相对于双向链表的便利性而言，这些缺点微不足道。双向链表不仅有head指针指向第一个节点，而且有tail指针指向最后一个节点；item储存数据、prev指向前一个节点、next指向后一个节点；
js实现链表
ssjjrr的博客
02-02 941
js实现链表
JavaScript(ES6)数据结构与算法——链表
FL_csdn1的博客
08-23 345
链表和数组一样，可以用于存储一系列的元素，但是列表和数组的实现机制完全不同。 在学习链表之前我们先了解一下数组的不足（缺点）： 要存储多个元素，数组可能是最常用的数据结构。几乎每一种编程语言都有默认实现的数组结构，数组的创建通常需要申请一段连续的内存空间，并且大小是固定的（大多数语言是固定的），所以当数组不能满足容量需求时，需要扩容，一般情况下是申请一个更大的数组，将原来数组中元素复制过去。而且数组开头或中间位置插入数据的成本很高，需要进行大量元素的位移。尽管JavaScript中的Array类可以帮助我
JavaScript 数据结构【链表】
qq_44810886的博客
05-03 1284
一、单向链表 只能从头到尾或者从尾遍历到头 封装单向链表： function LinkedList() { //内部的类：节点类 function Node(data) { this.data = data; this.next = null } //属性 this.head = null; .
JavaScript中数据结构与算法(三)：链表
10-24
链表是一种重要的数据结构，它在JavaScript中常用于解决特定问题，特别是在...在JavaScript中，由于数组的优化，链表可能不是首选的数据结构，但在某些特定场景下，如避免数组扩容或实现特定的算法时，链表仍然有价值。
数据结构与算法 c语言 线性表-静态链表
最新发布
04-27
数据结构与算法 c语言 线性表-静态链表 静态链表源码
JavaScript 链表定义与使用方法示例
11-21
了解并熟练掌握链表的概念和操作对于JavaScript开发者来说非常重要，因为它可以帮助我们设计和实现更高效的数据结构和算法。例如，在解决动态规划问题、图论问题或模拟某些复杂逻辑时，链表可能是理想的工具。此外，...
javascript实现链表
aboutcjp的博客
03-05 639
javascript中数组是对象，所以在效率上，会差一点。所以有的时候可以选择链表。javascript原生是没有链表的，不过我们可以自己写一个对象，来模拟链表。 链表主要特点是:每个节点，都会指向它的后继。我们可以通过一个对象来定义 function node(e){ this.element=e; this.next=null; }//节点对象 node，element是指节点值，
JS实现链表
Sco_jing的博客
06-18 4062
链表
JavaScript实现链表（单链表，双向链表）
IT_10的博客
10-08 514
单链表 &lt;script&gt; //单链表 function Node(element) { this.element=element; this.next=null; } function LList() { this.head=new Node("he...
反转链表JavaScript
热门推荐
韦编的博客
07-23 1万+
反转一个单链表。题目详细描述：https://leetcode-cn.com/problems/reverse-linked-list/description/ 此题目依旧是为了熟悉JavaScript链表的操作。 反转链表的思路：1-2-3-4-5，先将2换到第一个，变为：2-1-3-4-5。然后将3换到第一个，3-2-1-4-5。以此类推。其中，p始终指向1，q指向p的下一个，即本轮需...
javascript链表_使用javascript的链表初学者指南
weixin_26735419的博客
10-10 333
javascript链表了解链接列表(Understanding Linked Lists) Even as a beginner user of JavaScript, chances are you have come across data structures like arrays, strings and objects. You may or may not have known t...
数据结构学习--链表
weixin_34128534的博客
02-14 276
1、什么是链表？ 链表是物理存储单元上非连续的、非顺序的存储结构，不同于栈和队列。链表由一系列节点组成，每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O...
JavaScript单向链表（ES6）
weixin_33883178的博客
08-04 435
关键词：链表 单向链表 JavaScript实现单向链表 数据结构与算法 创刊号 在前端领域摸爬打滚了几年了，自认为前端知识有点积累了，后端知识也涉猎，但是离大神还是有差距的。很多积累知识点都用云笔记记录的，现在打算慢慢的网掘金上迁移。一是希望能通过整理这些知识点，让自己更加系统化的理解这些知识。二是希望某些知识点能帮忙到大家。 好了废话不多说，现在开始进入今天主题《单向链表》。 一、什么是单...
js 实现链表和树的结构
lulula的博客
10-28 3603
最近在学习es6 所以代码主要使用了es6的一些东西 链表的设计 我们设计链表包含两个类，一个是 Node 类用来表示节点，另一个事 LinkedList 类提供插入节点、删除节点等一些操作。 /** * 一般的语言实现链表都需要指针来实现 * 而js的引用类型本来就是按值引用的 * 变量中保存的实质上是一个指向其对应对象的一个...
javascript中的链表结构
weixin_34122810的博客
09-17 120
1.定义 　　很多编程语言中数组的长度是固定的，就是定义数组的时候需要定义数组的长度，所以当数组已经被数据填满的时候，需要再加入新的元素就很困难。只能说在部分变成语言中会有这种情况，在javascript中和php中数组的长度是可以任意增加的。在数组中添加和删除元素也是比较麻烦，因为要将数组中其他元素向前或者向后平移，这个在javascript中也不是问题，javascript中有一个很方便的方...
javascript链表_JavaScript链表小指南
编程故事的地方
02-04 111
javascript链表 什么是数据结构？ 数据结构是一种组织存储在计算机中的数据的方式，以便可以有效地使用它。 链表 ，顾名思义，是节点的链表，链表的头是列表中的第一个节点，而尾部是最后一个节点。 每个节点都有对上一个和下一个节点的引用/指针。 链表数据结构有两种类型，第一种是单链表，这种类型的节点有一个指向下一个的指针，但没有指向其上一个节点的指针。 在本文中，我们将探...
数据结构精讲：链表操作与算法实现
"这篇资料主要涉及数据结构中的一个重要部分——链表，以及与链表相关的算法问题。内容涵盖了单链表的各种操作，如反转、查找特定位置的元素、找到链表中间元素、删除节点、合并两个有序链表、处理二级链表、交换...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值