封装单向链表、双向链表

最新推荐文章于 2024-08-19 15:26:06 发布
最新推荐文章于 2024-08-19 15:26:06 发布
阅读量186 收藏
点赞数 1
文章标签： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53787962/article/details/127000411
版权
这篇博客详细介绍了如何在JavaScript中实现单向链表和双向链表的数据结构，包括节点构造、链表构造、添加、删除、查找和遍历等基本操作。示例代码展示了如何创建链表、在指定位置插入和移除元素，并提供了打印链表的方法。
摘要由CSDN通过智能技术生成

第一部分：封装单向链表

 // 链表中节点的结构

        class Lnode {

            constructor(data) {

                this.data = data;

                this.next = null;

            }

        }

        // 链表的结构

        class LinkList {

            constructor() {

                this.head = null;

                this.len = 0

            }

            // 在链表最后添加新节点

            append(ele) {

                let node = new Lnode(ele);

 

                if (this.head == null) {

                    this.head = node;//添加新节点

                } else {//不为空

                    // 找到最后一个节点

                    let current = this.head;

                    while (current.next != null) {

                        current = current.next;

                    }

                    // 最后一个节点

                    current.next = node;

                }

                this.len++;

            }

 

            //指定位置插入元素

            insert(position, ele) {

                if (position < 0 || position > this.len || !Number.isInteger(position)) return false;

 

                let node = new Lnode(ele);

 

                if (position == 0) {//头部添加元素

                    if (this.head == null) {

                        this.head = node;

                    } else {

                        node.next = this.head;//新节点指向头部节点

                        this.head = node;//指向新节点

                    }

                    this.len++;

                } else if (position == this.len) {//尾巴添加元素

                    this.append(ele);

                } else {//指定位置添加元素

                    let index = 0;

                    let current = this.head;

                    while (index < position - 1) {//查找前一位

                        // 继续查找

                        current = current.next;

                        index++;

                    }

                    // 指向下一位

                    node.next = current.next;

                    current.next = node;//指向新节点

                    this.len++;

                }

            }

            // 指定位置移除元素

            removeAt(position) {

                if (position < 0 || position > this.len - 1 || !Number.isInteger(position)) return false;

 

                if (position == 0) {//移除头部元素

                    this.head = this.head.next;//指向下一个

                } else {

                    let current = this.head;

                    let index = 0;

                    while (index < position - 1) {//查找前一位

                        current = current.next;// 继续查找

                        index++;

                    }

                    current.next = current.next.next;//指向下一个节点.next

                }

                this.len--;

            }

 

 

            // 查找元素的位置

            indexOf(ele) {

                let current = this.head;

                let index = 0;

                while (index < this.len) {

                    if (current.data == ele) {

                        return index;

                    } else {

                        current = current.next;

                        index++;

                    }

                }

                return -1;

            }

 

            // 移除指定的元素

            remove(ele) {

                let in1 = this.indexOf(ele);//查找指定位置

                this.removeAt(in1);//移除

            }

            toString() {

                let current = this.head;

                let index = 0;

                let res = "";

                while (index < this.len) {

                    res += "-" + current.data;//添加元素

                    current = current.next;

                    index++;

                }

                return res.slice(1);//从下标1开始截取

            }

        }

 

        let list = new LinkList();

        // list.append("hello");

        for (let i = 0; i < 4; i++) {

            list.append(i);

        }

        list.insert(2, 2);//0 1 hello 2 3

        list.insert(2, 2);//0 1 hello 2 3

        // list.removeAt(2);//0 1 3

        // console.log(list.indexOf("hello")); //-1

        // console.log(list.indexOf(2)); //2

        // list.remove(2);//0 1 3

        // list.insert(2, "hello");//0 1 hello 3

        // console.log(list.toString());//0-1-2-3

        console.log(list);

 

 

