JavaScript数据结构之链表

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

JavaScript链表结构的实现

简述

链表：就类似于火车一样，一节一节的链接起来，从火车头链接到火车尾，添加数据时只能在链表尾部添加，获取想要的数据时（查找也是只能从头部到尾部一节一节的查找，不能跳节）
链表

简单实现常用链表方法

append(node){}
insert(pos, node) { }
get(pos) { }
indexOf(node) { }
update(pos,node) { }
removeAt(pos) { }
remove(node) { }

node 节点

我们先定义一个 node 节点，用来存放的数据

class Node {
constructor(node){
	this.node = node;
	// 默认创建的节点 next 指向空
	this.next = null;
}

链表 Linked 实现

创建 Linked 类

class Linked {
	// 初始化时默认为空，没有数据，定义一个 head 及 length 长度为 0
	construcrot() {
		this.__head = null
		this.__length = 0
	}
}

append 方法实现

/**
 * 向列表后添加
 * @param {*} node 节点
*/
append(node) {
  // 1.创建节点
  const newNode = new Node(node)
  // 判断当前链表是否是第一个节点
  if (this.isEmpty()) {
    this.__head = newNode
  } else {
    // 找最后一个节点
    let currentNode = this.__head
    while (currentNode.next) {
      currentNode = currentNode.next
    }
    // 最后一个节点的 next 指向最新节点
    currentNode.next = newNode
  }
  // 节点长度++
  this.__length++
}

insert 方法实现

  /**
   *  链表插入数据
   * @param {number} pos 要插入的位置 0 - 当前链表长度
   * @param {*} node 要插入的节点
   */
  insert(pos, node) {
    // 对下标判断
    if (pos < 0 || pos > this.size()) { return false }

    // 创建节点
    const newNode = new Node(node)

    // 根据位置插入数据 区分为 0 跟不为 0
    // - 0:将新节点的 next 指向下一个节点，修正 head 指向新节点
    // - 1:分别定义变量接收当前节点跟上一个节点，新节点的 next 指向当前节点，前一个节点指向新节点
    if (pos === 0) {
      newNode.next = this.__head
      this.__head = newNode
    } else {
      let index = 0
      let currentNode = this.__head
      let prevNode = null
      while (index++ < pos) {
        prevNode = currentNode
        currentNode = currentNode.next
      }
      newNode.next = currentNode
      prevNode.next = newNode
    }
    this.__length++
    return true
  }

get方法实现

通过下标位置查找对应的节点信息

  /**
   * 返回指定下标的节点
   * @param {number} pos 链表下标
   */
  get(pos) {
    // 临界值判断
    if (pos < 0 || pos >= this.size()) { return null }
    // 定义变量接收当前节点信息
    let currentNode = this.__head
    // 遍历获取到符合条件的节点信息
    let index = 0
    while (index++ < pos) {
      currentNode = currentNode.next
    }
    return currentNode.node
  }

indexOf 方法实现

  /**
   * 根据节点信息返回下标值
   * @param {*} node 节点信息
   */
  indexOf(node) {
    let currentNode = this.__head
    // 定义下标
    let index = 0
    // 遍历节点相等时 返回对应的下标
    while (currentNode) {
      if (currentNode.node === node) {
        return index
      }
      currentNode = currentNode.next
      index++
    }
  }

update方法的实现

  /**
   * 修改链表指定下标
   * @param {number} pos 要修改的下标
   * @param {*} node 修改传递的值
   * @returns 修改后的值
   */
  update(pos, node) {
    // 越界判断
    if (pos < 0 || pos >= this.size()) { return false }
    let currentNode = this.__head
    let index = 0
    // 遍历找到对应下标的数据
    while (index++ < pos) {
      currentNode = currentNode.next
    }
    // 更新数据并返回
    return currentNode.node = node
  }

removeAt 方法实现

