数据结构与算法（二）之单向链表和双向链表（偏向JS）

最新推荐文章于 2024-05-04 13:33:38 发布
最新推荐文章于 2024-05-04 13:33:38 发布
阅读量230 收藏
点赞数
分类专栏： 数据结构和算法 文章标签： 链表 数据结构 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sue_vivian/article/details/106849930
版权

数据结构（二）

说明：本文基于哔哩哔哩视频【JavaScript数据结构与算法】整理

链表（linked List）

  • 类似于数组（数组在有些语言叫链表）

  • 插入删除性能高

  • 相较于数组的优点： 内存不必要是一整块的内存空间（无序，没有下标），大小可以无限延伸

  • 链表内的元素由 元素本身和指向下一个元素的指针【引用或者连接】组成；

  • 相当于 火车，火车头+车厢+连接，每一节车厢和连接处相当链表中的元素
    在这里插入图片描述

  • 常见的操作

  • append(element)：向列表尾部添加一个新的项

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

  • remove(element)：从列表中移除一项。

  • indexOf(element)：返回元素在列表中的索引。如果列表中没有该元素则返回-1。

  • removeAt(position)：从列表的特定位置移除一项。

  • isEmpty()：如果链表中不包含任何元素，返回true，如果链表长度大于0则返回false。

  • size()：返回链表包含的元素个数。与数组的length属性类似。

  • toString()：由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值。

  • 操作的代码实现

 // 链表的封装（类似数组）
        function linkedList() {
            // node 保存节点信息
            function Node(ele) {
                this.element = ele;
                this.next = null;
            }
            // 属性
            this.head = null;
            this.length = 0;

            // 方法
            linkedList.prototype.append = function(data) {
                var newNode = new Node(data);
                if (this.head == null) {
                    this.head = newNode;
                } else {
                    var current = this.head;
                    while (current.next) {
                        current = current.next;
                    }
                    current.next = newNode;
                }
                this.length += 1; // ++ 大多数语言无法识别
            };
            // 转化为字符串
            linkedList.prototype.toString = function() {
                var current = this.head;
                var listString = "";
                while (current) {
                    listString += " " + current.element;
                    current = current.next;
                }
                return listString.slice(1);
            };
            // 插入
            linkedList.prototype.insert = function(position, data) {
                // 越界判断  界限：>0,length
                if (position < 0 || position > this.length) return false;

                var newnode = new Node(data);
                var current = this.head;

                index = 0;
                if (position == 0) {
                    newnode.next = current;
                    this.head = newnode;
                } else {
                    // 运算符的优先级，先比较再计算,    相当于while 的最后一步，index++
                    while (index++ < position) {
                        privious = current;
                        current = current.next;
                    }
                    // 指针
                    newnode.next = current;
                    privious.next = newnode;
                }
                this.length += 1;
                return true;
            };
            // 获取某个位置的值
            linkedList.prototype.get = function(position) {
                if (position < 0 || position >= this.length) return null;

                var current = this.head;
                var index = 0;
                // 找到特定的位置
                while (index++ < position) {
                    current = current.next;
                }
                return current.element;
            };
            // 获取索引
            linkedList.prototype.indexOf = function(ele) {
                var current = this.head;
                index = 0;
                while (current) {
                    if (current.element == ele) {
                        return index;
                    }
                    index += 1;
                    current = current.next;
                }
                return -1;
            };
            // 修改数据
            linkedList.prototype.update = function(position, data) {
                if (position < 0 || position >= this.length) return null;
                var current = this.head;
                var index = 0;
                while (index++ < position) {
                    current = current.next;
                }
                current.element = data;
            };
            // 删除某个位置的值
            linkedList.prototype.removeAt = function(position) {
                if (position < 0 || position >= this.length) return null;

                var previous = null;
                var current = this.head;
                var previous = null;
                if (position == 0) {
                    this.head = current.next;
                } else {
                    var index = 0;
                    while (index++ < position) {
                        previous = current;
                        current = current.next;
                    }
                    previous.next = current.next;
                }
                this.length -= 1
                return current.element
            };
            // 删除某个值
            linkedList.prototype.remove = function(data) {
                const index = this.indexOf(data)
                return this.removeAt(index)
            };
            // 判断是否为空
            linkedList.prototype.isEmpty = function(data) {
                return this.length == 0
            }
            // 获取链表的长度
            linkedList.prototype.size = function(data) {
                return this.length
            }
        }
		// 测试
        var link = new linkedList();
        link.append("sdfg");
        link.append("sdf是g");
        link.append("sd出生地fg");
        link.toString(); // linkedList {head: Node, length: 1}head: Node {node: "sdfg", next: null}length: 1
        console.log(link, "link");

        link.insert(1, "123");
        link.insert(3, "456");
        // console.log(link.get(0), "get");
        console.log(link.indexOf("123"), "indexof");
        link.update(2, "mk");
        console.log(link, "up");
        console.log(link.removeAt(2), "removeat");
        console.log(link.remove('123'), "remove");
        console.log(link.isEmpty('123'), "isEmpty");
        console.log(link.size('123'), "size");

