双向链表的js实现

最新推荐文章于 2022-03-23 22:07:55 发布
最新推荐文章于 2022-03-23 22:07:55 发布
阅读量315 收藏
点赞数
分类专栏： javaScript数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u012183426/article/details/100779056
版权

双向链表：既可以从表头开始遍历也可以从表尾开始遍历

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>双向链表</title>
	</head>
	<body>
		<script>
			//封装双向链表
			function DoublyLinkedList(){
				//内部类
				function Node(data){
					this.data = data 
					this.prev = null
					this.next = null
				}
				//属性
				this.head = null
				this.tail = null 
				this.length = 0
				//1.append方法
				DoublyLinkedList.prototype.append = function(data){
					//1.创建新的节点
					var newNode = new Node(data)
					//2.判断是否为第一个节点
					if(this.length == 0){
						this.head = newNode
						this.tail = newNode
					}else{
						newNode.prev = this.tail 
						this.tail.next = newNode 
						this.tail = newNode 
					}
					//3.length+1
					this.length +=1
				}
				//2.将链表转变为字符串形式
				//2.1 toString方法
				DoublyLinkedList.prototype.toString = function(){
					return this.backwardString()
				}
				//2.2 forwardString方法
				DoublyLinkedList.prototype.forwardString = function(){
					//1.定义变量
					var current = this.tail
					var resultString = ''
					//2.依次向后遍历,获取每一个节点
					while(current){
						resultString += current.data+ ''
						current = current.prev
					}
					return resultString
				}
				//2.3 backwardString方法
				DoublyLinkedList.prototype.backwardString = function(){
					//1.定义变量
					var current = this.head
					var resultString = ''
					//2.依次向后遍历,获取每一个节点
					while(current){
						resultString += current.data+ ' '
						current = current.next
					}
					return resultString
				}
				//3.insert方法
				DoublyLinkedList.prototype.insert = function(position, data){
					//1.越界判断
					if(position <0 || position > this.length ) return false 
					//2.创建新的节点
					var newNode = new Node(data)
					//3.判断原来列表是否为空
					if(this.length == 0){
						this.head = newNode
						this.tail = newNode
						
					}else{
						if(position == 0){//3.1 判断插入位置是否为0
							this.head.prev = newNode //原来的第一个节点.prev = newNode
							newNode.next = this.head// newNode.next= 原来的第一个节点
							this.head = newNode
						}else if(position == this.length){//3.2判断插入位置是否为最后一位
							newNode.prev = this.tail
							this.tail.next = newNode
							this.tail = newNode
						}else{
							var current = this.head
							var index = 0
							while(index++ < position){
								current = current.next//current为要插入点的后一个节点
							}
							newNode.next = current
							newNode.prev = current.prev
							current.prev.next = newNode
							current.prev = newNode
						}
					}
					//4.length+1
					this.length+=1
					console.log(this.length)
					return true
				}
				//4.get方法
				DoublyLinkedList.prototype.get = function(position){
					//1.越界判断
					if(position < 0|| position >= this.length) return false
					//this.length/2 > position :从头向后遍历
					//this.length/2 < position :从后往前遍历 index-->position
					//2.获取元素
					var current = this.head
					var index = 0
					while(index++ < position){
						current = current.next
					}
					console.log(current.data)
					return current.data
				}
				//5.indexOf方法
				DoublyLinkedList.prototype.indexOf = function(data){
					//1.定义变量
					var current = this.head
					var index=0
					//2.找到与data相同的节点
					while(current){
						if(current.data == data){
							return index
						}
						current = current.next
						index+=1
					}
					console.log(index)
					return -1
				}
				//6.update方法
				DoublyLinkedList.prototype.update = function(position,newData){
					//1.越界判断
					if(position <0 || position>= this.length) return false
					//2.查找节点
					var current = this.head 
					var index = 0
					while(index++ < position){
						current = current.next
					}
					current.data = newData
					return true
				}
				//7.removeAt方法
				DoublyLinkedList.prototype.removeAt = function(position){
					//1.越界判断
					if(position<0 || position>=this.length) return null
					//2.判断是否只有一个节点
					var 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{
							var index = 0
							while(index++ < position){
								current = current.next
							}
							current.prev.next = current.next
							current.next.prev = current.prev
						}
					}
					//3.length-1
					this.length-=1
					return current.data
				}
				//8.remove方法
				DoublyLinkedList.prototype.remove = function(data){
					var  index = this.indexOf(data)
					return this.removeAt(index)
				}
				DoublyLinkedList.prototype.isEmpty = function(data){
					return this.length==0
				}
				DoublyLinkedList.prototype.size = function(data){
					return this.length
				}
				DoublyLinkedList.prototype.getHead = function(data){
					return this.head.data
				}
				DoublyLinkedList.prototype.getTail = function(data){
					return this.tail.data
				}
				
			}
			
			var doubly = new DoublyLinkedList()
			doubly.append('abc')
			doubly.append('def')
			doubly.append('hjk')
			alert(doubly)
			doubly.insert(0,'123')
			doubly.insert(2,'456')
			doubly.insert(5,'789')
			alert(doubly)
			alert(doubly.get(5))
			alert(doubly.indexOf('789'))
			doubly.update(5,'012')
			alert(doubly)
			alert(doubly.removeAt(0))
			alert(doubly.removeAt(1))
			alert(doubly)
			alert(doubly.removeAt(3))
			alert(doubly)
			alert(doubly.remove('def'))
			
		</script>
	</body>
