数据结构与算法JavaScript (三) ：链表

最新推荐文章于 2024-01-12 07:15:00 发布
转载 最新推荐文章于 2024-01-12 07:15:00 发布 · 543 阅读 · 1
文章标签：

#javascript #数据结构 #单链表

我们可以看到在javascript概念中的队列与栈都是一种特殊的线性表的结构，也是一种比较简单的基于数组的顺序存储结构。由于javascript的解释器针对数组都做了直接的优化，不会存在在很多编程语言中数组固定长度的问题(当数组填满后再添加就比较困难了，包括添加删除，都是需要把数组中所有的元素全部都变换位置的，javascript的的数组确实直接给优化好了，如push,pop,shift,unshift,split方法等等…)

线性表的顺序存储结构，最大的缺点就是改变其中一个元素的排列时都会引起整个合集的变化，其原因就是在内存中的存储本来就是连贯没有间隙的，删除一个自然就要补上。针对这种结构的优化之后就出现了链式存储结构，换个思路，我们完全不关心数据的排列，我们只需要在每一个元素的内部把下一个的数据的位置给记录就可以了，所以用链接方式存储的线性表简称为链表，在链式结构中，数据=（信息+地址）

链式结构中，我们把地址也可以称为“链”，一个数据单元就是一个节点，那么可以说链表就是一组节点组成的合集。每一个节点都有一个数据块引用指向它的下一个节点

数组元素是靠位置关系做逻辑引用，链表则是靠每一个数据元保存引用指针关系进行引用

这种结构上的优势就非常明显的，插入一个数据完全不需要关心其排列情况，只要把“链”的指向衔接上

这样做链表的思路就不会局限在数组上了，我们可以用对象了，只要对象之间存在引用关系即可

链表一般有，单链表、静态链表、循环链表、双向链表

单链表：就是很单一的向下传递，每一个节点只记录下一个节点的信息，就跟无间道中的梁朝伟一样做卧底都是通过中间人上线与下线联系，一旦中间人断了，那么就无法证明自己的身份了，所以片尾有一句话：”我是好人，谁知道呢？”

静态链表：就是用数组描述的链表。也就是数组中每一个下表都是一个“节”包含了数据与指向

循环链表：由于单链表的只会往后方传递，所以到达尾部的时候，要回溯到首部会非常麻烦，所以把尾部节的链与头连接起来形成循环

双向链表：针对单链表的优化，让每一个节都能知道前后是谁，所以除了后指针域还会存在一个前指针域，这样提高了查找的效率，不过带来了一些在设计上的复杂度，总体来说就是空间换时间了

综合下，其实链表就是线性表中针对顺序存储结构的一种优化手段，但是在javascript语言中由于数组的特殊性（自动更新引用位置），所以我们可以采用对象的方式做链表存储的结构

单链表

我们实现一个最简单的链表关系

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
function createLinkList() {
     var _this = {},
         prev = null ;
     return {
         add: function (val) {
             //保存当前的引用
             prev = {
                 data: val,
                 next: prev || null
             }
         }
     }
}
var linksList = createLinkList();
linksList.add( "arron1" );
linksList.add( "arron2" );
linksList.add( "arron3" );
//node节的next链就是 -arron3-arron2-arron1

通过node对象的next去直引用下一个node对象，初步是实现了通过链表的引用，这种链式思路jQuery的异步deferred中的then方法，还有日本的cho45的jsderferre中都有用到。这个实现上还有一个最关键的问题，我们怎么动态插入数据到执行的节之后？

所以我们必须 要设计一个遍历的方法，用来搜索这个node链上的数据，然后找出这个对应的数据把新的节插入到当前的链中，并改写位置记录

1
2
3
4
5
6
7
8
9
10
//在链表中找到对应的节
var findNode = function createFindNode(currNode) {
     return function (key){
         //循环找到执行的节，如果没有返回本身
         while (currNode.data != key) {
             currNode = currNode.next;
         }
         return currNode;              
     }
}(headNode);

这就是一个查找当前节的一个方法，通过传递原始的头部headNode节去一直往下查找next，直到找到对应的节信息

这里是用curry方法实现的

那么插入节的的时候，针对链表地址的换算关系这是这样

a-b-c-d的链表中，如果要在c(c.next->d)后面插入一个f

a-b-c-f-d ,那么c,next->f , f.next-d

通过insert方法增加节

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
//创建节
function createNode(data) {
     this .data = data;
     this .next = null ;
}
//初始化头部节
//从headNode开始形成一条链条
//通过next衔接
var headNode = new createNode( "head" );
 
