数据结构-JS实现单链表、JS实现双链表

最新推荐文章于 2022-10-18 23:18:26 发布
最新推荐文章于 2022-10-18 23:18:26 发布
阅读量8.8k 收藏
点赞数 2
分类专栏： 算法 文章标签： js 算法 链表 单链表 双链表
彭先生版权所有，未经授权是非法行为。欢迎访问我的个人网站：www.bookbook.cc
本文链接：https://blog.csdn.net/weixin_43742708/article/details/114486054
版权

文章目录

一、什么是链表？

链表和数组一样，可以用来存储一系列的元素，但是链表和数组的实现机制完全不同。

1.1 链表与数组的优差别

下面来简单看一下数组与链表的 差别
在这里插入图片描述
在这里插入图片描述
数组缺点总结： 1、扩容 2、中间插入成本高
链表缺点总结： 1、每次访问都是从头访问

数组在通过下标 修改或获取 元素效率更高。
链表在 插入或删除 时效率更高。

1.2 链表结构图示

抽象方式：
在这里插入图片描述
每个链表的开头都需要一个head属性，指向第一个节点。
在这里插入图片描述

二、 单向链表的常见操作及封装

在这里插入图片描述

2.1 append(data) 尾部追加

注意，添加时有两种情况：

  1. 链表本身为空，需要将head指向刚添加的节点
  2. 链表本身不为空，需要将最后一个节点的next指向当前
// 封装链表类
function LinkedList() {
  // 内部类：节点类
  function Node(data) {
    this.data = data
    this.next = null
  }
  // 属性 head属性指向第一个节点
  this.head = null
  // 当前链表的节点个数
  this.length = 0

  // 1.追加方法
  LinkedList.prototype.append = function (data) {
    // 1.创建新节点 
    let newNode = new Node(data)

    // 2.判断是否是第一个节点
    if (this.length == 0) {
      // 2.1 是，将head指向刚创建的节点
      this.head = newNode
    } else {
      // 2.2 不是，找到最后一个节点
      let current = this.head
      while (current.next) {
        current = current.next
      }
      // 把最后一个节点的next指向新创建的节点
      current.next = newNode
    }
    this.length += 1
  }
}

2.2 toString 方法

注意：调佣alert方法，如果重写了原形上的toString方法，则alert会调用重写的 toString方法。
在这里插入图片描述

// 2.toSring方法
LinkedList.prototype.toString = function () {
	let current = this.head
	let listString = ''
	
	// 2.循环获取一个个的节点
	while (current) {
	  listString += current.data + ' '
	  current = current.next
	}
	
	return listString
}

// 2.追加方法
list.append('a')
list.append('c')
list.append('b')
list.append('d')
alert(list);
console.log(list);

在这里插入图片描述
在这里插入图片描述

2.3 insert(position,data) 插入方法

情况一：插入到position等于0的位置
情况二：position插入到大于1的位置

在这里插入图片描述

// 3.insert方法
LinkedList.prototype.insert = function (position, data) {
  // 1.对我们的position进行越界判断 （小于0,大于当前长度）
  if (position < 0 || position > this.length) return false

  // 2.创建节点
  let newNode = new Node(data)

  // 3.判断插入的位置是否是第一个
  if (position == 0) {
    // 先让新插入节点的指针指向原来的第一个节点
    newNode.next = this.head
    // 再让head指向新插入的节点
    this.head = newNode
  }else{
    let index = 0
    let current = this.head
    let previous = null
    // 当循环停止，current就是position处的节点，previous是current的前面一个
    while(index++ < position){
      previous = current
      current = current.next
    }
    // 前一个链接新的，新的链接后边的
    previous.next = newNode
    newNode.next = current
  }

  this.length += 1
  return true
}

测试：

// 测试代码
// 1.创建LinkedList
let list = new LinkedList()

// 2.追加方法
list.append('a')
list.append('c')

// 3.插入方法
list.insert(1,'b')
alert(list);
console.log(list);

效果：
在这里插入图片描述
在这里插入图片描述

2.4 get(position) 获取对应位置的数据

//4.get方法
LinkedList.prototype.get = function (position) {
  // 1.越界判断
  if (position < 0 || position >= this.length) return null

  // 2.获取对应的数据
  let current = this.head
  let index = 0
  while (index++ < position) {
    current = current.next
  }
  return current.data
}

测试代码：

