js实现单向链表与双向链表

最新推荐文章于 2023-12-01 15:18:04 发布
最新推荐文章于 2023-12-01 15:18:04 发布
阅读量215 收藏
点赞数
分类专栏： js 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26144233/article/details/109019186
版权 
<!DOCTYPE html>
<html>

	<head>
		<meta charset="UTF-8">
		<title></title>
	</head>

	<body>
		<script type="text/javascript">
			//封装单向链表
			function LinkedList() {

				//内部类，节点类
				function Node(data) {
					this.data = data;
					this.next = null; //指向下一个节点
				}
				this.head = null; //头指针,开始指向第一个节点
				this.length = 0;
				//链表 尾部 追加新的元素
				LinkedList.prototype.append = function(data) {
					var newNode = new Node(data);
					if(this.length == 0) { //判断追加的是否是第一个节点
						this.head = newNode;
					} else { //不是第一个节点
						var current = this.head;
						//找到原来链表的最后一个节点，其next指向新加的节点。
						while(current.next) { //当前节点不是最后一个节点
							//当前节点指向下一个节点，直到最后一个节点
							current = current.next;
						}
						current.next = newNode;
					}
					this.length += 1;
				}

				LinkedList.prototype.toString = function() {
					var current = this.head; //指向第一个元素
					//					console.log(current,111)
					var listString = '';
					while(current) {
						listString += current.data + "  ";
						current = current.next;
					}
					//					console.log(listString);
					return listString;
				}
				LinkedList.prototype.insert = function(position, data) {
					//越界判断
					if(position < 0 || position > this.length) {
						return false;
					}
					var newNode = new Node(data);
					//分情况插入-1.头部插入
					if(position == 0) {
						newNode.next = this.head;
						this.head = newNode;
					} else {
						//--中间或者尾部插入
						var current = this.head;
						var previous = null;
						var index = 0;
						while(index++ < position) {
							previous = current;
							current = current.next;
						}
						newNode.next = current;
						previous.next = newNode;
					}
					//长度加1
					this.length += 1;
					return true;
				}
				LinkedList.prototype.get = function(position) {
					if(position < 0 || position >= this.length) {
						return false;
					} else {
						var index = 0;
						var current = this.head;
						while(index++ < position) {
							current = current.next;
						}
						return current.data;
					}
				}
				LinkedList.prototype.indexOf = function(element) {
					if(!element) {
						return false;
					}
					var current = this.head;
					var index = 0;
					while(element != current.data && index < this.length) {
						current = current.next;
						index++;
					}
					if(index >= this.length) {
						return false;
					}
					return index;

				}
				LinkedList.prototype.indexOf = function(data) {
					var index = 0;
					var current = this.head;
					while(current) {
						if(current.data == data) {
							return index;
						}
						current = current.next;
						index += 1;
					}
					//到最后没有找到该元素，返回-1
					return -1;
				}
				//类似get
				LinkedList.prototype.update = function(position, data) {
					var index = 0;
					if(position < 0 || position > this.length - 1) {
						return false;
					}
					var current = this.head;
					while(index++ < position) {
						current = current.next;

					}
					current.data = data;
					return true;
				}
				LinkedList.prototype.removeAt = function(position) {
					if(position < 0 || position >= this.length) {
						return null;
					}
					var current = this.head;
					var previous = null;
					if(position == 0) {
						this.head = this.head.next;
					} else {
						var index = 0;
						while(index++ < position) {
							previous = current;
							current = current.next;
						}
						//前一个节点的next 指向  当前节点的next
						previous.next = current.next;
						
					}
					this.length -= 1;
					return current.data;
					//前一个节点的next 指向  当前节点的next
					//					previous.next = current.next;
					//前一个节点 就是 当前节点的下一个节点
					//					previous=current.next;
				}
				LinkedList.prototype.remove=function(data){
					var position=this.indexOf(data);
//					return this.removeAt(position);
					if (position<0||position>this.length-1) {
						return false ;
					}
					if (position==0) {
						this.head=this.head.next;
					} else{
						var current=this.head;
						var previous=null;
						var index=0;
						while (index++<position){
							previous=current;
							current=current.next;
						}
						previous.next=current.next;
						
					}
					this.length-=1;
					return true;
				}
				LinkedList.prototype.isEmpty=function(){
					return this.length==0;
				}
				LinkedList.prototype.size=function(){
					return this.length;
				}
			}

			var linkedList = new LinkedList();
			linkedList.append(12);
			linkedList.append(13);
			linkedList.insert(2, 15);
			linkedList.append(14);
			linkedList.insert(0, 18);
			linkedList.insert(-1, 100);
			linkedList.insert(10, 17);
			linkedList.insert(5, 19);
			console.log(linkedList.toString());
			console.log('0--', linkedList.get(0), '2--', linkedList.get(2), '5--', linkedList.get(5), linkedList.get(-1), linkedList.get(8))
			//			alert(linkedList)
			console.log(linkedList);
			console.log(linkedList.indexOf(12), linkedList.indexOf(15), linkedList.indexOf(19), linkedList.indexOf(17))
			console.log(linkedList.indexOf(12), linkedList.indexOf(19), linkedList.indexOf(20));
			linkedList.update(0, 12);
			linkedList.update(5, 18);
			linkedList.update(19, 1);
			console.log(linkedList.toString());
			console.log(linkedList.removeAt(0));
			console.log(linkedList.removeAt(2));
			console.log(linkedList.remove(14))
			console.log(linkedList.toString(),linkedList.isEmpty(),linkedList.size());
		</script>
	</body>