//在链表中找到对应的节
var findNode = function createFindNode(currNode) {
     return function (key){
         //循环找到执行的节，如果没有返回本身
         while (currNode.data != key) {
             currNode = currNode.next;
         }
         return currNode;               
     }
}(headNode);
 
//插入一个新节
this .insert = function (data, key) {
     //创建一个新节
     var newNode = new createNode(data);
     //在链条中找到对应的数据节
     //然后把新加入的挂进去
     var current = findNode(key);
     //插入新的接，更改引用关系
     //1:a-b-c-d
     //2:a-b-n-c-d
     newNode.next = current.next;
     current.next = newNode;
};

首先分离出createNode节的构建，在初始化的时候先创建一个头部节对象用来做节开头的初始化对象

在insert增加节方法中，通过对headNode链的一个查找，找到对应的节，把新的节给加后之后，最后就是修改一下链的关系

如何从链表中删除一个节点？

由于链表的特殊性，我们a->b->c->d  ，如果要删除c那么就必须修改b.next->c为 b.next->d，所以找到前一个节修改其链表next地址，这个有点像dom操作中removeChild找到其父节点调用移除子节点

同样的我们也在remove方法的设计中，需要设计一个遍历往上回溯一个父节点即可

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
//找到前一个节
var findPrevious = function (currNode) {
     return function (key){
         while (!(currNode.next == null ) &&
             (currNode.next.data != key)) {
             currNode = currNode.next;
         }
         return currNode;           
     }
}(headNode);
 
//插入方法
this .remove = function (key) {
     var prevNode = findPrevious(key);
     if (!(prevNode.next == null )) {
         //修改链表关系
         prevNode.next = prevNode.next.next;
     }
};

测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
<!doctype html><button id= "test1" >插入多条数据</button>
<button id= "test2" >删除Russellville数据</button><div id= "listshow" ></div><script type= "text/javascript" >
     //////////
     //创建链表 //
     //////////
     function createLinkList() {
 
         //创建节
         function createNode(data) {
             this .data = data;
             this .next = null ;
         }
 
         //初始化头部节
         //从headNode开始形成一条链条
         //通过next衔接
         var headNode = new createNode( "head" );
 
         //在链表中找到对应的节
         var findNode = function createFindNode(currNode) {
             return function (key) {
                 //循环找到执行的节，如果没有返回本身
                 while (currNode.data != key) {
                     currNode = currNode.next;
                 }
                 return currNode;
             }
         }(headNode);
 
         //找到前一个节
         var findPrevious = function (currNode) {
             return function (key) {
                 while (!(currNode.next == null ) &&
                     (currNode.next.data != key)) {
                     currNode = currNode.next;
                 }
                 return currNode;
             }
         }(headNode);
 
         //插入一个新节
         this .insert = function (data, key) {
             //创建一个新节
             var newNode = new createNode(data);
             //在链条中找到对应的数据节
             //然后把新加入的挂进去
             var current = findNode(key);
             //插入新的接，更改引用关系
             //1:a-b-c-d
             //2:a-b-n-c-d
             newNode.next = current.next;
             current.next = newNode;
         };
 
         //插入方法
         this .remove = function (key) {
             var prevNode = findPrevious(key);
             if (!(prevNode.next == null )) {
                 //修改链表关系
                 prevNode.next = prevNode.next.next;
             }
         };
 
         this .display = function (fn) {
             var currNode = headNode;
             while (!(currNode.next == null )) {
                 currNode = currNode.next;
                 fn(currNode.data)
             }
         };
 
     }
 
     var cities = new createLinkList();
 
     function create() {
         var text = '' ;
         cities.display( function (data) {
             text += '-' + data;
         });
         var div = document.createElement( 'div' )
         div.innerHTML = text;
         document.getElementById( "listshow" ).appendChild(div)
     }
 
     document.getElementById( "test1" ).onclick = function () {
         cities.insert( "Conway" , "head" );
         cities.insert( "Russellville" , "Conway" );
         cities.insert( "Carlisle" , "Russellville" );
         cities.insert( "Alma" , "Carlisle" );
         create();
     }
 
     document.getElementById( "test2" ).onclick = function () {
         cities.remove( "Russellville" );
         create()
     }
 
</script>

双链表

原理跟单链表是一样的，无非就是给每一个节增加一个前链表的指针

增加节

