数据结构（JS实现）——单链表的实现

最新推荐文章于 2023-02-15 05:53:03 发布
最新推荐文章于 2023-02-15 05:53:03 发布
阅读量336 收藏 1
点赞数 1
分类专栏： 数据结构 文章标签： 链表 列表 数据结构 javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/M_Edison/article/details/113360325
版权

文章目录

一、什么是单链表？

单链表是一种链式存取的结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成为：元素（数据元素的映像）+指针（指示后继元素的存储位置），元素就是存储数据的储存单元，指针就是连接每个结点的地址数据。
在这里插入图片描述

二、单链表的封装

    // 封装链表类
    function LinkedList() {
        // 内部的类：节点类
        function Node(data) {
            this.data=data;
            this.next=null;
        }

        // 属性
        this.head=null;
        this.length=0;
        
    }

三、单链表常见的操作（增删改查）

  1. append(element)：向链表尾部添加一个新的项
  2. insert(position,element):向链表的特定位置插入一个新的项
  3. get(position):获取对应位置的元素
  4. indexOf(element):返回元素在列表上的索引。如果链表上没有该元素则返回-1
  5. updata（position，element）：更新某个元素
  6. removeAt（position）：从链表的特定位置移除一项（根据位置）
  7. remove(element);从链表移除一项（根据元素）
  8. isEmpty():如果链表中不包含任何元素，返回true，如果链表长度大于0则返回false。
  9. size():返回链表包含的元素个数。
  10. tostring():输出

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

步骤：

1.创建新的节点（newNode）

2.判断是否添加的是第一个节点

2.1 是第一个节点

2.2不是第一个节点

2.2.1 找到最后一个节点（使用current游标）

2.2.2 将最后一个节点的next指向新的节点

在这里插入图片描述

  LinkedList.prototype.append=function(data){
             // 1.创建新的节点
            var newNode=new Node(data);
             // 2.判断是否添加的是第一个节点
            if (this.length==0) {
                  // 2.1 是第一个节点
                  this.head=newNode;
            } else {
                 // 2.2不是第一个节点
                 var current=this.head;
                  // 2.2.1 找到最后一个节点
                 while (current.next) {
                     current=current.next
                 }
                  // 2.2.2 将最后一个节点的next指向新的节点
                  current.next=newNode;
            }     
              this.length+=1;
        }

3.2 insert(position,element):向链表的特定位置插入一个新的项

步骤：

1.对position进行越界判断

2.根据data创建newNode

3.判断插入的位置是否为第一个

3.1如图（插在第一位）

3.2如图（插在其他位）

3.1：（插在第一位）

在这里插入图片描述

3.2（插在其他位）

在这里插入图片描述

 /* insert()：插入 */
        LinkedList.prototype.insert = function (position, data) {
            // 1.对position进行越界判断
            if (position < 0 && position > this.length) {
                return false
            }
            // 2.根据data创建newNode
            var newNode = new Node(data);
            // 3.判断插入的位置是否为第一个
            if (position == 0) {
                // 3.1如图（插在第一位）
                newNode.next =this.head
                this.head = newNode;
            } else {
                // 3.2如图（插在其他位）
                var index=0;
                var current=this.head;
                var previous=null;
                // 将index停在position节点处
                while (index<position) {
                    previous=current;
                    current=current.next;
                    index+=1;
                }
                // 懂？
                newNode.next=current;
                previous.next=newNode;
            }
            this.length+=1;
            return true;
        }

3.3 get(position):获取对应位置的元素

步骤：

1.对position进行越界判断

2.获取data

/* get(position):获取对应位置的元素 */
        LinkedList.prototype.get=function(position){
            // 越界判断
            if (position < 0 || position >=this.length) {
                return null;
            }
            // 获取想应data
            var index=0;
            var current=this.head;
            while (index<position) {
                current=current.next;
                index++;
            }
            return current.data;
        }

3.4 indexOf(element):返回元素在列表上的索引。如果链表上没有该元素则返回-1

步骤：

循环，比较

LinkedList.prototype.indexOf=function(element){
            var index=0;
            var current=this.head;
            console.log(this.length);
            while (index<this.length) {//或者while(current)
                if (current.data==element) {
                    return index;
                }
                current=current.next;
                index+=1
            }
            return -1;
        }

3.5 undata（position，element）：修改某个元素的位置

步骤：

1.越界判断