// 测试代码
// 1.创建LinkedList
let list = new LinkedList()

// 2.追加方法
list.append('a')
list.append('c')

// 3.插入方法
list.insert(1, 'b')
console.log(list);
console.log(list.get(2));

在这里插入图片描述

2.5 indexOf(data) 返回元素在链表中的索引，没有返回 -1

// 5.indexOf
LinkedList.prototype.indexOf = function (data) {
  // 5.1定义变量
  let current = this.head
  let index = 0

  // 5.2 开始查找
  while(current){
    if(current.data == data){
      return index
    }
    current = current.next
    index += 1
  }
  // 找到最后都没找到返回 -1
  return -1
}

测试结果：
在这里插入图片描述

2.6 update(position,newData) 根据位置信息，修改对应的元素


// 6.update
LinkedList.prototype.update = function (position, newData) {
  // 1.越界判断
  if (position < 0 || position >= this.length) return false

  // 2.查找正确的节点
  let current = this.head
  let index = 0
  while (index++ < position) {
    current = current.next
  }
  // 3.将position位置节点的data修改为newData
  current.data = newData

  return true
}

测试代码：

// 测试代码
// 1.创建LinkedList
let list = new LinkedList()

// 2.测试追加方法
list.append('a')
list.append('c')

// 3.测试插入方法
list.insert(1, 'b')

// 4.测试toString方法
alert(list);

console.log(list);
console.log(list.get(0));
console.log(list.get(1));
console.log(list.get(2));

// 5.测试indexOf方法
console.log('测试indexOf方法：c=>', list.indexOf('c'));
// 6.测试update方法
console.log('测试update方法：position:2,result=>', list.update(2, 'd')); //true
console.log(list.get(2)); // d

测试结果：
在这里插入图片描述

2.7 removeAt(position) 根据位置信息删除

情况一：删除position位置等于0的
情况二：删除position非0的

// 7.removeAt
LinkedList.prototype.removeAt = function (position) {
  // 1.越界判断
  if (position < 0 || position >= this.length) return null

  // 2.判断是否删除的是第一个Node
  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
    }
    // 前一个的next指向后一个节点的next
    previous.next = current.next

    // 3.length减一
    this.length -= 1
    return current.data
  }
}

测试代码：

// 测试代码
// 1.创建LinkedList
let list = new LinkedList()

// 2.测试追加方法
list.append('a')
list.append('c')

// 3.测试插入方法
list.insert(1, 'b')

// 4.测试toString方法
alert(list);

console.log(list);
console.log(list.get(0));
console.log(list.get(1));
console.log(list.get(2));

// 5.测试indexOf方法
console.log('测试indexOf方法：c=>', list.indexOf('c'));
// 6.测试update方法
console.log('测试update方法：position:2,result=>', list.update(2, 'd')); //true
console.log(list.get(2)); // d

// 7.测试removeAt方法
console.log(list.removeAt(2));

测试效果：
在这里插入图片描述

2.8 remove(data) 根据元素删除

LinkedList.prototype.remove = function (data) {
  // 1.根据data 获取对应的位置
  let position = this.indexOf(data)
  // 2.根据位置信息,删除节点  不用考虑-1,因为 removeAt方法内，做了越界判断
  return this.removeAt(position)
}

测试代码：

// 8.测试remove方法
console.log('测试remove方法:删除b=>', list.remove('b'));

测试结果：
在这里插入图片描述

2.9 isEmpty 判断链表是否为空

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

2.10 size 返回链表个数

// 10. size 返回链表节点的个数
LinkedList.prototype.size = function (){
  return this.length
}

2.11 单向链表完整代码

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

<head>
  <meta charset="UTF-8">
  <meta http-equiv="X-UA-Compatible" content="IE=edge">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>单向链表</title>