1
2
3
4
5
6
7
8
9
10
11
12
//插入一个新节
this .insert = function (data, key) {
     //创建一个新节
     var newNode = new createNode(data);
     //在链条中找到对应的数据节
     //然后把新加入的挂进去
     var current = findNode(headNode,key);
     //插入新的接，更改引用关系
     newNode.next     = current.next;
     newNode.previous = current
     current.next     = newNode;
};

删除节

1
2
3
4
5
6
7
8
9
this .remove = function (key) {
     var currNode = findNode(headNode,key);
     if (!(currNode.next == null )) {
         currNode.previous.next = currNode.next;
         currNode.next.previous = currNode.previous;
         currNode.next          = null ;
         currNode.previous      = null ;
     }
};

在删除操作中有一个明显的优化：不需要找到父节了，因为双链表的双向引用所以效率比单链要高

测试代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
<!doctype html><button id= "test1" >插入多条数据</button>
<button id= "test2" >删除Russellville数据</button><div id= "listshow" ></div><script type= "text/javascript" >
 
     //////////
     //创建链表 //
     //////////
     function createLinkList() {
 
         //创建节
         function createNode(data) {
             this .data = data;
             this .next = null ;
             this .previous = null
         }
 
         //初始化头部节
         //从headNode开始形成一条链条
         //通过next衔接
         var headNode = new createNode( "head" );
 
         //在链表中找到对应的数据
         var findNode = function (currNode, key) {
             //循环找到执行的节，如果没有返回本身
             while (currNode.data != key) {
                 currNode = currNode.next;
             }
             return currNode;
         }
 
         //插入一个新节
         this .insert = function (data, key) {
             //创建一个新节
             var newNode = new createNode(data);
             //在链条中找到对应的数据节
             //然后把新加入的挂进去
             var current = findNode(headNode,key);
             //插入新的接，更改引用关系
             newNode.next     = current.next;
             newNode.previous = current
             current.next     = newNode;
         };
 
         this .remove = function (key) {
             var currNode = findNode(headNode,key);
             if (!(currNode.next == null )) {
                 currNode.previous.next = currNode.next;
                 currNode.next.previous = currNode.previous;
                 currNode.next          = null ;
                 currNode.previous      = null ;
             }
         };
 
         this .display = function (fn) {
             var currNode = headNode;
             while (!(currNode.next == null )) {
                 currNode = currNode.next;
                 fn(currNode.data)
             }
         };
 
     }
 
     var cities = new createLinkList();
 
     function create() {
         var text = '' ;
         cities.display( function (data) {
             text += '-' + data;
         });
         var div = document.createElement( 'div' )
         div.innerHTML = text;
         document.getElementById( "listshow" ).appendChild(div)
     }
 
     document.getElementById( "test1" ).onclick = function () {
         cities.insert( "Conway" , "head" );
         cities.insert( "Russellville" , "Conway" );
         cities.insert( "Carlisle" , "Russellville" );
         cities.insert( "Alma" , "Carlisle" );
         create();
     }
 
     document.getElementById( "test2" ).onclick = function () {
         cities.remove( "Russellville" );
         create()
     }
 
</script>

git代码下载：https://github.com/JsAaron/data_structure.git