 /**
   * 删除给定下标的数据 
   * @param {number} pos 要删除的下标指针
   */
  removeAt(pos) {
    // 临界值判断
    if (pos < 0 || pos >= this.size()) { return null }
    let currentNode = this.__head
    // 为 0 时 直接操作 head 即可
    if (pos === 0) {
      this.__head = currentNode.next
    } else {
      // 不为 0 时 需要记录当前的及上一个数据
      let prevNode = null
      let index = 0
      while (index++ < pos) {
        prevNode = currentNode
        currentNode = currentNode.next
      }
      // 将上一个数据的 next 指向当前的 next
      prevNode.next = currentNode.next
    }
    // 删除成功后 长度 -1
    this.__length -= 1
    // 返回被删除的数据
    return currentNode.node
  }

remove方法实现

  /**
 * 删除给定数据
 * @param {*} node 传递的节点信息
 */
remove(node) {
  return this.removeAt(this.indexOf(node))
}

其他方法


	// 是否为空
  isEmpty() {
    return this.__length === 0
  }
  // 当前链表大小
  size() {
    return this.__length
  }
  // 字符串输出
  toString() {
    let currentNode = this.__head
    let result = ''
    while (currentNode) {
      result += currentNode.node + ' '
      currentNode = currentNode.next
    }
    return result
  }

下面附上完整的

/**
 * 节点 
 */
class Node {
  constructor(node) {
    this.node = node;
    this.next = null
  }
}

class Linked {

  constructor() {
    this.__head = null
    this.__length = 0
  }

  /**
   * 向列表后添加
   * @param {*} node 节点
   */
  append(node) {
    // 1.创建节点
    const newNode = new Node(node)
    // 判断当前链表是否是第一个节点
    if (this.isEmpty()) {
      this.__head = newNode
    } else {
      // 找最后一个节点
      let currentNode = this.__head
      while (currentNode.next) {
        currentNode = currentNode.next
      }
      // 最后一个节点的 next 指向最新节点
      currentNode.next = newNode
    }
    // 节点长度++
    this.__length++

  }
  /**
   * 指定位置插入节点
   * @param {number} pos 要插入的位置 0 - 当前链表长度
   * @param {*} node 要插入的节点
   */
  insert(pos, node) {
    // 对下标判断
    if (pos < 0 || pos > this.size()) { return false }

    // 创建节点
    const newNode = new Node(node)

    // 根据位置插入数据 区分为 0 跟不为 0
    if (pos === 0) {
      newNode.next = this.__head
      this.__head = newNode
    } else {
      let index = 0
      let currentNode = this.__head
      let prevNode = null
      while (index++ < pos) {
        prevNode = currentNode
        currentNode = currentNode.next
      }
      newNode.next = currentNode
      prevNode.next = newNode
    }
    this.__length++
    return true
  }

  /**
   * 返回指定下标的节点
   * @param {number} pos 链表下标
   */
  get(pos) {
    // 临界值判断
    if (pos < 0 || pos >= this.size()) { return null }
    let currentNode = this.__head
    let index = 0
    while (index++ < pos) {
      currentNode = currentNode.next
    }
    return currentNode.node
  }
  /**
   * 根据节点信息返回下标值
   * @param {*} node 节点信息
   */
  indexOf(node) {
    let currentNode = this.__head
    let index = 0
    while (currentNode) {
      if (currentNode.node == node) {
        return index
      }
      currentNode = currentNode.next
      index++
    }
  }
  /**
   * 修改链表指定下标
   * @param {number} pos 要修改的下标
   * @param {*} node 修改传递的值
   * @returns 修改后的值
   */
  update(pos, node) {
    // 越界判断
    if (pos < 0 || pos >= this.size()) { return false }
    let currentNode = this.__head
    let index = 0
    // 遍历找到对应下标的数据
    while (index++ < pos) {
      currentNode = currentNode.next
    }
    // 更新数据并返回
    return currentNode.node = node
  }
 /**
   * 删除给定下标的数据 
   * @param {number} pos 要删除的下标指针
   */
  removeAt(pos) {
    // 临界值判断
    if (pos < 0 || pos >= this.size()) { return null }
    let currentNode = this.__head
    // 为 0 时 直接操作 head 即可
    if (pos === 0) {
      this.__head = currentNode.next
    } else {
      // 不为 0 时 需要记录当前的及上一个数据
      let prevNode = null
      let index = 0
      while (index++ < pos) {
        prevNode = currentNode
        currentNode = currentNode.next
      }
      // 将上一个数据的 next 指向当前的 next
      prevNode.next = currentNode.next
    }
    // 删除成功后 长度 -1
    this.__length -= 1
    // 返回被删除的数据
    return currentNode.node
  } 

