javascript封装一个单向链表

最新推荐文章于 2023-04-30 22:49:41 发布
最新推荐文章于 2023-04-30 22:49:41 发布
阅读量279 收藏
点赞数 1
分类专栏： 学习总结 数据结构 文章标签： 链表 javascript 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44586361/article/details/128812626
版权

单向链表

单向链表类似于火车，有一个火车头，火车头会连接一个节点，节点上有乘客，并且这个节点会连接下一个节点，以此类推。

  • 链表的火车结构
    在这里插入图片描述

  • 链表的数据结构
    head 属性指向链表的第一个节点。
    链表中的最后一个节点指向 null。当链表中一个节点也没有的时候，head 直接指向 null。
    在这里插入图片描述

链表的数据结构

  • 给火车加上数据后的结构
    在这里插入图片描述
    链表中的常见操作

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

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

  • get(position) 获取对应位置的元素。

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

  • update(position, element) 修改某个位置的元素。

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

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

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

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

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

单向链表的封装

创建单向链表类

先创建单向链表类 LinkedList，添加基本属性，再逐步实现单向链表的常用方法。

  function LinkedList() {
      function NewNode(data) {
        this.data = data
        this.next = null
      }
      this.head = null
      this.length = 0
  }

实现 append() 方法

 LinkedList.prototype.append = function(data){
    let node = new NewNode(data)
    if(this.length === 0){
      this.head = node
    } else {
      let current = this.head
      while(current.next){
        current = current.next
      }
      current.next = node
    }
    this.length += 1
 }

过程图解

  • 首先让 currentNode 指向第一个节点。
    在这里插入图片描述
  • 通过 while 循环使 currentNode 指向最后一个节点，最后通过 currentNode.next = newNode，让最后一个节点指向新节点 newNode。
    在这里插入图片描述
    代码测试
let linkedList = new LinkedList()
// 测试 append 方法
linkedList.append("A");
linkedList.append("B");
linkedList.append("C");
console.log(linkedList);

在这里插入图片描述
实现 toString() 方法

LinkedList.prototype.toString = function(){
    let str = ''
    let current = this.head
     // 遍历所有的节点，拼接为字符串，直到节点为 null
    while(current){
      str += current.data + ' '
      current = current.next
    }
    return str
}

代码测试
// 测试 toString 方法

console.log(linkedList.toString()); //--> AA BB CC

实现 insert() 方法

      LinkedList.prototype.insert = function(position, data) {
        // 越界判断
        if(position < 0 || position > this.length) return false;
        const newNode = new Node(data);
        if(position === 0){
          newNode.next = this.head;
          this.head = newNode;
        } else {
          let index = 0;
          let current = this.head;
          let previous = null;
          while(index++ < position){
            previous = current;
            current = current.next;
          }
          newNode.next = current;
          previous.next = newNode;
        }
        this.length += 1;
      }

代码测试
// 测试 insert 方法

linkedList.insert(0, "123");
linkedList.insert(2, "456");
console.log(linkedList.toString()); //--> 123 AA 456 BB CC

实现 get() 方法
获取指定位置（position）的 data。

LinkedList.prototype.get = function(position) {
    if(position < 0 || position >= this.length) return null
    let index = 0
    let current = this.head
    while(index++ < position){
      current = current.next
    }
    return current.data
 }

代码测试
// 测试 getData 方法

console.log(linkedList.get(0)); //--> 123
console.log(linkedList.get(1)); //--> AA

实现 indexOf() 方法
indexOf(data) 返回指定 data 的 index，如果没有，返回 -1。
代码实现

LinkedList.prototype.indexOf = function(data) {
    let index = 0
    let current = this.head
    while(current){
      if(current.data === data){
        return index
      }
      current = current.next
      index += 1
    }
    return -1
}

代码测试
// 测试 indexOf 方法

console.log(linkedList.indexOf("AA")); //--> 1
console.log(linkedList.indexOf("ABC")); //--> -1

实现 update() 方法
update(position, data) 修改指定位置节点的 data。
代码实现

  LinkedList.prototype.update = function(position, newData) {
    // 越界判断
    if(position < 0 || position >= this.length) return false;
    let current = this.head;
    let index = 0;
    while(index++ < position){
      current = current.next;        
    }
    current.data = newData;
    return true;
  }

代码测试
// 测试 update 方法

linkedList.update(0, "12345");
console.log(linkedList.toString()); //--> 12345 AA 456 BB CC
linkedList.update(1, "54321");
console.log(linkedList.toString()); //--> 12345 54321 456 BB CC

实现 removeAt() 方法
removeAt(position) 删除指定位置的节点。
代码实现