2.查找正确的节点

3.将position位置的node的data修改为newData

 LinkedList.prototype.updata=function(position,element){
            //对position进行越界判断
            if (position<0||position>=this.length) {
                return false;
            }
            var current=this.head;
            var index=0;
            //查找正确的节点
            while (index<position) {
                current=current.next;
                index+=1;
            }
            //将position位置的node的data修改为newData
            current.data=element;
            return true;
        }

3.6 removeAt（position）：从链表的特定位置移除一项 （根据位置）

步骤

1.对position进行越界判断

2.判断删除节点类型（position为0）

3.让前一个的next指向current的next

在这里插入图片描述

LinkedList.prototype.removeAt = function (position) {
            //1.对position进行越界判断
            if (position < 0 || position >= this.length) {
                return false;
            }
            // 2.判断删除节点类型
            if (position == 0) {
                this.head = this.head.next;
            } else {
                var current = this.head;
                var index = 0;
                var previous = null;
                while (index < position) {
                    previous = current;
                    current = current.next;
                    index++;
                }
                //3. 让前一个的next指向current的next
                previous.next = current.next;
                current.next = null;
            }
            this.length-=1;
            return true;
        }

3.7 remove(element);从链表移除一项 （根据元素）

步骤：（可直接用removeAt和indexOf结合使用）

获取位置

删除元素

 LinkedList.prototype.remove=function(element){
            var index=0;
            var current=this.head;
            var previous=null;
            while (current) {
                if (current.data==element) {
                    if (index==0) {
                        this.head=this.head.next;
                    } else {
                        previous.next=current.next;
                    }
                    this.length-=1;
                    return true;
                }
                previous=current;
                current=current.next;
                index+=1;
            }
            return -1;
        }

3.8 isEmpty():判空

LinkedList.prototype.isEmpty = function () {
            return this.length==0;
        }

3.9 size():返回链表包含的元素个数。

 LinkedList.prototype.size = function () {
            return this.length;
        }

3.10 tostring():输出

步骤：

1.定义游标

2.循环获取

LinkedList.prototype.tostring=function(){
            // 定义游标
            var currrent=this.head;
            var stringsub="";
            // 循环获取   
            while(currrent){
                stringsub+=currrent.data+" ";
                currrent=currrent.next;
            }
            return stringsub;
        }

四. 源码

   <!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>单向列表</title>
</head>