</html>

 

Xaire
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【JS数据结构】双向链表
早睡早起长头发的博客
10-25 858
一. 认识双向链表 1.单向链表 1.1 概念 1.2 实现的原理 1.3 缺点 2.双向链表 2.1 概念 2.2 实现的原理 2.3 缺点 2.4 双向连接的特点图解 二.双向链表的创建 1.创建一个双向链表的类 2.双向链表的常见操作 2.1append(element)尾部追加数据 2.2 将链表转成字符串形式 2.3 insert(position, element)任意位置插入 2.4 get(position)获取对应位置的元素 2.5 indexOf(el
JavaScript实现双向链表
雨的印记的博客
02-26 361
JavaScript实现双向链表 JavaScript实现双向链表 一、双向链表简介 双向链表：既可以从头遍历到尾，又可以从尾遍历到头。也就是说链表连接的过程是双向的，它的实现原理是：一个节点既有向前连接的引用，也有一个向后连接的引用。 双向链表的缺点： 每次在插入或删除某个节点时，都需要处理四个引用，而不是两个，实现起来会困难些； 相对于单向链表，所占内存空间更大一些； 但是，相对于双向链表的便利性而言，这些缺点微不足道。 双向链表的结构： 双向链表不仅有head指针指向第一个节点，而且有tail
双向链表的实现(js)
weixin_53781355的博客
01-13 320
文章目录 文章目录 目录 文章目录 文章目录 前言 一、双向链表的概念 二、双向链表的实现 1.双向链表的封装 1.解析和单向链表的封装基本原理大同小异 2.双向链表的一些基本方法 2.读入数据 总结 前言 本文将介绍双向链表的基本原理和实现 一、双向链表的概念 由单向链表的缺点引出双向链表的概念：在实际开发中我们经常遇到需要回到上一个节点的情况，这个时候单向链表又需要回到第一个节点，逐个遍历，才能达到需求，恰恰双向链表可以...
Js实现双向链表
xiayngbaidu12345的博客
03-23 445
1.实现双向链表的插入（尾插法） 图解： 对于第二种情况，其中②③步可以颠倒。 代码实现： //向链表尾部添加一个新的项(尾插法) DoubleLinkedList.prototype.append=function(data){ //创建一个新节点 var newNode=new Node(data); //当插入的节点为第一个节点时 if(this.length==0){ this.head=newN
js双向链表代码实现
hulover的博客
02-11 451
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 <!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <meta http-equiv="X-UA-Compatible" content="IE=edge"&g
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
以下是一个简单的JavaScript实现双向链表的代码： ```javascript function DoublyLinkedList() { var Node = function(element) { this.element = element; this.next = null; this.prev = null; }; var ...
lijst:JavaScript 双向链表实现
05-31
JavaScript 双向链表实现 当前 API 状态： lijst Capacity ✓ # empty() ✓ # length Element access ✓ # front() ✓ # back() Modifiers ✓ # assign() ✓ # pushFront() ✓ # popFront() ✓ # push...
JS双向链表实现与使用方法示例(增加一个previous属性实现)
10-17
本篇文档详细介绍如何使用JavaScript实现双向链表，重点在于增加了一个previous属性，从而使得链表中的每个节点都能通过前驱指针和后继指针访问其前一个节点和后一个节点。这与传统的单链表不同，在单链表中，节点...
js实现双向链表互联网机顶盒实战应用实现
10-28
在本文中，我们将探讨如何使用JavaScript实现双向链表，并将其应用于互联网机顶盒的实战场景。双向链表是一种数据结构，它允许我们在列表中的每个节点都有指向其前后节点的引用，从而可以在列表的任何位置进行高效的...
使用JS实现双向链表
yangaoyuan1999的博客
11-09 1335
1.双向链表 双向链表和普通链表的区别在于，在链表中，一个节点只有链向下一个节点的链接，而在双向链表中，链接是双向的，一个链向下一个元素，另一个链向前一个元素 2.双向链表的优缺点 每次在插入或删除某个节点时，都需要处理四个引用，而不是两个，实现起来会困难些 相对于单向链表，所占内存空间更大一些； 但是，相对于双向链表的便利性而言，这些缺点微不足道。 3.双向链表的常见操作： append（element）：向链表尾部添加一个新的项； inset（position，element）：向链表的特定位置插入
JavaScript 数据结构与算法（七）双向链表
weixin_42572968的博客
03-25 117
JavaScript 数据结构与算法（七）双向链表 单向链表和双向链表 单向链表 只能从头遍历到尾或者从尾遍历到头（一般从头到尾）。 链表相连的过程是单向的，实现原理是上一个节点中有指向下一个节点的引用。 单向链表有一个比较明显的缺点：可以轻松到达下一个节点，但回到前一个节点很难，在实际开发中, 经常会遇到需要回到上一个节点的情况。 双向链表 既可以从头遍历到尾，也可以从尾遍历到头。 链表相连的过程是双向的。实现原理是一个节点既有向前连接的引用，也有一个向后连接的引用。 双向链表可以有效的解决单向链表
使用JavaScript实现双向链表
苦涩记忆
06-09 475
双向链表中共有两指针，一个指向上一个元素，一个指向下一个元素。 js实现双向链表： //基于数组实现双向链表 function DoublyLinkedList() { var Node = function(element){ this.element = element; this.next = null; //指向下一个元素的指针 this.prev = null; //指向上一个指针的元素 }; var length = 0; //链表的长度 var head = null; /
JavaScript链表结构——双向链表
liu_jia_hao的博客
10-02 191
JavaScript——双向链表 //双向链表类 function DoublyLinkList(){ //节点类 function Node(data){ this.data = data this.pre = null this.next = null } //初始化属性 this.head = null this.tail = null this.length = ...
JavaScript中的双向链表
小瑾沐晚风的博客
10-03 329
双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。 &lt;!DOCTYPE html&gt; &lt;html&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &lt;title&gt;&lt;/title&
JS实现双向链表
StarFishing
12-22 3902
链表结构是我们在面试中经常会被问起的较为基础的数据结构问题，起初学习数据结构使用的是C++语言，最近在做前端面试题的过程中没碰到了需要用js实现双链表的需求，百度出来的文章发现可很多错误，于是索性自己重新写了，并且列出了一些错误点，这里给大家较为详细的一步步看一下实现思想和步骤，相较于C++语言，js的实现可以说是很简单了，不需要创建繁琐的对象，更加直观易懂； 首先我们来看一下双向链表的结构图： ...
javascript——双向链表
FormAda的博客
12-16 1472
双向链表：既可从头遍历到尾又可从尾遍历到头。
数据结构（JS实现）——双向链表的实现
M_Edison的博客
01-28 351
文章目录一、什么是双链表？二、双向链表的特点三、 双向链表的封装四、双链表常见的操作（增删改查）4.1 append(element)：向链表尾部添加一个新的项4.2 insert(position,element):向链表的特定位置插入一个新的项4.3 get(position):获取对应位置的元素4.4 indexOf(element):返回元素在列表上的索引。如果链表上没有该元素则返回-14.5 updata（position，element）：更新某个元素4.6 removeAt（pos
双向链表与环状链表：Vue定时器优化与Fortran编程介绍
在本文档中，我们主要探讨了在编程中两种重要的数据结构——双向链表和环状链表，特别是在Vue.js背景下，如何优化定时器setInterval的使用。首先，双向链表和环状链表与单向链表相比，提供了更大的灵活性。在单向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值