  /**
   * 删除给定数据
   * @param {*} node 传递的节点信息
   */
  remove(node) {
    return this.removeAt(this.indexOf(node))
  }
  isEmpty() {
    return this.__length === 0
  }
  size() {
    return this.__length
  }
  toString() {
    let currentNode = this.__head
    let result = ''
    while (currentNode) {
      result += currentNode.node + ' '
      currentNode = currentNode.next
    }
    return result
  }

}
放逐的程序猿
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
JavaScript数据结构之链表的实现
12-08
前面楼主分别讨论了数据结构栈与队列的实现，当时所用的数据结构都是用的数组来进行实现，但是数组有的时候并不是最佳的数据结构，比如在数组中新增删除元素的时候需要将其他元素进行移动，而在javascript中使用spit...
javascript中的链表结构
weixin_34122810的博客
09-17 116
1.定义 　　很多编程语言中数组的长度是固定的，就是定义数组的时候需要定义数组的长度，所以当数组已经被数据填满的时候，需要再加入新的元素就很困难。只能说在部分变成语言中会有这种情况，在javascript中和php中数组的长度是可以任意增加的。在数组中添加和删除元素也是比较麻烦，因为要将数组中其他元素向前或者向后平移，这个在javascript中也不是问题，javascript中有一个很方便的方...
JavaScript 数据结构【链表】
qq_44810886的博客
05-03 1279
一、单向链表 只能从头到尾或者从尾遍历到头 封装单向链表： function LinkedList() { //内部的类：节点类 function Node(data) { this.data = data; this.next = null } //属性 this.head = null; .
javascript链表
weixin_46224014的博客
11-06 8482
1.什么是链表？ 链表是多个元素组成的列表 元素存储不连续，用next指针连接到一起 JS中没有链表，但是可以用Object模拟链表 2.常用操作 新增节点 append 删除节点 remove 插入节点 insert 输出节点 索引 indexOf ...
javascript-链表
qq_43368682的博客
09-18 102
链表 链表： 链表实际上是线性表的链式存储结构，与数组不同的是，它是用一组任意的存储单元来存储线性表中的数据，存储单元不一定是连续的， 且链表的长度不是固定的，链表数据的这一特点使其可以非常的方便地实现节点的插入和删除操作 链表的每个元素称为一个节点，每个节点都可以存储在内存中的不同的位置，为了表示每个元素与后继元素的逻辑关系，以便构成“一个节点链着一个节点”的链式存储结构。 let LinkNode=function(val){ this.val=val; this.next=nu
数据结构-使用javascript讲解数据结构之链表.zip
最新发布
02-12
数据结构 数据结构_使用javascript讲解数据结构之链表
JavaScript数据结构与算法之链表
10-22
链表就是线性表中针对顺序存储结构的一种优化手段，但是在javascript语言中由于数组的特殊性（自动更新引用位置），所以我们可以采用对象的方式做链表存储的结构
JavaScript数据结构链表知识详解
10-21
存储有序的元素集合，但不同于数组，链表中的元素在内存中不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（也称指针或链接）组成。下面通过本文给大家详细介绍下，需要的朋友参考下
JavaScript【链表】
m0_63077733的博客
03-21 1580
双向链表：既可以从头遍历到尾，又可以从尾遍历到头。也就是说链表连接的过程是双向的，它的实现原理是：一个节点既有向前连接的引用，也有一个向后连接的引用。每次在插入或删除某个节点时，都需要处理四个引用，而不是两个，实现起来会困难些；相对于单向链表，所占内存空间更大一些；但是，相对于双向链表的便利性而言，这些缺点微不足道。双向链表不仅有head指针指向第一个节点，而且有tail指针指向最后一个节点；item储存数据、prev指向前一个节点、next指向后一个节点；
JavaScript实现链表
maomaolaoshi的博客
09-15 489
时隔一个多月，终于又开始写关于js的文章啦，本次我写的是如何使用JavaScript实现链表。 在这我就不再介绍链表的定义了，直接开始内容部分。 老规矩，先看看链表的方法。 定义链表的方法 在尾部添加新的项 方法：append() 语法：LinkedList.append(element1，element2…elementX) 参数：必需。element不能为空。
javascript实现链表
aboutcjp的博客
03-05 632
javascript中数组是对象，所以在效率上，会差一点。所以有的时候可以选择链表。javascript原生是没有链表的，不过我们可以自己写一个对象，来模拟链表。 链表主要特点是:每个节点，都会指向它的后继。我们可以通过一个对象来定义 function node(e){ this.element=e; this.next=null; }//节点对象 node，element是指节点值，
JavaScript数据结构——链表
郊眠寺
05-30 1171
前言 嘿，掘友们！今天我们来了解并实现数据结构 —— 链表。 本文主要内容 单向链表 双向链表 循环链表 链表 要存储多个元素，数组可能是最常用的数据结构。但是这种数据结构有一个缺点，数组的大小是固定的，从数组的起点或中间插入或移除的成本很高，因为需要移动元素。 链表存储有序的元素集合，不同于数组的是，链表中的元素在内存中并不是连续放置的。每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（指针或链接）组成。下图是一个链表的结构。 相比数组，链表的一个好处在于，添加或移除元素的时候不需要移动其
JavaScript实现链表（单链表，双向链表）
IT_10的博客
10-08 510
单链表 &lt;script&gt; //单链表 function Node(element) { this.element=element; this.next=null; } function LList() { this.head=new Node("he...
JavaScript单向链表（ES6）
weixin_33883178的博客
08-04 432
关键词：链表 单向链表 JavaScript实现单向链表 数据结构与算法 创刊号 在前端领域摸爬打滚了几年了，自认为前端知识有点积累了，后端知识也涉猎，但是离大神还是有差距的。很多积累知识点都用云笔记记录的，现在打算慢慢的网掘金上迁移。一是希望能通过整理这些知识点，让自己更加系统化的理解这些知识。二是希望某些知识点能帮忙到大家。 好了废话不多说，现在开始进入今天主题《单向链表》。 一、什么是单...
javascript：数据结构——链表
weixin_42924369的博客
08-23 333
什么是链表？ 链表是有序的列表， 链表是以节点的方式来存储，是链式存储。 每个节点包含item域，next指针（指向下一个节点），即就是链表中的每一个元素都带有下一个元素的位置(next) 链表的节点不一定连续存储，是离散的状态 双向链表 每个链表不仅带有next这一项，还有previous这一项 双向循环列表 链表操作 1、添加（指定添加元素 尾部添加元素） 2、移除（指定位置(下标)移除元素 移除元素元素） 链表尾添加元素 1、如果链表为空的情况下，给链表尾添加元素，同时要把链表头
Javascript中的链表
qq_40957332的博客
08-21 117
单向链表 /** * @desc 单向链表 */ class Node { // 链表节点 constructor(element) { this.data = element // 节点数据 this.next = null // 下一个节点的指针 } } class NodeList { // 链表 constructor(item) { this.head = new Node(item); //初始化链表的头节点 } /** * @de
数据结构双链表的插入排序
12-26
双链表的插入排序是一种对双链表进行排序的算法。它通过不断将未排序的节点插入到已排序的部分中，最终使整个链表有序。 以下是双链表插入排序的实现方法： 1. 创建一个新的空链表，作为已排序的部分。 2. 遍历...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

放逐的程序猿

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值