</head>

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

      // 1.追加方法
      LinkedList.prototype.append = function (data) {
        // 1.创建新节点 
        let newNode = new Node(data)

        // 2.判断是否是第一个节点
        if (this.length == 0) {
          // 2.1 是，将head指向刚创建的节点
          this.head = newNode
        } else {
          // 2.2 不是，找到最后一个节点
          let current = this.head
          while (current.next) {
            current = current.next
          }
          // 把最后一个节点的next指向新创建的节点
          current.next = newNode
        }
        this.length += 1
      }

      // 2.toSring方法
      LinkedList.prototype.toString = function () {
        let current = this.head
        let listString = ''

        // 2.循环获取一个个的节点
        while (current) {
          listString += current.data + ' '
          current = current.next
        }

        return listString
      }

      // 3.insert方法
      LinkedList.prototype.insert = function (position, data) {
        // 1.对我们的position进行越界判断 （小于0,大于当前长度）
        if (position < 0 || position > this.length) return false

        // 2.创建节点
        let newNode = new Node(data)

        // 3.判断插入的位置是否是第一个
        if (position == 0) {
          // 先让新插入节点的指针指向原来的第一个节点
          newNode.next = this.head
          // 再让head指向新插入的节点
          this.head = newNode
        } else {
          let index = 0
          let current = this.head
          let previous = null
          // 当循环停止，current就是position处的节点，previous是current的前面一个
          while (index++ < position) {
            previous = current
            current = current.next
          }
          // 前一个链接新的，新的链接后边的
          previous.next = newNode
          newNode.next = current
        }

        this.length += 1
        return true
      }

      // 4.get方法 获取对应位置的数据
      LinkedList.prototype.get = function (position) {
        // 1.越界判断
        if (position < 0 || position >= this.length) return null

        // 2.获取对应的数据
        let current = this.head
        let index = 0
        while (index++ < position) {
          current = current.next
        }
        return current.data
      }

      // 5.indexOf 返回匹配到的元素的位置
      LinkedList.prototype.indexOf = function (data) {
        // 5.1定义变量
        let current = this.head
        let index = 0

        // 5.2 开始查找
        while (current) {
          if (current.data == data) {
            return index
          }
          current = current.next
          index += 1
        }
        // 没找到返回 -1
        return -1
      }

      // 6.update 更新某一个位置的数据
      LinkedList.prototype.update = function (position, newData) {
        // 1.越界判断
        if (position < 0 || position >= this.length) return false

        // 2.查找正确的节点
        let current = this.head
        let index = 0
        while (index++ < position) {
          current = current.next
        }
        // 3.将position位置节点的data修改为newData
        current.data = newData

        return true
      }

      // 7.removeAt 根据位置删除元素
      LinkedList.prototype.removeAt = function (position) {
        // 1.越界判断
        if (position < 0 || position >= this.length) return null

        // 2.判断是否删除的是第一个Node
        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
          }
          // 前一个的next指向后一个节点的next
          previous.next = current.next

          // 3.length减一
          this.length -= 1
          return current.data
        }
      }

      // 8.remove 根据元素删除
      LinkedList.prototype.remove = function (data) {
        // 1.根据data 获取对应的位置
        let position = this.indexOf(data)
        // 2.根据位置信息,删除节点  不用考虑-1,因为 removeAt方法内，做了越界判断
        return this.removeAt(position)
      }

      // 9.isEmpty 判断链表是否为空
      LinkedList.prototype.isEmpty = function () {
        return this.length == 0
      }

      // 10. size 返回链表节点的个数
      LinkedList.prototype.size = function () {
        return this.length
      }
    }

    // 测试代码
    // 1.创建LinkedList
    let list = new LinkedList()

    // 2.测试追加方法
    list.append('a')
    list.append('c')

    // 3.测试插入方法
    list.insert(1, 'b')

    // 4.测试toString方法
    alert(list);

    console.log(list);
    console.log(list.get(0));
    console.log(list.get(1));
    console.log(list.get(2));

    // 5.测试indexOf方法
    console.log('测试indexOf方法：c=>', list.indexOf('c'));
    // 6.测试update方法
    console.log('测试update方法：position:2,result=>', list.update(2, 'd')); //true
    console.log(list.get(2)); // d

    // 7.测试removeAt方法
    console.log(list.removeAt(2));

    // 8.测试remove方法
    console.log('测试remove方法:删除b=>', list.remove('b'));
    // 9.测试isEmpty方法
    console.log(list.isEmpty());
    // 10.测试size方法
    console.log(list.size());
  </script>
</body>

</html>

三、双向链表

3.1 认识双向列表

在这里插入图片描述

总结出双向链表的特点：

  1. 可以使用一个head和一个tail分别指向头部和尾部的节点
  2. 每个节点都由三部分组成前一个节点的指针(prev)，保存的元素(item)，后一个节点的指针next)
  3. 双向链表的第一个节点的prev是null
  4. 双向链表的最后的节点的next是null

3.2 双向链表图示