</html>

<!DOCTYPE html>
<html>

	<head>
		<meta charset="UTF-8">
		<title></title>
	</head>

	<body>
		<script type="text/javascript">
			function DoublyLinkedList() { //双向链表
				this.length = 0;
				this.head = null;
				this.tail = null;

				function Node(data) { //链表中节点
					this.prev = null;
					this.next = null;
					this.data = data;
				}
				//尾部追加元素
				DoublyLinkedList.prototype.append = function(data) {
					var newNode = new Node(data);
					if(this.length == 0) {
						this.head = newNode;
						this.tail = newNode;
					} else {
						//						新节点的prev指向原来最后的节点；newNode.prev=this.tail;
						newNode.prev = this.tail;
						//						原来最后节点的next指向新节点 ；this.tail.next=newNode;
						this.tail.next = newNode;
						this.tail = newNode;
					}
					this.length += 1;
				}
				//从前向后 遍历,将链表转化为字符串
				DoublyLinkedList.prototype.backwardString = function() {
					var result = '';
					var current = this.head;
					while(current) {
						result += current.data + " ";
						current = current.next;
					}
					return result;
				}
				//从后向前遍历,将链表转化为字符串
				DoublyLinkedList.prototype.forwardString = function() {
					var result = "";
					var current = this.tail;
					while(current) {
						result += current.data + " ";
						current = current.prev;
					}
					return result;
				}
				//从前向后 遍历,将链表转化为字符串
				DoublyLinkedList.prototype.toString = function() {
					return this.backwardString();
				}
				//插入
				DoublyLinkedList.prototype.insert = function(position, data) {
					if(position < 0 || position > this.length) {
						return false;
					}
					var newNode = new Node(data);
					if(this.length == 0) { //原来链表为空
						this.head = newNode;
						this.prev = newNode;
					} else {
						if(position == 0) { //原来链表为非空，在头部插入
							this.head.prev = newNode;
							newNode.next = this.head;
							this.head = newNode; //上面三行该行必须最后
						} else if(position == this.length) { //原来链表为非空，在尾部插入
							newNode.prev = this.tail;
							this.tail.next = newNode;
							this.tail = newNode; //上面三行该行必须最后
						} else { //原来链表为非空，在中间插入
							var index = 0;
							var current = this.head;
							while(index++ < position) {
								current = current.next;
							}
							//此时，current指向要插入的位置
							newNode.next = current;
							newNode.prev = current.prev;
							current.prev.next = newNode;
							current.prev = newNode; //上面四行该行必须最后

						}
					}

					this.length += 1;
					return true;
				}
				DoublyLinkedList.prototype.get = function(position) {
					if(position < 0 || position >= this.length) {
						return false;
					}
					var middle = this.length / 2;
					if(middle > position) { //position在链表前半部分
						var index = 0;
						var current = this.head;
						while(index++ < position) {
							current = current.next;
						}
						return current.data;
					} else { //position在链表后半部分
						var index = this.length - 1;
						var current = this.tail;
						while(index-- > position) {
							current = current.prev;
						}
						return current.data;
					}

				}
				DoublyLinkedList.prototype.indexOf = function(data) {
					if(!data) {
						return -1;
					}
					var current = this.head;
					var index = 0
					while(current) {
						if(current.data == data) {
							return index;
						}
						current = current.next;
						index++;
					}
					return -1;
				}
				DoublyLinkedList.prototype.update = function(position, data) {
					if(position < 0 || position >= this.length) {
						return false;
					}
					var current = this.head;
					var index = 0;
					while(index++ < position) {
						current = current.next;
					}
					current.data = data;
					return true;
				}
				DoublyLinkedList.prototype.removeAt = function(position) {
					if(position < 0 || position >= this.length) {
						return null;
					}
					var current = this.head;
					
					if(this.length == 1) {
						this.head = null;
						this.tail = null;
					} else {
						if(position == 0) { //如果删除的是第一个元素
							//							this.head = null;
							//							this.tail = null;
							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;
						}
					}

					this.length -= 1;
					return current.data;
				}
				
				DoublyLinkedList.prototype.remove=function(data){
					var index=this.indexOf(data);
					return this.removeAt(index);
				}
				DoublyLinkedList.prototype.isEmpty=function(){
					return this.length==0;
				}
				DoublyLinkedList.prototype.size=function(){
					return this.length;
				}
				DoublyLinkedList.prototype.getHead=function(){
					return this.head.data;
				}
				DoublyLinkedList.prototype.getTail=function(){
					return this.tail.data;
				}
			}

			var list = new DoublyLinkedList();
			list.append(12);
			list.append(9);
			list.append(18);
			list.insert(0, 10);
			list.insert(3, 8);
			list.insert(5, 5);
			list.insert(10, 82);
			//			alert(list);
			console.log(list)
			console.log(list.toString());
			console.log(list.backwardString());
			console.log(list.forwardString());
			console.log(list.get(0), list.get(5), list.get(7), list.get(3), list.get(2));
			console.log(list.indexOf(-1), list.indexOf(9), list.indexOf(5), list.indexOf(8));
			list.update(1, 2);
			list.update(5, 7);
			list.update(-1, 45);
			list.update(7, 8);
			console.log(list.toString());
			console.log(list.removeAt(-1), list.removeAt(6), list.removeAt(0),list.removeAt(4) ,list.removeAt(1),list.toString());
			//list.removeAt(3),
			console.log(list.toString());