第二部分：封装双向链表

 class Dnode {

            constructor(data) {

                this.pre = null;

                this.data = data;

                this.next = null;

            }

        }

        class DoubleLinkList {

            constructor() {

                this.head = null;

                this.tail = null;

                this.len = 0;

            }

            append(ele) {

               let node = new Dnode(ele);

                if (this.len == 0) {

                    this.head = node;//头节点指向新节点

                    this.tail = node;//尾节点指向新节点

                } else {

                    node.pre = this.tail;

                    this.tail.next = node;

                    this.tail = node;

                }

                this.len++

            }

            insert(position, ele) {

                if (position < 0 || position > this.len || !Number.isInteger(position)) return false

 

                let node = new Dnode(ele);

 

                if (position == 0) {

                    if (this.len == 0) {

                        this.head = node;

                        this.tail = node;

                    } else {

                        node.next = this.head;

                        this.head.pre = node;

                        this.head = node;

                    }

                    this.len++;

                } else if (position == this.len) {

                    this.append(ele);

                } else {

                    let current = this.head, index = 0;

                    while (index < position - 1) {

                        current = current.next;

                        index++;

                    }

 

                    // 新节点练上去

                    node.pre = current;

                    node.next = current.next;

 

                    current.next = node;

                    node.next.pre = node;

                    this.len++;

                }

            }

  // 3.removeAt() 移除指定位置的元素

            removeAt(position) {

                if (position < 0 || position > this.len - 1 || !Number.isInteger(position)) return false

 

                if (position == 0) {

                    this.head = this.head.next;

                    this.head.pre = null;

                } else if (position == this.len - 1) {

                    this.tail = this.tail.pre;

                    this.tail.next = null;

                } else {

                    let current = this.head, index = 0;

                    while (index < position - 1) {

                        current = current.next;

                        index++;

                    }

 

                    current.next = current.next.next;

                    current.next.pre = current;

                }

                this.len--;

            }

 

            // 4.indexOf(ele) 查找元素的位置

            indexOf(ele) {

                let current = this.head;

                let index = 0;

                while (index < this.len) {

                    if (current.data == ele) {

                        return index;

                    } else {

                        current = current.next;

                        index++;

                    }

                }

                return -1;

            }

 

            // 5.remove(ele) 移除指定的元素

            remove(ele) {

                let i1 = this.indexOf(ele);

                this.removeAt(i1);

            }

 

 

            toAfterString() {

                let current = this.head;

                let index = 0;

                let res = "";

 

                while (index < this.len) {

                    res += '-' + current.data;

                    current = current.next;

                    index++;

                }

 

                return res.slice(1);

            }

            toBeforeString() {

                let current = this.tail, index = this.len - 1, res = "";

 

                while (index >= 0) {

                    res += '-' + current.data;

                    current = current.pre;

                    index--;

                }

                return res.slice(1);

            }

        }

 

        let dlist = new DoubleLinkList();

        for (let i = 0; i < 4; i++) {

            dlist.append(i);

        }

        dlist.insert(2, "hello");//0 1 hello 2 3

        // dlist.removeAt(2);//0 1 3

        // console.log(dlist.indexOf(2)); //2

        // dlist.remove(2);//0 1 3

        // dlist.insert(2,"hello");//0 1 hello 3

        // console.log(dlist.toAfterString());//0-1-2-3

        // console.log(dlist.toBeforeString());//3-2-1-0