在这里插入图片描述
在这里插入图片描述

3.3 链表结构封装

<script>
  // 封装双向链表
  function DoublyLinkedList() {
    // 1.内部类:节点类
    function (data) {
      this.data = data
      this.prev = null
      this.next = null
    }
    // 2.属性
    this.head = null //头
    this.tail = null //尾
    this.length = 0 //node个数

    // 3.常见的操作
  }
</script>

四、双向链表的常见操作及封装

4.1 常见方法

在这里插入图片描述

4.2 append(data) 尾部追加元素

注意，添加时有两种情况：

  1. 判断链表是否为空
  2. 链表本身不为空，需要将最后一个节点的next指向当前
function DoublyLinkedList() {
  // 1.内部类:节点类
  function DoublyNode(data) {
    this.data = data
    this.prev = null
    this.next = null
  }
  // 2.属性
  this.head = null //头
  this.tail = null //尾
  this.length = 0 //node个数

  // 3.常见的操作

  // 1.append(data) 尾部追加
  DoublyLinkedList.prototype.append = function (data) {
    // 1.根据data创建节点
    let newNode = new DoublyNode(data)

    // 2.判断添加的是否为第一个节点
    if (this.length == 0) {
      this.head = newNode
      this.tail = newNode
    } else {
      // 新节点的prev指向 以前的tail
      newNode.prev = this.tail
      // 以前的tail的next节点 指向newnode
      this.tail.next = newNode
      // 新节点变为最后一个节点
      this.tail = newNode
    }
    // 3.改变length的长度
    this.length += 1
  }
}

4.3 backwardString 向后遍历

DoublyLinkedList.prototype.backwardString = function () {
  let current = this.head
  let resultString = ''

  // 1.依次向后遍历，获取每一个节点
  while (current) {
    resultString += current.data + ' '
    current = current.next
  }
  return resultString
}

4.4 fowardString 向前遍历

DoublyLinkedList.prototype.fowardString = function () {
  let current = this.tail
  let resultString = ''
  // 1.依次向后遍历
  while (current) {
    resultString += current.data + ' '
    current = current.prev
  }
  return resultString
}

4.5 toString方法

 DoublyLinkedList.prototype.toString = function () {
   return this.backwardString()
 }

4.6 测试 append backwardString fowardString toString

测试代码：

// 测试代码
const list = new DoublyLinkedList()

// 1.测试append方法
list.append('abc')
list.append('cba')
list.append('nba')

// 2.测试转成字符串的方法
console.log(list.backwardString());
console.log(list.fowardString());
console.log(list.toString());

测试结果：
在这里插入图片描述

4.7 insert(position,data) 插入到指定位置

注意以下几种情况：

  1. 链表是空的 （head tail）
  2. 插入到链表开头 （head 新节点 绑定尾 旧节点绑定头）
  3. 插入到链表结尾 （tail 新节点绑定头 旧节点绑定尾）
  4. 插入到链表中间 （新节点绑定头尾 旧节点的prev.next 旧节点的.prev）
DoublyLinkedList.prototype.insert = function (position, data) {
  // 1.越界判断
  if (position < 0 || position > this.length) return false

  // 2.根据data创建节点
  let newNode = new DoublyNode(data)

  // 3.找到正确的位置
  if (this.length == 0) {
    this.head = newNode
    this.tail = newNode
  } else {
    if (position == 0) {// 3.1 判断position是否为0
      this.head.prev = newNode
      newNode.next = this.head
      this.head = newNode
    } else if (position == this.length) { // 3.2 position == length
      console.log('position: ', position);
      newNode.prev = this.tail
      console.log('this.tail: ', this.tail);
      this.tail.next = newNode
      this.tail = newNode
    } else {
      let current = this.head
      let index = 0
      while (index++ < position) {
        current = current.next
      }
      // 3.3 修改指针
      newNode.prev = current.prev
      newNode.next = current
      current.prev.next = newNode
      current.prev = newNode
    }
  }

  // 4. length +1
  this.length += 1
  return true
}

测试代码：

    // 测试代码
    const list = new DoublyLinkedList()

    // 1.测试append方法
    list.append('a')
    list.append('b')
    list.append('c')

    // 2.测试转成字符串的方法
    console.log(list.backwardString());
    console.log(list.toString());
    console.log(list.fowardString());

    // 3.测试insert方法
    list.insert(0, '-a')
    list.insert(2, '-b')
    list.insert(5, 'c+')
    console.log(list);