js实现链表
03-23
javascript实现链表的功能。可以解决相应问题。
数据结构与算法JavaScript (三) 链表
baoaoba9317的博客
01-08 164
我们可以看到在javascript概念中的队列与栈都是一种特殊的线性表的结构，也是一种比较简单的基于数组的顺序存储结构。由于javascript的解释器针对数组都做了直接的优化，不会存在在很多编程语言中数组固定长度的问题(当数组填满后再添加就比较困难了，包括添加删除，都是需要把数组中所有的元素全部都变换位置的，javascript的的数组确实直接给优化好了，如push,po...
JS数据结构学习：链表
weixin_34413065的博客
02-23 130
在存储多个元素时，我们最常用的数据结构可能是数组，究其原因可能是数组访问方便，可以直接通过[]访问，但是数组也存在一定的缺点，数组的大小是固定，数组在执行插入或者删除的时候成本很高。链表存储的是有序的元素集合，和数组不同的是，链表中的元素在内存并不是连续放置，每个元素由一个存储元素本身的节点和一个指向下一个元素的引用组成，结构如下图所示：...
js-学习链表
追梦的女孩博客
11-15 306
链表和数组一样，可以用于存储一系列连续的元素。链表中的元素在内存中不必是连续的空间。链表的每一个元素有一个由一个存储元素本身的节点和一个指向下一个元素的引用组成(指针和连接)。
JavaScript----- 链表学习
wanghongpu9305的博客
11-28 164
1、数组的缺点 在其他语言中 数组的长度是固定的，所以数组被填满后在添加新的元素是非常困难的。在数组中添加和删除也是很麻烦的，需要把其他元素向前或者向后平移，以反映数组刚刚进行了添加或删除操作。 在JavaScript 中数组的主要问题是，它们被实现成了对象，与其他语言(比如 C++ 和 Java) 的数组相比，效率很低 2、 定义链表 链表是由一组节点组成的集合,每个节点都使用一个对象的引用指向它的后继。指向另一 个节点的引用叫做链。 ...
JavaScript中数据结构与算法(三)：链表
12-02
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和数据结构的实现。相对于数组，链表在处理动态数据变化时具有显著优势。在JavaScript中，由于数组的优化，如快速的push、pop、shift和unshift等操作...
前端学数据结构与算法（三）：链表为什么能和数组相提并论？实现数组bettle下 数组和链表.pdf
04-18
在前端开发中，理解和掌握数据结构与算法是提升编程能力的关键。本篇主要探讨了链表这一重要的数据结构，分析了其与数组的区别，并通过实际的JavaScript代码实现了一个链表类，展示了链表的增、删、查操作。以下是...
JS数据结构与算法.pdf
11-01
JS 数据结构与算法.pdf 本书主要介绍了 JavaScript 语言的基础知识，包括数据结构和算法。以下是该书的详细知识点： 一、JavaScript 基础知识 * 变量和数据类型 * 运算符和控制结构 * 函数和对象 * 数组和字符串 ...
JavaScript数据结构与算法：链表详解
"本文主要探讨了JavaScript中的链表数据结构，包括单链表、静态链表、循环链表和双向链表。文章通过代码实例详细解释了如何在JavaScript中实现链表的增加和删除操作，并对比了链表与数组的区别。" 在JavaScript中，...
js数据结构学习--链表
qq_44998582的博客
11-20 256
4.链表 内存空间不连续，能实现灵活的内存动态管理 链表创建时不需确定大小，大小可随需要而扩充 在插入和删除数据时，时间复杂度可达到O(1) 4.1链表的火车结构 链表类似于火车，有一个火车头，火车头连接一个节点（车厢），节点（车厢）内有乘客（数据），并且此节点连接下一节点，以此类推 4.2链表的常见操作 append(element):向列表尾部添加一个新的项 insert(position,element):向列表的特定位置插入一个新的项 ge
js链表算法
共同学习，心怀感激。
02-19 192
js链表 // 链表 function Node(value) { this.value = value; this.next = null } var node1 = new Node(1) var node2 = new Node(2) var node3 = new Node(3) var node4 = new Node(4) var node5 = new Node(5) node1.next = node2 node2.next = node3 node3.next
用js实现链表
zdhui_fly的博客
07-19 941
链表骨架 function LinkedList(){       var Node = function(element){           this.element = element;           this.next = null;        }       var length = 0;       var head = null;       var    tail...
js链表
qq_18304615的博客
04-04 422
function LinkedList(){ var Node = function(element){ this.element = element; this.next = null; } var length = 0; var head = null; //在链表尾部增加元素 this.append = function(element){ var node = ne...
JS 链表
qq_60754128的博客
04-23 191
【代码】JS 链表。
js的链表
jintingbo的专栏
09-12 301
实验来源：https://blog.youkuaiyun.com/u010565037/article/details/65634325 一、html文件:Link.html &lt;!DOCTYPE html&gt; &lt;html&gt;     &lt;head&gt;         &lt;meta charset="utf-8"&gt;         &lt;title&gt;&lt;/t..
js(JavaScript)数据结构之链表（Linked List）
最新发布
星辰迷上大海的博客
01-12 2409
链表（Linked List）是一种常见的数据结构，它由一系列节点组成，每个节点都包含了数据和指向下一个节点的指针。
用Javascript实现链表
qq_39833020的博客
10-19 262
github主页：https://github.com/A15162252289 什么是链表 链表存储有序的元素集合，但不同于数组，链表中的元素在内存中不是连续放置的。每个元素由一个存储元素本身的节点和指向下一个元素的引用组成。 下图为单向链表的示意图 相对于传统数组链表的好处在于，添加和删除元素的时候不需要移动其他元素。然而，链表需要使用指针，因此实现链表时应该额外注意。数组的另一个细节是可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值