<body>
</body>
<script>
    // 封装链表类
    function LinkedList() {
        // 内部的类：节点类
        function Node(data) {
            this.data = data;
            this.next = null;
        }
        // 属性
        this.head = null;
        this.length = 0;

        /*  append(element)：向链表尾部添加一个新的项 */
        LinkedList.prototype.append = function (data) {
            // 1.创建新的节点
            var newNode = new Node(data);
            // 2.判断是否添加的是第一个节点
            if (this.length == 0) {
                // 2.1 是第一个节点
                this.head = newNode;
            } else {
                // 2.2不是第一个节点
                var current = this.head;
                // 2.2.1 找到最后一个节点
                while (current.next) {
                    current = current.next
                }
                // 2.2.2 将最后一个节点的next指向新的节点
                current.next = newNode;

            }
            this.length += 1;
        }
        /*   tostring():输出 */
        LinkedList.prototype.tostring = function () {
            // 定义游标
            var currrent = this.head;
            var stringsub = "";
            // 循环获取   
            while (currrent) {
                stringsub += currrent.data + " ";
                currrent = currrent.next;
            }
            return stringsub;
        }

        /* insert()：插入 */
        LinkedList.prototype.insert = function (position, data) {
            // 1.对position进行越界判断
            if (position < 0 && position > this.length) {
                return false
            }
            // 2.根据data创建newNode
            var newNode = new Node(data);
            // 3.判断插入的位置是否为第一个
            if (position == 0) {
                // 3.1如图（插在第一位）
                newNode.next = this.head
                this.head = newNode;
            } else {
                // 3.2如图（插在其他位）
                var index = 0;
                var current = this.head;
                var previous = null;
                // 将index停在position节点处
                while (index < position) {
                    previous = current;
                    current = current.next;
                    index += 1;
                }
                // 懂？
                newNode.next = current;
                previous.next = newNode;
            }
            this.length += 1;
            return true;
        }
        /* get(position):获取对应位置的元素 */
        LinkedList.prototype.get = function (position) {
            // 越界判断
            if (position < 0 || position >= this.length) {
                return null;
            }
            // 获取想应data
            var index = 0;
            var current = this.head;
            while (index < position) {
                current = current.next;
                index++;
            }
            return current.data;
        }



        /* indexOf(element):返回元素在列表上的索引。如果链表上没有该元素则返回-1 */
        LinkedList.prototype.indexOf = function (element) {
            var index = 0;
            var current = this.head;
            console.log(this.length);
            while (index < this.length) {//或者while(current)
                if (current.data == element) {
                    return index;
                }
                current = current.next;
                index += 1
            }
            return -1;
        }

        /* undata（position，element）：修改某个元素的位置 */
        LinkedList.prototype.updata = function (position, element) {
            //对position进行越界判断
            if (position < 0 || position >= this.length) {
                return false;
            }
            var current = this.head;
            var index = 0;
            //查找正确的节点
            while (index < position) {
                current = current.next;
                index += 1;
            }
            //将position位置的node的data修改为newData
            current.data = element;
            return true;
        }



        /*removeAt（position）：从链表的特定位置移除一项（根据位置） */
        LinkedList.prototype.removeAt = function (position) {
            //1.对position进行越界判断
            if (position < 0 || position >= this.length) {
                return false;
            }
            // 2.判断删除节点类型
            if (position == 0) {
                this.head = this.head.next;
            } else {
                var current = this.head;
                var index = 0;
                var previous = null;
                while (index < position) {
                    previous = current;
                    current = current.next;
                    index++;
                }
                //3. 让前一个的next指向current的next
                previous.next = current.next;
                current.next = null;
            }
            this.length -= 1;
            return true;
        }

        /* remove(element);从链表移除一项（根据元素） */
        LinkedList.prototype.remove = function (element) {
            var index = 0;
            var current = this.head;
            var previous = null;
            while (current) {
                if (current.data == element) {
                    if (index == 0) {
                        this.head = this.head.next;
                    } else {
                        previous.next = current.next;
                    }
                    this.length -= 1;
                    return true;
                }
                previous = current;
                current = current.next;
                index += 1;
            }
            return -1;
        }

        /* size():长度 */
        LinkedList.prototype.size = function () {
            return this.length;
        }

        /* isEmpty():长度 */
        LinkedList.prototype.isEmpty = function () {
            return this.length==0;
        }

    }
    var list = new LinkedList();
    list.append('abc');
    list.append('cbb');
    list.append('axx');
    console.log(list.tostring());
    console.log(list.remove(' sss'));
    console.log(list.tostring());
    console.log(list.size());
    console.log(list.isEmpty());
    console.log(list);