测试结果：
在这里插入图片描述

4.8 get(position) 根据位置获取对应元素

DoublyLinkedList.prototype.get = function (position) {
  // 1.越界判断
  if (position < 0 || position >= this.length) return null
  
  // 2.获取元素
  // 优化算法 判断从前往后找 还是从后往前找
  if (this.length / 2 > position) {
    // 前往后
    let current = this.head
    let index = 0
    while (index++ < position) {
      current = current.next
    }
  } else {
    // 后往前
    let current = this.tail
    let index = this.length - 1
    while (index-- > position) {
      current = current.prev
    }
  }
  return current.data
}

测试代码：

// ... 沿用上边全部测试代码
// 4.测试get方法
console.log(list.get(0));
console.log(list.get(1));
console.log(list.get(4));
console.log(list.get(5));

测试结果：
在这里插入图片描述

4.9 indexOf(data) 根据元素返回对应位置

DoublyLinkedList.prototype.indexOf = function (data) {
 let current = this.head
 let index = 0
 // 1.查找和data相同的节点
 while (current) {
   if (current.data == data) {
     return index
   }
   current = current.next
   index += 1
 }
 return -1
}

测试代码：

// ... 沿用上边全部测试代码
console.log(list.indexOf('-a'));
console.log(list.indexOf('c+'));

测试结果:
在这里插入图片描述

4.10 update(position,data) 更新指定位置的数据

注意：这里可以做一个优化，判断是从前往后遍历，还是从后往前遍历

DoublyLinkedList.prototype.update = function (position, newData) {
  // 1.越界判断
  if (position < 0 || position >= this.length) return false

  // 2.寻找正确的节点
  // 算法优化 判断是从前往后，还是从后往前
  let current = null
  if (this.length / 2 > position) {
    // 前往后
    current = this.head
    let index = 0
    while (index++ < position) {
      current = current.next
    }
  } else {
    // 后往前
    current = this.tail
    let index = this.length - 1
    while (index-- > position) {
      current = current.prev
    }
  }

  // 3.修改找到的节点信息
  current.data = newData
  return true
}

测试代码：

// ... 沿用上边全部测试代码
console.log(list.update(0, '--a'));
console.log(list.update(5, 'c++'));
console.log(list.get(0));
console.log(list.get(5));

测试结果：
在这里插入图片描述

4.11 removeAt(position) 根据位置信息删除对应节点

注意删除操作要考虑以下几种情况：

  1. 只有一个节点
  2. 删除第一个节点
  3. 删除最后一个节点
  4. 删除中间的节点
DoublyLinkedList.prototype.removeAt = function (position) {
  // 1.越界判断
  if (position < 0 || position >= this.length) return false

  // 2.判断是否只有一个节点
  let current = this.head

  if (this.length == 1) {
    this.head = null
    this.tail = null
  } else {
    if (position == 0) {// 删除的是第一个节点
      this.head.next.prev = null
      this.head = this.head.next
    } else if (position == this.length - 1) { //删除的是最后的节点
      current = this.tail
      this.tail.prev.next = null
      this.tail = this.tail.prev
    } else {
      let index = 0
      while (index++ < position) {
        current = current.next
      }
      //函数生命周期结束后，没有被引用的变量都会被GC回收 以达到删除的目的
      current.prev.next = current.next
      current.next.prev = current.prev
    }
  }
  // 3.length减一
  this.length -= 1
  return current.data
}

测试代码：

// ... 沿用上边全部测试代码
console.log('删除掉的是第0位：', list.removeAt(0))
console.log('删除掉的是第4位：', list.removeAt(4))
console.log('删除掉的是第5位：', list.removeAt(5))

测试结果：
在这里插入图片描述

4.12 remove(data) 根据元素删除

DoublyLinkedList.prototype.remove = function (data) {
  // 1.根据data获取下标值
  let index = this.indexOf(data)

  // 2.根据 index 删除元素
  return this.removeAt(index)
}

测试代码：

// ... 沿用上边全部测试代码
console.log('删除-b:', list.remove('-b'));
console.log(list);

测试结果：
在这里插入图片描述

4.13 其他方法的实现

// 9.isEmpty
DoublyLinkedList.prototype.isEmpty = function () {
  return this.length == 0
}

// 10. size
DoublyLinkedList.prototype.size = function () {
  return this.length
}