LinkedList.prototype.removeAt = function(position) {
    // 越界判断
    if(position < 0 || position >= this.length) return null;
    let current = this.head;
    if(position == 0){
      this.head = this.head.next;
    } else {
      let index = 0;
      let previous = null;
      while(index++ < position){
        previous = current;
        current = current.next;
      }
      previous.next = current.next;
    }     
    this.length -= 1;   
    return current.data;
  }

代码测试
// 测试 removeAt 方法

linkedList.removeAt(3);
console.log(linkedList.toString()); //--> 12345 54321 456 CC

实现 remove() 方法
remove(data) 删除指定 data 所在的节点。
代码实现

LinkedList.prototype.remove = function(data) {
    // 获取data在列表中的位置
    const position = this.indexOf(data)
    return this.removeAt(position)
}

代码测试
// 测试 remove 方法

linkedList.remove("CC");
console.log(linkedList.toString()); //--> 12345 54321 456

实现 isEmpty() 方法
isEmpty() 判断链表是否为空。
代码实现

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

代码测试
// 测试 isEmpty 方法

console.log(linkedList.isEmpty()); //--> false

实现 size() 方法
size() 获取链表的长度。
代码实现

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

代码测试
// 测试 size 方法

console.log(linkedList.size()); //--> 3

完整实现

function LinkedList(){
      // 内部类，节点类
      function Node(data){
        this.data = data;
        this.next = null;
      }

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

      LinkedList.prototype.append = function(data) {
        // 创建一个新节点
        const newNode = new Node(data);
        //判断是否添加的第一个节点
        if(this.length == 0){ // 是第一个节点
          this.head = newNode;
        } else { // 不是第一个节点
          let current = this.head;
          while(current.next){ // current.next为null,表示找到了最后一个元素
            current = current.next;
          }
          current.next = newNode;
        }
        this.length += 1;
      }

      LinkedList.prototype.toString = function() {
        let current = this.head;
        let linkString = ''
        while(current){
          linkString += current.data + ' ';
          current = current.next;
        }
        return linkString;
      }

      LinkedList.prototype.insert = function(position, data) {
        // 越界判断
        if(position < 0 || position > this.length) return false;
        const newNode = new Node(data);
        if(position == 0){
          newNode.next = this.head;
          this.head = newNode;
        } else {
          let index = 0;
          let current = this.head;
          let previous = null;
          while(index++ < position){
            previous = current;
            current = current.next;
          }
          newNode.next = current;
          previous.next = newNode;
        }
        this.length += 1;
      }

      LinkedList.prototype.get = function(position) {
        // 越界判断
        if(position < 0 || position >= this.length) return null;
        let current = this.head;
        let index = 0;
          while(index++ < position){
            current = current.next;
          }
          return current.data
      }

      LinkedList.prototype.indexOf = function(data) {
        let current = this.head;
        let index = 0;
        while(current){
          if(current.data === data){
            return index;
          }
          current = current.next;
          index += 1;
        }
        return -1;
      }

      LinkedList.prototype.update = function(position, newData) {
        // 越界判断
        if(position < 0 || position >= this.length) return false;
        let current = this.head;
        let index = 0;
        while(index++ < position){
          current = current.next;        
        }
        current.data = newData;
        return true;
      }

      LinkedList.prototype.removeAt = function(position) {
        // 越界判断
        if(position < 0 || position >= this.length) return null;
        let current = this.head;
        if(position == 0){
          this.head = this.head.next;
        } else {
          let index = 0;
          let previous = null;
          while(index++ < position){
            previous = current;
            current = current.next;
          }
          previous.next = current.next;
        }     
        this.length -= 1;   
        return current.data;
      }

      LinkedList.prototype.remove = function(data) {
        // 获取data在列表中的位置
        const position = this.indexOf(data)
        return this.removeAt(position)
      }

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

      LinkedList.prototype.size = function() {
        return this.length;
      }
    }