双向链表（使用较多）

  • 可以从两个方向遍历的链表

  • 缺点：内存空间占用较大，需要操作的指针有四个，相对复杂
    来自网络
    在这里插入图片描述

  • 操作：同 单向链表，不同的如下

  • forwardString（）正向遍历 从后往前

  • backwardString（）反向遍历

  • 相关代码的实现

   // 双向链表
        function DoublyLinkedList() {
            // 内部类：相当于火车的车厢
            function Node(data) {
                this.data = data;
                this.pre = null;
                this.next = null;
            }

            // 大类 双向链表类 的属性
            this.head = null;
            this.tail = null;
            this.length = 0;

            // 双向链表 操作
            DoublyLinkedList.prototype.append = function(data) {
                // 思路
                // 先以传入的元素为基础创建节点，获取这个节点之前的节点pre，让 pre的 next指针指向 这个节点

                const newnode = new Node(data);

                if (this.length == 0) {
                    this.head = newnode;
                    this.tail = newnode;
                } else {
                    newnode.pre = this.tail;
                    this.tail.next = newnode;
                    this.tail = newnode;
                }
                this.length += 1;
            };
            DoublyLinkedList.prototype.forwardString = function() {
                var current = this.tail;
                var res = "";
                while (current) {
                    res += current.data + " ";
                    current = current.pre;
                }
                return res;
            };
            DoublyLinkedList.prototype.backwardString = function() {
                // 向后遍历
                var current = this.head;
                var res = "";
                while (current) {
                    res += current.data + " ";
                    current = current.next;
                }
                return res;
            };
            DoublyLinkedList.prototype.toString = function() {
                this.forwardString();
            };
            DoublyLinkedList.prototype.insert = function(position, data) {
                // 越界判断
                if (position < 0 || position > this.length) return false;
                // 创建节点
                var newnode = new Node(data);

                if (this.length == 0) {
                    this.head = newnode;
                    this.tail = newnode;
                } else {
                    if (position == 0) {
                        this.head.pre = newnode;
                        newnode.next = this.head;
                        this, (head = newnode);
                    } else if (position == this.length) {
                        newnode.pre = this.tail;
                        this.tail.next = newnode;
                        this.tail = newnode;
                    } else {
                        var current = this.head;
                        index = 0;
                        // 找位置
                        while (index++ < position) {
                            current = current.next;
                        }
                        // 找到位置
                        // 修改指针
                        newnode.next = current;
                        newnode.pre = current.pre;
                        // current.pre.next  拿到的是 原来 的pre，不是变成newnode之后的 pre
                        current.pre.next = newnode;
                        current.pre = newnode;
                    }
                }
                this.length += 1;
            };
            DoublyLinkedList.prototype.get = function(position) {
                if (position < 0 || position >= this.length) return false;
                // 较高效率的做法是 二分之后作对比，然后决定顺序还是倒序遍历
                var current = this.head;
                index = 0;
                while (index++ < position) {
                    current = current.next;
                }
                return current.data;
            };
            DoublyLinkedList.prototype.indexOf = function(data) {
                var current = this.head;
                index = 0;
                while (current) {
                    if (current.data == data) {
                        return index;
                    }
                    current = current.next;
                    index++;
                }
                return -1;
            };
            DoublyLinkedList.prototype.update = function(position, data) {
                if (position < 0 || position >= this.length) return false;
                var current = this.head;
                var newData = new Node(data);
                index = 0;
                while (index++ < position) {
                    current = current.next;
                }
                current.data = newData;
                return true;
            };
            DoublyLinkedList.prototype.removeAt = function(position) {
                if (position < 0 || position >= this.length) return null;
                var current = this.head;
                if (this.length == 1) {
                    this.head = thia.tail = null;
                } else {
                    if (position == 0) {
                        this.head.next.pre = null; // 如果删除1 位置的，则，让head 指向为空，并且，重新赋值，指向为删除后的下一个元素
                        this.head = this.head.next;
                    } else if (position == this.length - 1) {
                        this.tail.pre.next = null;
                        this.tail = this.tail.pre;
                    } else {
                        var index = 0;
                        // 找位置
                        while (index++ < position) {
                            current = current.next;
                        }
                        // 找到了
                        current.pre.next = current.next;
                        current.next.pre = current.pre;
                    }
                    this.length -= 1;
                    return current.data;
                }
            };
            DoublyLinkedList.prototype.remove = function(data) {
                var pos = this.indexOf(data);
                return this.removeAt(pos);
            };
            DoublyLinkedList.prototype.isEmpty = function(data) {
                return this.length == 0;
            };
            DoublyLinkedList.prototype.size = function(data) {
                return this.length;
            };
        }
     const doublel = new DoublyLinkedList();
        doublel.append("123");
        doublel.append("456");
        doublel.append("789");
        console.log(doublel, "append");
        console.log(doublel.forwardString(), "forwardString");// 789 456 123  forwardString

        console.log(doublel.backwardString(), "backwardString");// 178 123 456 789  backwardString
        doublel.insert(1, "aaa");
        console.log(doublel, "insert");
        console.log(doublel.get(0), "get");
        console.log(doublel.indexOf("123"), "indexOf");
        doublel.update(0, "mmm");
        console.log(doublel, "up");
        console.log(doublel.removeAt(0), "remove at");
        doublel.remove("456");
        console.log(doublel, "remove ");
        console.log(doublel.isEmpty(), "isEmpty ");
        console.log(doublel.size(), "size ");