// 11.获取链表的第一个元素
DoublyLinkedList.prototype.getHead = function () {
  return this.head
}
// 11.获取链表的最后一个元素
DoublyLinkedList.prototype.getTail = function () {
  return this.tail
}

测试代码：

// 9.测试 isEmpty
console.log('isEmpty:',list.isEmpty());
// 10.测试 size
console.log('size：',list.size());
// 11.测试 getHead
console.log('getHead：',list.getHead());
// 12.测试 getTail
console.log('getTail：',list.getTail());

测试结果：
在这里插入图片描述

优雅哥cc
关注
专栏目录
js(es6)实现单向链表——链表添加、删除、反转方法的实现
weixin_44607531的博客
01-16 782
1、以下方法中，head指向的节点即头节点的下标（index）为0，即第一个有数据的节点的下标为1。 2、以下方法中，未判断各种特殊情况，如下一个节点不存在的情况，因为如果下一个节点不存在，next为null，正好赋值给了尾节点的next，或正好中断了循环，完全符合逻辑，无需判断各种情况。 3、以下方法未详细描述，可结合链表结构图理解代码
用js写单链表和双向链表
MOU_littleGuo的博客
07-22 625
主要是理解单链表的结构和原理。 单链表    试验一下： var l = new list(); l.insert("a","head"); l.insert("b","a"); l.insert("c","b"); l.remove("b"); l.show(); 双向链表 function node(Element){ this.Ele
JavaScript实现单链表、双链表
weixin_51061303的博客
05-21 113
链表 链表是一种物理存储单元上非连续、非顺序的存储结构，链表上的节点的逻辑顺序是通过链表中的指针链接来实现的。 链表上的结点包括两个部分： 一个是存储数据的数据域 一个是存储链接指向的指针域 链表在插入操作时，最快可以达到O（1）的时间复杂度 在得到要插入位置的结点的指针后，直接链接进去，然后将前后两个结点的数据交换，即可实现O（1）时间复杂度的速度。 结构图： 下面分析几种操作： 查找 通过分析链表的存储方式可知(按照指针依次链接n个对象)， 查找元素只能挨个查找，直至找到
JavaScript实现链表（单链表，双向链表）
IT_10的博客
10-08 528
单链表 &lt;script&gt; //单链表 function Node(element) { this.element=element; this.next=null; } function LList() { this.head=new Node("he...
JavaScript数据结构：单链表与双向链表
前端学习博客
01-10 376
文章目录创建链表类链表常见操作：增删改查append(element)：toString()insert(position, element)：indexOf(element)：get(positon)：updata(position,element):removeAt(position)：remove(element)：isEmpty()：size()：双向链表双向链表介绍双向链表的封装双向链表常见操作：增删改查append(element)：forwardString()：backwardString(
Node.js环境下JavaScript实现单链表与双链表结构
10-22
在Node.js环境下使用JavaScript实现数据结构是程序员必须掌握的技能之一，链表作为一种基础的数据结构，在实际编程中有着广泛应用。链表结构主要包括单链表和双链表，这两种链表的特性、用途和操作方法都有所不同。 ...
leetcode给单链表加一js实现-javascript-algorithms:JavaScript实现的一些数据结构和Javascript
06-30
给单链表加一js实现JavaScript 算法和数据结构 排序算法 一些排序算法，它们是在 javascript 中实现的。 冒泡排序 堆排序 插入排序 归并排序 快速排序 选择排序 壳排序 力码 leetcode 问题的一些解决方案。 数据结构...
JavaScript数据结构之单链表和循环链表
10-18
在深入了解JavaScript中的单链表和循环链表的实现之前，我们需要先了解数据结构的基本概念。数据结构是计算机存储、组织数据的方式，它有助于更高效地访问和修改数据。数据结构分为线性和非线性两大类，而链表属于非...
【JS数据结构】单向链表
最新发布
早睡早起长头发的博客
10-18 1064
一. 认识链表 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
JS双向链表实现与使用方法示例(增加一个previous属性实现)
10-17
JavaScript作为一门灵活的编程语言，非常适合用来实现各种数据结构，包括双向链表。 本篇文档详细介绍如何使用JavaScript实现双向链表，重点在于增加了一个previous属性，从而使得链表中的每个节点都能通过前驱指针...
js实现单向链表和双向链表
hahahahahahahaha__1的博客
01-31 388
//js实现链表 //单向链表 function LinkedList() { //单链表的节点结构 function Node(ele){ this.element = ele; this.next = null; } this.head = null; ...
js实现单向链表与双向链表
qq_26144233的博客
10-11 241
<!DOCTYPE html> <html> <head> <meta charset="UTF-8"> <title></title> </head> <body> <script type="text/javascript"> //封装单向链表 function LinkedList() { //内部类，节点类 function Node(dat
单向链表和双向链表区别_使用JS实现链表（3）——双向链表
weixin_40001025的博客
12-10 107
在阅读之前，先提示下，这是我用JS实现数据结构之链表篇的专栏文章，在阅读这篇之前，请确保关于链表的前面的几篇都看过。那好了，废话不多说，这篇我们使用JS实现双向链表。同样，该双向链表继承自第二篇中实现的的单向循环链表，而单向循环链表又继承自第一篇中的单链表。如今终于到了双向链表了，此前在Node结构中的prev指针终于派上了用场。由于双向链表多了一个前向指针，所以有些操作和单向链表比较起来反而更加...
用JS实现单向链表
m0_56649557的博客
06-26 245
链表 链表是数据的一种存储结构，一个链表包含若干个节点，每个节点至少包含一个数据域和指针域，指针域指向下一个节点。第0个节点称为头节点，头节点中存放第一个节点的首地址，头节点中没有数据域不存放数据，只是一个指针变量，头节点之后的节点都包含两个域 数据域 存放各种数据 指针域 存放下一个节点的首地址 链表的分类 单向链表 每个节点都只有一个指向其下一个节点的指针域 双向链表 每个节点都有一个指向其前一个节点的指针域和指向其下一个节点的指针域 // 定义节点类 cl
单向链表——JS实现链表的常见操作
u012183426的博客
09-06 176
链表的插入和删除操作时，时间复杂度可以达到O(1)，但是访问慢只能从表头开始访问。 数组的查找快，可以直接通过下标访问，但是删除和插入数据效率低。 insert方法图解 <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>LinkList...
【剑指offer】刷题 之 用javascript 实现寻找两个链表的第一个公共节点
Leo_Franklin的博客
02-03 202
文章目录题目描述解题思路上参考代码 题目描述 输入两个链表，找出它们的第一个公共节点。 示例图 解题思路 有两种情况，一种是两个链表有焦点，一种是没有焦点。此题较为巧妙的解法是利用双指针去走自己的路 和 别人的路。当有公共节点时，分别设置A，B不相交的路程为La，Lb，公共路程为Lc，则A走的总路程为La + Lc +Lb，B走过的路程为Lb + Lc + La 所以走过的路是一样的必然在c1点相遇，此时返回他们的指针即可。而没有相交的情况下，他们只是少了Lc，虽然不会相遇，但是必然同时指向NULL。
使用JavaScript实现单向链表
苦涩记忆
06-08 205
链表是一个存储有序元素的集合，元素在内存中不是连续放置的，每个元素由元素本身节点和指向下一个节点的指针组成。 链表的优点：添加或者移除元素不需要移动其他元素。 链表的缺点：访问链表的元素，需要从表头开始迭代访问。 使用JavaScript实现一个单向链表类： function Linkedlist(){ //辅助类Node var Node = function(element){ //元素节点本身 this.element = element; //指向下一个节点的指针 this.n
JavaScript实现单向链表
quitv的博客
02-01 277
JavaScript实现单向链表 一、单向链表简介 链表和数组一样，可以用于存储一系列的元素，但是链表和数组的实现机制完全不同。链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（有的语言称为指针或连接）组成。类似于火车头，一节车厢载着乘客（数据），通过节点连接另一节车厢。 head属性指向链表的第一个节点； 链表中的最后一个节点指向null； 当链表中一个节点也没有的时候，head直接指向null； 数组存在的缺点： 数组的创建通常需要申请一段连续的内存空间（一整块内存），并且大小是固
基于Node.js的JavaScript单链表和双链表实现
Node.js 环境下 JavaScript 实现单链表与双链表结构 **单链表（LinkedList）的 JavaScript 实现** 在 Node.js 环境下，实现单链表结构是非常重要的，单链表是一种基本的数据结构，它可以用于存储和管理大量的数据...
评论 4
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

优雅哥cc

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

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

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

打赏作者

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

抵扣说明：

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

余额充值