会给自己买_�
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
单向链表、双向链表
Dear
07-12 595
单向链表 链表和数组一样，都可以用于存储一系列的元素。链表的每个结点（最后一个结点除外）由一个存储元素本身的结点的数据和一个指向下一个元素的引用（指针）组成。 这有点类似于一个火车，火车的每节车厢都装着自己的东西并连接着下一节车厢（最后一节车厢除外）。 链表通常有一个head 属性（头指针）一直指向第一个结点，最后一个结点指向 null 数组与链表的对比 数组 内存中是一块连续的空间，一般需要提前分配固定的空间大小，空间利用率不高 在数组的起始位置插入和删除数据效率低，改变一个数据需要移动后续所有的数据
JavaScript封装单向链表的示例代码
10-14
封装单向链表意味着将这些概念转化为可重用的代码，以便在实际项目中方便地操作链表。下面我们将详细讨论如何在JavaScript中实现这个功能。 首先，我们创建一个名为`LinkList`的类，它将作为链表的容器。在这个类中...
单向链表与双向链表
qq_57106106的博客
07-29 834
可以解决顺序表存储空间上限，插入和删除效率低的问题链表：链式存储的线性表链表的组成：由一个个节点组成节点：由数据域和指针域组成数据域：存放数据的区域指针域：存放下一个节点地址的指针单向链表，双向链表，循环链表只能通过头节点或者头指针单向的访问后继节点的链表，称为单向链表。每个节点的指针域只记录其后继节点的地址。（火车结构）头节点结构体格式：int len；//头节点的数据域普通节点结构体格式：int data；//普通节点的数据域unionint len；//头节点的数据域。
js封装单向链表
qq_33363757的博客
10-20 232
【代码】js封装单向链表。
c++实现单向链表
henjdx的博客
03-26 972
单向链表属于链表中的一类，链表是用于数据元素的线性集合，其中每个元素都指向下一个元素，元素存储上并不连续。单向链表的特性是每个元素只知道其下一个元素是谁。
JavaScript：封装单向链表10种常见的操作方法
零小唬的博客
12-25 437
JavaScript：封装单向链表10种常见的操作方法
每日一课 | 单向链表、双向链表和循环链表图文解析
Python大本营的博客
07-07 1235
02.单向链表、双向链表、循环链表大家好，我是营长，上期给大家分享——数组内存及数组面试常问算法全解析本期分享内容：单向链表、双向链表和循环链表图文解析本期邀请的是春晨溅雨·4位算法工程...
数据结构——单向循环链表&双向循环链表
qq_56668869的博客
08-24 3157
数据结构、单向循环链表、程序实现单向循环链表、方法操作示例、双向循环链表、程序实现双向循环链表
洛谷 B3631 单向链表
qingmengk_k的博客
04-05 793
就用这道题的代码来演示一下单向链表的写法（不会用指针这种数据类型，对于本蒟蒻还是太容易错了）这道题和上一题题意差不太多但是复杂了不少。就这样，拜拜 o((>ω< ))o。
java链表----＞之单向，双向，循环链表
A_cup的博客
01-04 851
对吧，然后这俩都往后移动m-1，这个时候first指向的就是要被嘎的那个，helper指向的是要被嘎的前一个啊！2.单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面我们单链表删除节点时，总是找到要删除的前一个节点的下一个节点来删除的。还有一个删除没写，思路都是差不多的，找到指定数据的位置，然后把前一个节点的next指针指向该数据的next节点。你看你看，咱们在数组中删除和插入数据的时候，后面的数据都得移动，毕竟数据得连续存储，这个链表就不需要，性能不就上升了嘛。
C语言-链表(单向链表、双向链表)
12-17 786
在前面章节已经学习了数组的使用，数组的空间是连续空间，数组的大小恒定的，在很多动态数据存储的应用场景下，使用不方便；而这篇文章介绍的链表结构，支持动态增加节点，释放节点，比较适合存储动态数据的应用场景，而且链表的空间是存储在堆上面的，可以动态分配，释放。从效率上来讲，数组的空间是连续的，查询、读取数据数组占优势；链表的优势在于节点可以动态增加、动态删除，删除支持任意位置的节点删除。
C封装单向循环链表对象1
08-04
编译这个C封装的单向循环链表对象，你需要将`SingleCircularLinkedList.c`和`SingleCircularLinkedList.h`包含在你的项目中，并链接相应的依赖库。使用`gcc`或`clang`等编译器，通过命令行参数指定这些文件进行编译...
数据结构与算法:单向链表实现与封装
08-26
"数据结构与算法：单向链表实现与封装" 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，单向链表是指链表中的每个节点 chỉ指向下一个节点的数据结构。今天，我们将...
用C++实现单向循环链表的解决方法
09-05
接着，我们定义了一个模板类`MyList<T>`来封装链表的操作。这个类包括以下方法： 1. 构造函数：初始化链表，创建一个头节点，其数据域为`NULL`，并将其`next`指针设置为自身，形成循环链表的起始环。 2. 析构函数...
微信小程序骨架屏
djjdjdjdjddjjdjd的博客
08-16 380
⑤ 在onLoad 中页面加载前定义 isLoading.value=true, 在加载完后定义 isLoading.value=false.骨架屏是页面的一个空白版本，通常会在页面完全渲染之前，通过一些灰色的区块大致勾勒出轮廓，待数据加载完成后，再替换成真实的内容。① 在相应微信小程序页面右下角点生成骨架屏，左侧小程序目录会自动生成 .wxml 、.wxss 文件，⑥ 在生成骨架屏页面中 v-if="isLoading" v-else 定义显示与隐藏。
网上商品订单转手系统bootpf
weixin_43213064的博客
08-18 456
【代码】springboot网上商品订单转手系统bootpf
44 个 React 前端面试问题
广漂程序猿DevinRock
08-14 1043
虚拟 DOM 是 React 中的一个概念，其中创建实际 DOM（文档对象模型）的轻量级虚拟表示并将其存储在内存中。它是一种用于优化 Web 应用程序性能的编程技术。当 React 组件的数据或状态发生更改时，虚拟 DOM 会被更新，而不是直接操作真实 DOM。然后，虚拟 DOM 计算组件的先前状态和更新状态之间的差异，称为“比较”过程。一旦识别出差异，React 就会高效地仅更新真实 DOM 的必要部分以反映更改。这种方法最大限度地减少了实际 DOM 操作的数量，并提高了应用程序的整体性能。
Vue3项目-Cesium地图初始化
StupidlyGrass的博客
08-19 90
将node_modules中cesium/Build/Cesium文件夹拷贝至public目录下。3、index.html配置。一、安装、配置Cesium。1、安装Cesium。二、使用Cesium。
Vue :class 绑定可以结合多个判断维度来动态设置类
最新发布
u010865136的专栏
08-19 85
二、:class="[isMute && 'disabled', env.isH5 && 'TUIChat-H5-footer']"一、数组语法允许你根据条件动态添加多个类名。数组中的每个元素可以是一个类名的字符串，或者是一个对象。对象中的键是类名，值是布尔值。
c语言用类封装单向链表
06-10
C语言中没有类的概念，但可以使用结构体和函数指针来实现链表的封装，下面是一个简单的单向链表封装示例。 ```c #include #include typedef struct _node { int value; struct _node* next; } ListNode; ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值