</script>
</html>
小牲口online
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
【JS数据结构】单向链表
早睡早起长头发的博客
10-18 603
一. 认识链表 1.数组 1.1 数组的优点 1.2 数组的缺点 2.链表 2.1 相对于数组, 链表有一些优点 2.2 相对于数组, 链表有一些缺点 3.什么是链表 3.1 链表的火车结构 3.2 链表的数据结构 3.3 给火车加上数据后的结构 二. 链表封装 1.创建链表类 1.1 创建一个链表类 1.2 代码解析 2.链表常见操作 2.1append(element)尾部追加数据 2.2 toString()转成字符串 2.3 insert(position
JavaScript 数据结构与算法（六）单向链表
weixin_42572968的博客
03-25 269
JavaScript 数据结构与算法（六）单向链表 认识链表 链表和数组 链表和数组一样，可以用于存储一系列的元素，但是链表和数组的实现机制完全不同。 数组 存储多个元素，数组（或列表）可能是最常用的数据结构。 几乎每一种编程语言都有默认实现数组结构，提供了一个便利的 [] 语法来访问数组元素。 数组缺点： 数组的创建需要申请一段连续的内存空间(一整块内存)，并且大小是固定的，当前数组不能满足容量需求时，需要扩容。 (一般情况下是申请一个更大的数组，比如 2 倍，然后将原数组中的元素复制过去)
用JS实现链表 --单链表
最新发布
weixin_43850639的博客
02-15 969
用JS实现单链表
leetcode给单链表加一js实现-javascript-algorithms:用JavaScript编写的经典计算机科学范式、算法和方法的
06-30
leetcode 给单链表加一js实现JavaScript 中的计算机科学 该存储库包含不同著名计算机科学算法的 JavaScript 实现。 同样在下面，您将找到按主题关系的依赖性划分的问题的解决方案。 描述 用 JavaScript 编写的经典计算机科学范式、算法和方法的集合。 还包含描述和特征：运行时间或复杂性。 不使用 JavaScript 的内置方法，例如 sort()、reverse() 等。解决方案还包括测量时间复杂度。 演示 托管在 GitHub 页面上， 发展 技术，，，带有语法高亮。 通过npm test运行的npm test 这个项目是引导的 作者 于 17 年 12 月 21 日开始 复杂性术语 象征 名称 表现 Ω 大欧米茄 最佳情况性能 θ 大θ 平均数 哦 大哦 最差 Javascript 实现的主要数据结构 字符串操作 复杂： 时间 空间 迭代，2 次循环 O(n^2) 0（？） 大批 数组内置方法 复杂： 时间 空间 推 O(1) 0(1) 流行音乐 O(1) 0(1) 转移 上） 0(1) 不移位 上） 0(1) 删除 上） 0(1) 反向、拼接、切
JS实现单向链表添加元素
weixin_44054325的博客
03-11 941
用来声明插入链表中元素的构造。 function Node(ele){//定义链表中的一个元素 this.ele = ele;//值 this.next = null;//用来指向下一个节点的指针 } 定义链表及其方法 function LinkList(){//定义链表 let length = 0; let head = null; //链表方法 this.appe...
如何用JavaScript实现功能齐全的单链表详解
10-17
总的来说，用JavaScript实现功能齐全的单链表需要对链表数据结构有深入的理解，并能够编写相应的操作方法。这样的实现有助于提升JavaScript开发者的数据结构和算法能力，对于前端开发者来说尤其重要，因为数据结构是...
JavaScript数组实现数据结构中的队列与堆栈
10-22
主要介绍了JavaScript数组实现数据结构中的队列与堆栈的相关资料,需要的朋友可以参考下
简单粗暴学习数据结构与算法——JS版（一）
06-13
这个教程“简单粗暴学习数据结构与算法——JS版（一）”很可能是通过一系列的实例和练习，用JavaScript来直观解释各种数据结构的实现和算法的应用。通过下载的多个rar文件，可能包含了不同章节的讲解、代码示例和...
JavaScript数据结构之单链表和循环链表
11-30
在计算机科学中，数据结构是编程的基础，而链表作为一种基础且重要的数据结构，被广泛应用于各种算法和程序设计中。链表不同于数组，它在内存中并不是连续存储的，而是通过指针链接各个元素。本文将主要讨论两种链表...
手写简单单链表实现功能
03-31
手动实现简单单链表实现，有助于学习数据结构之单链表。其中实现的功能有增删改查功能。单链表的优点是插入删除效率高。但不支持随机查找，查找效率低。
leetcode给单链表加一js实现-javascript-algorithms:JavaScript实现的一些数据结构和Javascript
06-30
leetcode 给单链表加一js实现JavaScript 算法和数据结构 排序算法 一些排序算法，它们是在 javascript 中实现的。 冒泡排序 堆排序 插入排序 归并排序 快速排序 选择排序 壳排序 力码 leetcode 问题的一些解决方案。 数据结构 用 Javascript 实现的数据结构。 堆 队列 单链表 双向链表 树 《IT面试》中的问题 堆栈和队列 堆栈与getMin和reverse 带有由另一个堆栈实现的sort的堆栈 狗和猫的队列 河内塔通过递归实现顺序 河内塔与堆栈实现的顺序 获取数组window中的最大数字 获取矩阵的最大面积 获取适合等式的子数组的数量： max - min <= num 链表 打印两个有序链表的公共部分 从尾部删除第nth节点 删除a/b位置的节点 反转链表 链表的反向部分 删除循环链表的节点，直到剩下一个节点 检查链表是否回文 按 prviot 对链表进行排序 用rand指针复制链表 将两个 int 链表相加 找到两个链表的第一个交叉节点。 每k节点反转一个链表。 删除链表中的重复节点。 按给定值删除节点。 将搜索二叉树转换为双向链
leetcode给单链表加一js实现-leetcode-By[removed]LeetCode解决方案（全部通过JavaScript！）h
06-30
leetcode给单链表加一js实现 LeetCode By JavaScript LeetCode Solutions (All By JavaScript!) 的个人Solutions汇总，全部使用JavaScript完成:grinning_squinting_face: 目的：了解、掌握数据结构和算法，当然更重要的是学会如何用JS实现（如JS中的Hash Table、BST等），和JS结下更深的友谊:clapping_hands: 其他：做笔记备份的目的是方便以后复习和再学习，同时也看看以前写的算法是有多么傻x:pile_of_poo: 如需中文,可=> 一、基本格式 问题链接 …… 问题描述 …… 解法描述 …… 源码实现（确保Accpted无误） // 运行时间 …… 二、Index目录引导 其中数字表示题目的顺序编号 1.运算基础（数字的基本运算、简单的求和等） 01 Two Sum ：两数之和 07 Reverse Integer：翻转整数 09 Palindrome Number：回文数 11 Container With Most Water：双指针搜索的典型例子 12 Integer to Roman： 将阿拉伯数字转换为罗马数字 38 Count and Say：
JS 单链表
花生吃花生的学习记录
11-11 1033
代码：
369 给单链表加一
weixin_44171872的博客
09-11 658
题目描述： 用一个 非空 单链表来表示一个非负整数，然后将这个整数加一。 你可以假设这个整数除了 0 本身，没有任何前导的 0。 这个整数的各个数位按照 高位在链表头部、低位在链表尾部 的顺序排列。 示例: 输入: [1,2,3] 输出: [1,2,4] 方法1： 主要思路： （1）先将链表中的元素存储到数组中，再对数组中的元素实现加1的操作，最后将数组中的元素重新赋值给链表，若是有需要，则增加新的头部结点； /** * Definition for singly-linked list. * stru
js实现数据结构--单链表
阳光下的冷静的博客
11-26 567
单链表的概念： 单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用(也称指针或链接)组成。下图展示了一个单链表的结构图： 单链表的特点： 每个元素除了由元素本身的节点还有指向下一个元素的指针构成 从链表中添加或者删除元素不需要移动其他的元素 访问链表中间的一个元素，需要从表头开始迭代列表直到找到所...
单链表、循环链表的JS实现
weixin_30547797的博客
11-11 640
数据结构系列前言： 数据结构作为程序员的基本知识，需要我们每个人牢牢掌握。近期我也展开了对数据结构的二次学习，来弥补当年挖的坑。。。。。。 当时上课的时候也就是跟着听课，没有亲自实现任何一种数据结构，更别提利用数据结构来解决问题了。 现在就来填坑了 在这里提醒看到我博客的孩子们，如果你还是在校生，永远不要轻视任何一门基础课的学习，这个时候挖的坑，要么需要用双倍的...
JavaScript实现单向链表
quitv的博客
02-01 270
JavaScript实现单向链表 一、单向链表简介 链表和数组一样，可以用于存储一系列的元素，但是链表和数组的实现机制完全不同。链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（有的语言称为指针或连接）组成。类似于火车头，一节车厢载着乘客（数据），通过节点连接另一节车厢。 head属性指向链表的第一个节点； 链表中的最后一个节点指向null； 当链表中一个节点也没有的时候，head直接指向null； 数组存在的缺点： 数组的创建通常需要申请一段连续的内存空间（一整块内存），并且大小是固
js(es6)实现单向链表——链表添加、删除、反转方法的实现
weixin_44607531的博客
01-16 777
1、以下方法中，head指向的节点即头节点的下标（index）为0，即第一个有数据的节点的下标为1。 2、以下方法中，未判断各种特殊情况，如下一个节点不存在的情况，因为如果下一个节点不存在，next为null，正好赋值给了尾节点的next，或正好中断了循环，完全符合逻辑，无需判断各种情况。 3、以下方法未详细描述，可结合链表结构图理解代码
js实现单链表及各种操作
weixin_42458557的博客
10-14 263
// 新建节点 class Node { constructor(val) { this.value = val this.next = null } } // 单向链表 class LinkedList { constructor(val) { this.length = 0 this.head = null } // 新增节点 append(val) { let newNode = new Node(val) if (this.he
nodejs vue论文-《数据结构》课程网站的设计与实现.docx
05-15
该文档是一篇关于《数据结构》课程网站的设计与实现的本科毕业论文，主要关注于利用Node.js和Vue.js技术构建一个教育平台。论文旨在探讨如何通过这些前端框架来提升在线学习体验，尤其是在数据结构课程的教学中。 ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值