云之前端
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript封装单向链表的示例代码
10-14
总结来说，封装JavaScript单向链表涉及创建一个表示链表的类以及一个表示节点的内部类。链表类应包含对链表的基本操作，如添加、删除、查找、更新元素等。通过这种方式，我们可以轻松地在JavaScript应用程序中使用和...
将一个单向链表反向连接
11-28
将一个单向链表反向连接
JS封装所有单向链表的操作并使用内部类的方式
m0_47195133的博客
04-27 101
JS封装所有单项链表的操作使用JS内部类的方式
JavaScript数据结构单链表的封装
xal
03-05 699
JavaScript数据结构单链表的封装 // 封装链表 function LiskedList(){ // 封装链表 function Nodes(data){ this.data = data; this.next = null; } // 属性 this.header = null; this.length = 0; // append(element) 向列表尾部添加一个新的项 LiskedList.p
js封装链表操作
我是vip你是谁的博客
05-03 1104
js封装链表操作
【JS数据结构与算法】单向链表的封装及其方法
29的博客
07-29 681
目录 一、什么是链表？ 二、链表的封装 三、追溯方法append(element) 四、toString() 五、inset(position, element) 六、get(position) 七、indexOf(element) 八、upDate(position, element) 九、removeAt(position) 十、remove(element) 十一、判断...
链表及链表的常见操作和用js封装一个链表
M_emory_的博客
04-30 677
/ 封装 append 追加方法// 1、创建新的节点// 2、判断添加的是否为第一个节点if (this.length == 0) { // 2.1 是第一个节点} else { // 2.2 不是第一个节点// 找到最后一个节点while (current.next) { // 判断下一个节点是否为 null ，如果为 null 就跳出循环，如果不为 null ，就继续往后寻找，一直找到最后的节点// 最后节点的next指向新的节点。
JavaScript：封装单向链表10种常见的操作方法
零小唬的博客
12-25 433
JavaScript：封装单向链表10种常见的操作方法
JavaScript实现单向链表
qq_42710593的博客
03-12 609
JavaScript实现单向链表
javascript——单向链表
FormAda的博客
12-15 1788
链表：存储数据一般可以用数组或者链表，不同于数组的是，链表中的元素不必是连续的空间。链表中的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（指针）组成。
数据结构与算法:单向链表实现与封装
08-26
"数据结构与算法：单向链表实现与封装" 在计算机科学中，数据结构是指计算机中...单向链表的实现与封装是数据结构和算法中的一个重要课题，通过封装，我们可以隐藏链表的实现细节，提供一个简单易用的接口供用户使用。
C语言单向链表的表示与实现实例详解
12-31
一个单向链表包含两个值: 当前节点的值和一个指向下一个节点的链接 一个单向链表的节点被分成两个部分。第一个部分保存或者显示关于节点的信息，第二个部分存储下一个节点的地址。单向链表只可向一个方向遍历。 链表...
javascript写的一个链表实现代码
10-29
链表是一种基础的数据结构，它由一系列节点组成，每个节点包含数据和指向下一个节点的引用。在JavaScript中，由于其动态类型和面向对象的特性，实现链表相对简单。以下是一个基于给定代码的链表实现的详细分析： ...
bootstrap制作一个优美的导航栏
qq_44586361的博客
04-22 9922
制作这个导航栏需要知道 导航栏是bootstrap网站的一个突出特点。导航栏在移动设备的视图中是折叠的，随着可用视图的增加，导航栏也会水平展开。 实例如下所示： <!DOCTYPE html> <html> <head> <title></title> <link rel="stylesheet" type="text/css" ...
react-hooks之useImperativeHandle使用详解
qq_44586361的博客
08-09 6214
useImperativeHandle可以通过使用ref时自定义暴露给父组件的实列值，并配合forwardRef一起使用 下面是一个简单的例子暴露给父组件一个属性值 效果如下 该钩子函数还有第三个参数，如果里面涉及到某个变化的值，只有当第三个参数发生改变时，父组件接收到的该值才会发生改变 代码如下所示： 先点击setCount按钮加到7，然后点击“获取子组件暴露给父组件的东西”按钮，此时打印出的count还是初使状态的0，只有点击了setNum按钮，（也就是说当num发生改变当时候），再次点击“获取
css3之鼠标移入显示所有内容
qq_44586361的博客
02-21 4320
在做这个之前，我先介绍一下做这个需要用到的知识点： text-overflow属性 text-overflow:ellipsis; overflow:hidden; white-space:nowrap; transition-property属性设置过渡动画所需操作的属性 transition-duration属性设置过渡动画持续时间，单位s(秒)，也可以为小数，如：0.5秒 transiti...
vue实现一个任务计划表
qq_44586361的博客
06-02 2853
效果图如下所示： 需要用到的指令： 条件渲染 v-show 根据表达式之真假值，切换元素的 display CSS 属性 当条件变化时该指令触发过渡效果 v-model 在表单控件或者组件上创建双向绑定 v-bind 缩写: 动态地绑定一个或多个特性，或一个组件 prop 到表达式 v-on 缩写@ 绑定事件监听器。事件类型由参数指定。表达式可以是一个方法的名字或一个内联语句，如果没有修饰...
css3之爱心表白动画特效
qq_44586361的博客
02-26 2760
春天了，又到了告白的季节，你是不是还在苦恼不知如何向心中的她（他）表白心意呢，哈哈，下面我就教大家做一个爱心表白特效 &lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;title&gt;&lt;/title&gt; &lt;style&gt; html{height: 100%;background: rgb(40,240,245);} .h...
设计程序创建一个单向链表
最新发布
05-29
好的，以下是一个基本的单向链表的实现示例，使用 Python 语言： ```python class ListNode: def __init__(self, val=0, next=None): self.val = val self.next = next class LinkedList: def __init__(self):...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值