单向链表——JS实现链表的常见操作

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

链表的插入和删除操作时，时间复杂度可以达到O(1)，但是访问慢只能从表头开始访问。

数组的查找快，可以直接通过下标访问，但是删除和插入数据效率低。

insert方法图解

<!DOCTYPE html>
<html>
	<head>
		<meta charset="utf-8">
		<title>LinkList</title>
	</head>
	<body>
	<script type="text/javascript">
		//封装单向链表
		function LinkedList(){
			//内部的类，节点类
			function Node(data){
				this.data = data
				this.next = null
			}
			//属性
			this.head = null
			this.length = 0
			
			//1.追加方法
			LinkedList.prototype.append = function(data){
				//1.创建新的节点
				var newNode = new Node(data)
				//2.判断是否添加的是第一个节点
				
				if(this.length === 0){//2.1 判断是第一个节点
					this.head = newNode
				}else{              //2.2 判断不是第一个节点
					//找到最后一个节点
					var current = this.head
					while(current.next){
						//将下一个节点的值赋值给当前节点
						//（每一个节点的next属性都是等于下一个节点的值）
						current =  current.next
					}
					//最后一个节点的next指向新的节点
					current.next = newNode
				}
				//3.记录链表数据长度
				this.length +=1
			}
		//2.toString方法
		LinkedList.prototype.toString = function(){
			//1.定义变量
			var current = this.head
			var listString = ''
			
			//2.循环获取一个一个的节点
			while(current){
				listString += current.data + ' '
				current = current.next
			}
			return listString
		}
		//3.实现insert方法
		LinkedList.prototype.insert = function(position, data){
			//1.对position进行越界判断
			if(position < 0 | position > this.length) return false
			//2.创建一个新的节点
			var newNode = new Node(data)
			//3.判断节点插入位置是否是第一个
			if(position == 0){
				newNode.next = this.head
				this.head = newNode
			}else{
				var current = this.head
				var index = 0
				var previous = null
				while(index++ < position){
					//position等于this.length的时候,
					//current最后是指向null,previous
					previous = current
					current = current.next
				}
				newNode.next = current
				previous.next = newNode
			}
			this.length +=1
			
		}
		//4.get方法
		LinkedList.prototype.get = function(position){
			//1.越界判断
			if(position <0 || position >= this.length) return false
			
			//2.获取对应的data
			var current = this.head
			var index = 0
			while(index < position){
				current = current.next
				index++
			}
			return current.data
		}
		//5.实现indexOf方法
		LinkedList.prototype.indexOf = function(data){
			var current = this.head
			var index = 0
			while(current){
				if(current.data == data){
					return index
				}
				current = current.next
				index +=1 
			}
			return -1
		}
		//6.update方法
		LinkedList.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方法
			LinkedList.prototype.removeAt = function(position){
				//1.越界判断
				if(position <0 || position >= this.length) return false 
				//2.判断是否是第一个节点
				var current = this.head 
				if(position == 0){
					this.head = this.head.next
				}else{
					var index = 0
					var previous = null
					while(index++ < position){
						previous = current 
						current = current.next 
					}
					//前一个节点的next指向current的next即可
					previous.next = current.next 
				}
				//3.length-1
				this.length -=1
				return current.data
			}
			//8.remove方法
			LinkedList.prototype.remove = function(data){
				//1.获取data在列表中的位置
				var position =  this.indexOf(data)
				//2.根据位置信息,删除节点
				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
		var node = new LinkedList()
		//测试append方法
		node.append(23)
		node.append('tert')
		alert(node)
		node.insert(1,'one')
		alert(node)
		alert(node.get(1))
		alert(node.indexOf('one'))
		alert(node.indexOf(23))
		node.update(0,'two')
		node.update(2,'three')
		alert(node)
		alert(node.removeAt(0))
		alert(node)
	</script>
	</body>
</html>

 

Xaire
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
LeetCode单向链表——删除链表中的节点
那人独钓寒江雪
01-20 166
解法思路：idea:node是被删除的节点,将第二个节点的值修改为第3个节点的值,即将 节点5的值修改为1 然后将第三个节点的值指向空。地址：https://leetcode.cn/problems/delete-node-in-a-linked-list。
js(es6)实现单向链表——链表添加、删除、反转方法的实现
weixin_44607531的博客
01-16 778
1、以下方法中，head指向的节点即头节点的下标（index）为0，即第一个有数据的节点的下标为1。 2、以下方法中，未判断各种特殊情况，如下一个节点不存在的情况，因为如果下一个节点不存在，next为null，正好赋值给了尾节点的next，或正好中断了循环，完全符合逻辑，无需判断各种情况。 3、以下方法未详细描述，可结合链表结构图理解代码
JavaScript链表结构——单向链表
liu_jia_hao的博客
10-01 274
JavaScript链表结构——单向链表 //单向链表类 function LinkList(){ //节点类(data为节点保存的数据，next为下一个节点的地址) function Node(data){ this.data = data this.next = null } //初始化链表head指向 this.head = null //初始化链表长度(节点个数) t...
javascript——单向链表
FormAda的博客
12-15 1790
链表：存储数据一般可以用数组或者链表，不同于数组的是，链表中的元素不必是连续的空间。链表中的每个元素由一个存储元素本身的节点和一个指向下一个元素的引用（指针）组成。
js算法——实现反转链表
在下月亮有何贵干
12-24 4979
题 题目来自leetcode。 定义一个函数，输入一个链表的头节点，反转该链表并输出反转后链表的头节点。 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL /** * Definition for singly-linked list. * function ListNode(val) { * this.val = val; * this.next = null; * } *
javascript 链表——单向链表（附代码）
苹果蜀黍与福尔猫斯
10-10 151
前言 javascript的数据类型有限，本例采用了Object来实现链表的部分特性及功能。 链表节点构造函数 const Node = function (data) { if (!data && data !== 0) return this.data = data // this.next } 链表初始化 const init = () => { // 加入头节点 list = new Node('head') // 加入尾节点
JavaScript数据结构之 —— 04单向链表
邪人君子的博客
08-05 223
链表是由一组节点组成的集合。每个节点都使用一个对象的引用指向它的后继。指向另一个节点的引用叫做链。 插入节点：修改它前面的节点（前驱），使其指向新加入的节点，而新加入的节点则指向原来前驱指向的节点。 删除节点：将待删除元素的前驱节点指向待删除元素的后继节点，将待删除元素指向 null，元素就删除成功了。 单向链表 单向链表包含两个类。Node 类用来表示节点，LinkedList 类提供了插入...
JavaScript数据结构——单向链表
最新发布
qq_52748669的博客
08-24 152
JavaScript数据结构——单向链表
JS数据结构（5）——单向链表
echomsy的博客
07-06 169
JS数据结构（5）——单向链表 链表和数组的区别： 数组的优缺点： 数组是最常用的数据结构，它用来存储多个元素。 几乎每一种编程语言中都有默认实现数组结构，并且有很多关于数组的操作方法。 数组的修改和查找操作，时间复杂度低。 数组的创建通常需要申请一段连续的内存空间，并且大小是固定的，所以当当前的数组不能满足容量需求的时候，就需要扩容（一般情况下会申请一个更大的数组，比如说原数组的2倍，然后将原数组中的元素再复制过去）,这对空间造成了大量浪费。 而且在数组开头或者中间插入数据的成本非常高，需要进行大量元素
单向链表基本操作的递归实现
08-10
在本文中，我们将探讨如何使用递归实现单向链表的一些基本操作。 1. **统计节点个数**：`count_listnode`函数通过递归遍历链表，计算节点总数。在递归调用中，它首先检查当前节点是否非空，然后递增计数器`count`，...
C语言实现单向链表及操作
03-24
数据结构，c语言实现的单向链表。代码分享 struct LinkNode { int data; struct LinkNode *next; }; typedef struct LinkNode *Lnode;
C语言单向链表的表示与实现实例详解
12-31
C语言中的单向链表（单链表）是链表的一种，其特点是链表的链接方向是单向的，对链表的访问要通过顺序读取从头部开始。 链表中最简单的一种是单向链表，它包含两个域，一个信息域和一个指针域。这个链接指向列表中的...
Java实现单向链表反转
08-27
单向链表反转的应用非常广泛，例如在数据处理中，我们可以使用单向链表反转来实现数据的反转操作。在数据分析中，我们可以使用单向链表反转来实现数据的排序操作。 下面是Java实现单向链表反转的代码示例： ```...
js单向链表的具体实现实例
12-01
总的来说，这个JS单向链表的实现是基础且实用的，可以用于处理需要线性数据结构的问题，例如在内存有限或需要高效插入、查找和遍历数据的场景。然而，它缺乏一些高级特性，如迭代器支持，或者对链表的排序功能，这些...
栈——后进先出（LIFO：last in first out）
u012183426的博客
08-24 3115
栈：后进先出（LIFO：last in first out） 例如：自助餐中的自取餐盘 面试题目：有六个元素6 5 4 3 2 1 的顺序进栈，哪一个不是合法的出栈序列： A. 5 4 3 6 1 2 B.4 5 3 2 1 6 C.3 4 6 5 2 1 D.2 3 4 1 5 6 解析：进入栈的顺序保持6 5 4 3 2 1 ，3出栈所以栈中现在是从栈底-->栈顶依次为6...
队列（Queue——先进先出（FIFO First In First Out）
u012183426的博客
08-29 1728
栈和队列都是一种受限的线性结构 队列是数据从表的后端rear进行插入，表的前端front删除操作。 应用场景：打印队列、线程队列 基于数组实现的Demo <!DOCTYPE html> <html> <head> <meta charset="utf-8"> <title>封装队列基...
树结构——javascript实现删除及其他方法
u012183426的博客
10-14 1131
非线性结构 树的术语： 节点的度——节点的子树点个数 树的度——树的所有节点中最大的度数 任何一颗树最后都可以用二叉树（每个节点的子节点最多只有2个）模拟 二叉搜索树（BST, Binary Search Tree）,又称为二叉排序树或二叉找树 查找效率高 <!DOCTYPE html> <html> <head> &l...
冒泡排序、插入排序、希尔排序、快速排序比较
u012183426的博客
10-31 935
冒泡排序O(n^2) =选择排序O(n^2)> 插入排序O(n^2)>希尔排序O(n^(3/2))>快速排序O(nlogn) 详解参考 https://www.jianshu.com/p/f1f2dc978762https://www.jianshu.com/p/8940e7030ff4 冒泡排序：从左往右比较并交换最大值得位置，将最大值放在最右侧；循环这一操作 选择排序：...
C++实现单向链表操作的数据结构
"这篇文档是关于数据结构中的链表，主要使用C++语言进行实现，包括单向链表的各种基本操作，如初始化、清除、获取长度、检查空表、获取指定位置元素、遍历和查找元素等。" 链表是一种在计算机科学中广泛使用的数据...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值