//			console.log(list.remove(8),list.remove(89),list.remove(2),list.remove(18),list.toString());
			console.log(list.isEmpty(),list.getHead(),list.getTail(),list.size());
		</script>
	</body>

</html>
qq_26144233
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
单向链表、双向链表
Dear
07-12 587
单向链表 链表和数组一样，都可以用于存储一系列的元素。链表的每个结点（最后一个结点除外）由一个存储元素本身的结点的数据和一个指向下一个元素的引用（指针）组成。 这有点类似于一个火车，火车的每节车厢都装着自己的东西并连接着下一节车厢（最后一节车厢除外）。 链表通常有一个head 属性（头指针）一直指向第一个结点，最后一个结点指向 null 数组与链表的对比 数组 内存中是一块连续的空间，一般需要提前分配固定的空间大小，空间利用率不高 在数组的起始位置插入和删除数据效率低，改变一个数据需要移动后续所有的数据
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
首先，双向链表（Doubly Linked List）与普通的单向链表的主要区别在于，每个节点不仅包含指向下一个节点的指针，还包含一个指向前一个节点的指针。这种设计使得在链表中进行双向迭代成为可能，可以从头到尾，也可以...
Javascript 实现单向链表和双向链表
weixin_44996454的博客
08-11 124
链表原理：链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)
js实现单向链表和双向链表
hahahahahahahaha__1的博客
01-31 383
//js实现链表 //单向链表 function LinkedList() { //单链表的节点结构 function Node(ele){ this.element = ele; this.next = null; } this.head = null; ...
JavaScript实现单向链表
qq_42710593的博客
03-12 617
JavaScript实现单向链表
JavaScript实现双向链表
qq_42710593的博客
03-12 1183
JavaScript实现双向链表
数据结构（二）：单向链表、双向链表
weixin_42044763的博客
02-11 2067
链表和数组一样，可以用于存储一系列的元素，但是链表和数组的实现机制完全不同。链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（有的语言称为指针或连接）组成。类似于火车头，一节车厢载着乘客（数据），通过节点连接另一节车厢。head属性指向链表的第一个节点；链表中的最后一个节点指向null；当链表中一个节点也没有的时候，head直接指向null；双向链表：既可以从头遍历到尾，又可以从尾遍历到头。
【数据结构与算法】JavaScript实现单向链表
一个前端开发者
11-13 318
链表和数组一样，可以用于存储一系列的元素，但是链表和数组的实现机制完全不同。链表的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（有的语言称为指针或连接）组成。类似于火车头，一节车厢载着乘客（数据），通过节点连接另一节车厢。head属性指向链表的第一个节点；链表中的最后一个节点指向null；当链表中一个节点也没有的时候，head直接指向null；数组的创建通常需要申请一段连续的内存空间（一整块内存），并且大小是固定的。所以当原数组不能满足容量需求时，需要扩容。
用JS实现单向链表
m0_56649557的博客
06-26 239
链表 链表是数据的一种存储结构，一个链表包含若干个节点，每个节点至少包含一个数据域和指针域，指针域指向下一个节点。第0个节点称为头节点，头节点中存放第一个节点的首地址，头节点中没有数据域不存放数据，只是一个指针变量，头节点之后的节点都包含两个域 数据域 存放各种数据 指针域 存放下一个节点的首地址 链表的分类 单向链表 每个节点都只有一个指向其下一个节点的指针域 双向链表 每个节点都有一个指向其前一个节点的指针域和指向其下一个节点的指针域 // 定义节点类 cl
【数据结构】自己动手使用JavaScript实现单向链表、双向链表（第四篇）
weixin_45620943的博客
12-01 87
以上，如有不合理之处，还请帮忙指出，大家一起交流学习~
JavaScript数据结构之双向链表定义与使用方法示例
10-19
本文将深入探讨双向链表的定义、工作原理以及如何在JavaScript中实现和使用它。 双向链表，顾名思义，是每个节点不仅包含指向其后继节点的指针，还包含一个指向前驱节点的指针。这种设计使得双向链表在遍历和修改时...
JavaScript数据结构与算法之链表
10-22
单向链表在JavaScript中的实现通常会有一个构造函数`LinkedList`，这个构造函数内部定义了一个节点构造函数`Node`，用于创建链表节点。每个节点包含两个属性：`element`用于存储数据，`next`用于存储指向下一个节点...
js实现表格中最多显示两行，超出使用省略号
qq_26144233的博客
11-11 3453
//HTML: { field: 'Description', align: 'left', title: '描述', width: 239, templet: function (d) { return '<span class="description">' + d.Description + '</span>' } .
js实现深度优先与广度优先
qq_26144233的博客
01-22 1845
深度优先遍历(Depth First Search, 简称 DFS) 与广度优先遍历(Breath First Search)是图论中两种非常重要的算法，生产上广泛用于拓扑排序，寻路(走迷宫)，搜索引擎，爬虫等，也频繁出现在 leetcode，高频面试题中。 深度优先遍历 (1)递归实现 主要思路是从图中一个未访问的顶点 V 开始，沿着一条路一直走到底，然后从这条路尽头的节点回退到上一个节点（看该节点 是否还有除该子节点以外的节点，没有继续回退到父节点，有则遍历该子节点之外的其他节点），再从另一条路开始走
div,contenteditable编辑器之ctrl+enter换行，enter发送
qq_26144233的博客
01-20 1311
<!doctype html> <html lang="en"> <head> <meta http-equiv="X-UA-Compatible" content="IE=edge,chrome=1"> <meta charset="utf-8"> <title>contenteditable,Ctrl+Enter换行，Enter发送</title> <meta name="description..
拖拽Drag 和 Drop 事件
qq_26144233的博客
11-24 1128
DataTransfer 对象 所有 drag 和 drop 事件的事件监听器都接收一个 Event 对象作为参数，它有一个叫做 dataTransfer 的只读属 性。event.dataTransfer 返回与事件相关的 DataTransfer 对象，DataTransfer 对象持有 drag 和 drop 操作相关的数据。可以检索这些数据以及设置 DataTransfer 对象相关联 的各种属性，正如下面所阐述的 <!DOCTYPE HTML> <html> <he
mock模拟后端数据
qq_26144233的博客
01-16 833
1.正则匹配路径 Mock.mock(RegExp('/Api/EnterpriseQq/Manage/UsageRecord' + '.*'), 'get', function (option) { console.log(option); //获得?之后的参数 var querys = option.url.split('?')[1]; // var keys=[]; // var ...
虚拟节点-vnode与真实节点-node转化
qq_26144233的博客
01-15 833
<script> // <div id="outer" class="border">I am your father</div> // => （转化为虚拟dom） // {tag:'div',data:{id:'outer',class:'border'},children:[],value:'I am your father'} class VNode{ /*tag:标签名，..
单向链表和双向链表的优缺点
最新发布
03-22
单向链表和双向链表都是常见的链表数据结构，它们在存储和操作数据时有一些不同之处。...双向链表相对于单向链表在插入和删除节点时更加灵活，并且可以实现正向和反向遍历，但需要额外的空间来存储前一个节点的指针。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值