其他数据结构可访问以下地址：

数据结构与算法（一）之数组，队列，栈（偏向JS）
数据结构与算法（三）之集合，字典

Sue_9293
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单向链表和双向链表的优缺点及使用场景
qq_36553031的博客
09-28 3万+
单向链表：只有一个指向下一个节点的指针。 优点：单向链表增加删除节点简单。遍历时候不会死循环； 缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。 适用于节点的增加删除。 双向链表：有两个指针，一个指向前一个节点，一个后一个节点。 优点：可以找到前驱和后继，可进可退； 缺点：增加删除节点复杂，需要多分配一个指针存储空间。 适用于需要双向查找节点值的情况。 ...
数据结构：单链表、双链表的区别与实现
不吃鱼的猫的博客
08-05 8768
目录 一、链表 二、单向链表与双向链表的区别 三、单链表的实现 四、双向(循环)链表的实现 一、链表 链表所需要的功能: 初始化 创建新节点 插入 删除 查询 链表的销毁(释放包括头结点在内的空间) 链表的清空（释放除了头结点以外的空间） 链表的优缺点： 优点：链表不需要初始化容量，可以任意加减元素，并且添加与删除元素十分快捷，只需要改变指针域指向的内容即...
数据结构----单向链表和双向链表的那些事(代码实现)
weixin_43142816的博客
07-27 575
(一)链表的定义 用一组任意的存储单元存储线性表的数据元素，这组存储单元可以是连续的，也可以是不连续的 (二)单向链表 1、定义 在数据存储中，使用单一指针(java中称对象)指向下一个存储单元的位置 2、存储结构 3、代码实现 Node.java > /** * 节点 */ public class Node { private Node next; private Object value; public Node getNext() { ret
数据结构——单向链表和双向链表
qq_43587345的博客
07-10 728
数据结构——链表
数据结构与算法:单向链表实现与封装
08-26
今天小编就为大家分享一篇关于数据结构与算法:单向链表实现与封装，小编觉得内容挺不错的，现在分享给大家，具有很好的参考价值，需要的朋友一起跟随小编来看看吧
【Java数据结构与算法】双向链表
12-21
单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面删除单向链表节点时，需要找到temp的下一个节点来删除 如若未了解单链表请参考–>单链表点这里 双向链表示意图如下： 分析双向链表的...
C#数据结构与算法揭秘四 双向链表
12-31
所谓双向链表是如果希望找直接前驱结点和直接后继结点的时间复杂度都是 O(1)，那么，需要在结点中设两个引用域，一个保存直接前驱结点的地址，叫 prev，一个直接后继结点的地址，叫 next，这样的链表就是双向链表...
python数据结构链表之单向链表(实例讲解)
01-21
单向链表也叫单链表，是链表中最简单的一种形式，它的每个节点包含两个域，一个信息域（元素域）和一个链接域。这个链接指向链表中的下一个节点，而最后一个节点的链接域则指向一个空值。 表元素域elem用来存放具体...
C语言学习历程（十六）数据结构-单双向链表
Zhanganliu的博客
12-17 457
数据结构 1.线性表 定义：使用指针将地址链接起来，但是在内存区的物理地址并不一定是连续的。 遍历：必须从头开始走到我们需要的地方；2.顺序表 定义：在内存区内定义一块连续的内存，通过数组的方式来存取，在地址上是连续的。 遍历：顺序访问，可以随机存取；3.链表 *单链表 typedef struct Node { 类型 类型名; }LNode; 当然，类型可以int ，do
数据结构与算法分析：（四）双向链表
riemann_的博客
02-25 1536
一、双向链表介绍 我们上一篇主要介绍了关于单向链表的操作，数据结构与算法分析：（三）单向链表。 我们先来介绍下单向链表与双向链表的一些差异： 1、单向链表 只能从头遍历到尾或者从尾遍历到头(一般从头到尾)。 链表相连的过程是单向的，实现的原理是上一个链表中有一个指向下一个链表的引用。 缺点： a、单向链表不能自我删除，需要先找到被删除节点的前一个节点front，使用front节点来辅助删除，不方...
单链表、双向链表的比较
believe的专栏
11-11 4505
与单链表相比较，双向链表具有如下特点： 　　（1）从任意一个结点开始，可以查找链表中的其他任意结点。 　　（2）既可以依照后继的方向（向后）遍历，也可以依照前驱的方向（向前）遍历。 　　（3）每个指针域中都增加了一个存储指针的空间，降低了存储密度。         （4）可以在当前结点前面或者后面插入，可以删除前趋和后继（包括结点自己）。                  单链表只能在结
（数据结构）说明双链表结构和单链表结构相比较的一个优点和一个缺点
CaoMei_HuaCha的博客
10-23 4062
书中的练习题： 优点：双链表结构比单链表结构更有优越性。 从给定的节点，向左移动到前一个节点， 直接移动到最后一个节点。 缺点：双链表结构中额外的指针，需要一个额外的、线性的内存使用量。  ...
单向链表、双向链表
Dear
07-12 560
单向链表 链表和数组一样，都可以用于存储一系列的元素。链表的每个结点（最后一个结点除外）由一个存储元素本身的结点的数据和一个指向下一个元素的引用（指针）组成。 这有点类似于一个火车，火车的每节车厢都装着自己的东西并连接着下一节车厢（最后一节车厢除外）。 链表通常有一个head 属性（头指针）一直指向第一个结点，最后一个结点指向 null 数组与链表的对比 数组 内存中是一块连续的空间，一般需要提前分配固定的空间大小，空间利用率不高 在数组的起始位置插入和删除数据效率低，改变一个数据需要移动后续所有的数据
js 实现数据结构 -- 链表(LinkedList)
03-25 332
原文： 　　在 Javascript 中学习数据结构与算法。 概念： 　　链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个 元素由一个存储元素本身的节点和一个指向下一个元素的引用(也称指针或链接)组成。下图展示了链表的结构: 　　相对于传统的数组，链表的一个好处在于，添加或移除元素的时候不需要移动其他元素。然而，链表需要使用指针，因此...
左神算法——第07题——反转单向和双向链表
weixin_43338519的博客
07-27 231
1.反转单向链表 class Node{ int value; Node next; public Node(int data){ this.value = data; } } public class e09ReverseList { public static Node reverseList(Node head){ N...
浅谈单链表与双链表的区别
热门推荐
kangxidagege的博客
05-06 7万+
昨天面试官面试的时候问了我一道关于链表的问题：情境如下 面试官：请说一下链表跟数组的区别？ 我：数组静态分配内存，链表动态分配内存；数组在内存中连续，链表不连续；数组利用下标定位，时间复杂度为O(1)，链表定位元素时间复杂度O(n)；数组插入或删除元素的时间复杂度O(n)，链表的时间复杂度O(1)。 根据以上分析可得出数组和链表的优缺点如下：   数组的优点 随机访问性强（通过下标进行...
了解数据结构中的单向链表和双向链表
不愿意透露姓名的网友
05-04 605
链表定义：将元素存放在通过连接构造起来的一系列存储块中 一、单链表 定义：每个节点两部分，即元素区elem和链接区next（指向下一个节点的地址） 第一个节点叫头结点 最后一个节点叫尾结点 尾结点的链接区指向空 # 创建一个节点类 class Node(): def __init__(self, elem, next=None): self.elem =...
[数据结构]——非递归排序总结——笔试爱考
最新发布
小李很执着的博客
05-04 923
创建一个栈ST，并初始化为空。将结束索引end和开始索引开始依次入栈ST。进入循环，直到栈ST为空： a. 从栈ST中弹出两个索引，分别赋值给left和right。b. 调用PartSort3函数，将数组a在[left， right]范围内进行三路划分，返回划分后的基准元素的索引keyi。c. 如果left < keyi - 1，则将keyi - 1和left依次入栈ST，用于后续处理[left， keyi-1]范围内的子数组。
数据结构与算法单向循环链表
09-20
单向循环链表是一种特殊的链表，它与单链表相似，唯一的区别是最后一个节点指向链表的头节点，形成一个环。这种结构可以用来解决需要循环访问的问题，比如约瑟夫环问题。在单向循环链表中，每个节点除了保存数据元素...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值