JavaScript算法——链表篇

最新推荐文章于 2024-01-12 07:15:00 发布
最新推荐文章于 2024-01-12 07:15:00 发布
阅读量302 收藏 1
点赞数
分类专栏： 算法 文章标签： 链表 算法 javascript 前端 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jackson_Mseven/article/details/131015857
版权

链表理论基础

单链表

链表是一种通过指针串联在一起的线性结构，每一个节点由两部分组成，一个是数据域一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向 null（空指针）。

链表的入口节点称为链表的头结点也就是 head。

在这里插入图片描述

双链表

单链表中的指针域只能指向节点的下一个节点。

双链表：每一个节点有两个指针域，一个指向下一个节点，一个指向上一个节点。

双链表既可以向前查询也可以向后查询。

在这里插入图片描述

循环链表

循环链表：就是链表收尾相连。

循环链表可以用来解决约瑟夫环问题。

在这里插入图片描述

链表的存储方式

链表是通过指针域的指针链接在内存中各个节点，所以，链表中的节点不是连续分布的，而是散乱分布在内存中的某地址上，分配机制取决于操作系统的内存管理。

在这里插入图片描述

链表的定义

function ListNode(val, next) {
    this.val = (val === undefined ? 0 : val);
    this.next = (next === undefined ? null : next);
}

删除节点

在这里插入图片描述

如图所示：只需要将 C 节点的指针域指向 E 节点即可。

添加节点

在这里插入图片描述

如图所示：只需要将 C 节点的指针域指向 F 节点，F 节点的指针域指向 D 节点即可。

性能分析

查询（时间复杂度）插入/删除（时间复杂度）使用场景
数组O(1)O(n)数据量固定，频繁查询，较少增删
链表O(n)O(1)数据量不固定，频繁增删，较少查询

移除链表元素

移除链表元素

/*
	思路：创建虚拟头结点，从头开始与链表元素一一比对，直到找到对应节点
*/
var removeElements = function(head, val) {
	// 创建一个虚拟头节点
    const ret = new ListNode(0, head);
    let cur = ret;
    while(cur.next) {
        // 找到指定节点
        if(cur.next.val === val) {
            // 让指针指向下一个节点
            cur.next = cur.next.next;
            continue;
        }
        // 如果不是当前节点，则继续找下一个节点
        cur = cur.next;
    }
    return ret.next;
};

设计链表

设计链表

/*
	链表节点
*/
function LinkNode(val, next) {
    this.val = (val === undefined ? 0 : val); // 节点值
    this.next = (next === undefined ? null : next); // 节点的下一个节点
}

/*
	创建空链表
*/
var MyLinkedList = function() {
    this._size = 0; // 链表长度
    this._tail = null; // 头结点
    this._head = null; // 尾结点
};

/*
	获取目标结点
*/
MyLinkedList.prototype.getNode = function(index) {
    // 如果索引越界
    if(index < 0 || index >= this._size) return null;
    // 创建虚拟头节点
    let cur = new LinkNode(0, this._head);
    // 从头开始迭代，直到 index 减为0（找到了）
    while(index-- >= 0) {
        cur = cur.next;
    }
    return cur;
}

/*
	获取目标结点的值
*/
MyLinkedList.prototype.get = function(index) {
    // 如果索引越界
    if(index < 0 || index >= this._size) return -1;
    // 获取当前结点
    return this.getNode(index).val;
};

/*
	添加头结点
*/
MyLinkedList.prototype.addAtHead = function(val) {
    // 创建头结点
    const node = new LinkNode(val, this._head);
    // 把头结点设置为创建节点
    this._head = node;
    // 链表的长度+1
    this._size++;
    // 如果原链表是空链表
    if(!this._tail) {
        this._tail = node;
    }
};

/*
	添加尾结点
*/
MyLinkedList.prototype.addAtTail = function(val) {
    // 创建尾结点
    const node = new LinkNode(val, null);
    // 链表的长度+1
    this._size++;
    // 如果原链表不为空
    if(this._tail) {
        // 将原链表的尾结点的 next 指针指向 node
        this._tail.next = node;
        // 设置新的尾结点
        this._tail = node;
        return;
    }
    // 如果原链表为空
    this._tail = node;
    this._head = node;
};

/*
	添加目标结点
*/
MyLinkedList.prototype.addAtIndex = function(index, val) {
    // 索引越界
    if(index > this._size) return null;
    // 目标结点为头结点
    if(index <= 0) {
        this.addAtHead(val);
        return;
    }
    // 目标结点为尾结点的下一个结点（即添加一个尾结点）
    if(index == this._size) {
        this.addAtTail(val);
        return;
    }
    // 获取目标结点的上一个结点
    const node = this.getNode(index - 1);
    // 将 node 结点的 next 指针指向新结点，新结点的 next 指针指向目标结点
    node.next = new LinkNode(val, node.next);
    this._size++;
};

/*
	删除目标结点
*/
MyLinkedList.prototype.deleteAtIndex = function(index) {
    // 索引越界
    if(index < 0 || index >= this._size) return;
    // 如果是目标结点是头结点
    if(index == 0) {
        // 设置头结点指向头结点的下一个结点
        this._head = this._head.next;
        // 如果这个结点同时也是尾结点（即：链表只有一个结点）
        if(index == this._size - 1) {
            this._tail = this._head;
        }
        this._size--;
        return;
    }
    // 获取目标结点的下一个结点
    const node = this.getNode(index - 1);
    // 设置 node 结点的 next 指针指向目标结点的下一个结点
    node.next = node.next.next;
    // 如果目标结点是尾结点
    if(index == this._size - 1) {
        this._tail = node;
    }
    this._size--;
};

反转链表

反转链表

/*
	双指针
	思路：从头节点开始遍历，修改节点的指针指向前一个节点
*/
var reverseList = function(head) {
    // 如果是空链表或链表只有一个节点
    if(!head || !head.next) return head;
    let pre = null, cur = head;
    while(cur) {
        [cur.next, pre, cur] = [pre, cur, cur.next];
    }
    return pre;
};

/*
	递归
	思路：从头结点开始递归，修改节点的指针指向前一个节点
*/
var reverseList = function(head) {
    var reverse = function(pre, head) {
        // 如果链表为空链表
        if(!head) return pre;
        // temp：暂存节点
        const temp = head.next;
        // 修改节点的指针指向前一个节点
        head.next = pre;
        // 左指针改为当前结点
        pre = head
        return reverse(pre, temp);
    }
    return reverse(null, head);
};

/*
	递归
	思路：从尾节点开始递归，修改节点的指针指向前一个结点
*/
var reverseList = function(head) {
    var reverse = function(head) {
        // 节点为空 或 节点为链表最后一个结点
        if(!head || !head.next) return head;
        // 从后往前翻
        // next：head的下一个结点
        const next = reverse(head.next);
        [head.next, next.next] = [next.next, head];
        return head;
    }
    let cur = head;
    // 找到尾节点的前一个结点
    while(cur && cur.next) {
        cur = cur.next;
    }
    reverse(head);
    return cur;
};

两两交换链表中的节点

两两交换链表中的节点

/*
	思路：创建虚拟头节点，从头节点开始遍历，依次两两交换节点
*/
var swapPairs = function(head) {
    // ret：虚拟头节点
    // temp：临时节点
    let ret = new ListNode(0, head), temp = ret;
    // 当 临时结点的下一个节点 和 下下一个节点 都存在时
    while(temp.next && temp.next.next) {
        // cur：要交换的右节点
        // pre：要交换的左节点
        let cur = temp.next.next, pre = temp.next;
        // 交换节点
        [pre.next, cur.next, temp.next] = [cur.next, pre, cur];
        // 继续交换后续节点
        temp = pre;
    }
    return ret.next;
};

删除链表的倒数第N个节点

删除链表的倒数第N个节点

/*
	双指针
	思路：创建虚拟头结点，要找到倒数第n个节点，只需要找到正数第n个节点（右指针），然后从头结点（左指针）开始依次向右移动，当右指针移动到尾节点的下一个节点（null）时，此时的左指针就是倒数第n个节点
*/
var removeNthFromEnd = function(head, n) {
    // node：虚拟头节点
    let node = new ListNode(0, head);
    // pre：左指针
    // cur：右指针
    let pre = node, cur = head;
    // 找到第n个节点（cur）
    while(n > 0) {
        cur = cur.next;
        n--;
    }
    // 找到要删除的节点（pre）
    while(cur != null) {
        pre = pre.next;
        cur = cur.next;
    }
    // 删除节点
    pre.next = pre.next.next;
    return node.next;
};

链表相交

链表相交

/*
	思路：因为链表相交部分的长度是相同的，所以先求出链表的长度差，找到更长的链表的起始比较节点，将该节点与另一链表头节点进行比较，如果不同则继续比较后续节点，直到找到相同的节点
*/
var getIntersectionNode = function(headA, headB) {
    /*
    	获取链表长度
    	head：头结点
    */
    var getLength = function(head) {
        // 定义长度变量
        let len = 0;
        // 创建判断长度的节点
        let cur = head;
        // 求出链表的长度
        while(cur) {
            cur = cur.next;
            len++;
        }
        return len;
    }
    // lenA：链表A的长度
    // lenB：链表B的长度
    let lenA = getLength(headA), lenB = getLength(headB);
    // curA：链表A中的相交节点
    // curB：链表B中的相交节点
    let curA = headA, curB = headB;
    // 链表B更长
    while(lenA < lenB) {
        curB = curB.next;
        lenB--;
    }
    // 链表A更长
    while(lenA > lenB) {
        curA = curA.next;
        lenA--;
    }
    // 遍历 curA 和 curB，若相同则返回
    while(curA && curA !== curB) {
        curA = curA.next;
        curB = curB.next;
    }
    return curA;
};

环形链表

环形链表II

/*
	思路：如下图所示，慢指针的步数为(x + y)，快指针的步数为(x + n(y + z) + y)，则有 2(x + y) = x + n(y + z) + y => x = (n - 1)(y + z) + z，即快指针从相遇处出发，慢指针从头节点出发，它们一定会在环的入口处相遇
*/
var detectCycle = function(head) {
    // 空链表 或 单节点链表
    if(!head || !head.next) return null;
    // fast：快指针
    // slow：慢指针
    let fast = head.next.next, slow = head.next;
    // 当快、慢指针没有相遇 且 快指针不为null 且 快指针的下一个节点不为null
    while(fast !== slow && fast && fast.next) {
        // 快指针每次走两个节点
        fast = fast.next.next;
        // 慢指针每次走一个节点
        slow = slow.next;
    }
    // 不存在环
    if(!fast || !fast.next) return null;
    // 快、慢指针相遇了，现在要找到环的入口
    slow = head;
    // 遍历快、慢指针，直到快、慢指针再次相遇的节点即为入口节点
    while(slow != fast) {
        slow = slow.next;
        fast = fast.next;
    }
    return slow;
};

在这里插入图片描述

注意：x = (n - 1)(y + z) + z，即只要将慢指针从头结点开始、快指针从相遇节点开始遍历，一定会在入口节点再次相遇

总结

在这里插入图片描述

Jackson Mseven
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
数据结构——链表 C语言
03-16
设单链表A和B均非递减有序，试设计算法，将A和B合并成非递增有序的单链表C，并要求利用原表A和B的结点空间构造表C。
javascript：数据结构——链表
weixin_42924369的博客
08-23 332
什么是链表？ 链表是有序的列表， 链表是以节点的方式来存储，是链式存储。 每个节点包含item域，next指针（指向下一个节点），即就是链表中的每一个元素都带有下一个元素的位置(next) 链表的节点不一定连续存储，是离散的状态 双向链表 每个链表不仅带有next这一项，还有previous这一项 双向循环列表 链表操作 1、添加（指定添加元素 尾部添加元素） 2、移除（指定位置(下标)移除元素 移除元素元素） 链表尾添加元素 1、如果链表为空的情况下，给链表尾添加元素，同时要把链表头
JS 数据结构：链表
weixin_46015333的博客
11-24 4121
本文介绍了什么是链表以及他的优缺点，并分别介绍了单链表、双向链表和循环链表之间的细微差别和各自的特点，一些有明显差异的操作都分别给出了图和代码，更易于理解和实践。
JavaScript【链表】
m0_63077733的博客
03-21 1578
双向链表：既可以从头遍历到尾，又可以从尾遍历到头。也就是说链表连接的过程是双向的，它的实现原理是：一个节点既有向前连接的引用，也有一个向后连接的引用。每次在插入或删除某个节点时，都需要处理四个引用，而不是两个，实现起来会困难些；相对于单向链表，所占内存空间更大一些；但是，相对于双向链表的便利性而言，这些缺点微不足道。双向链表不仅有head指针指向第一个节点，而且有tail指针指向最后一个节点；item储存数据、prev指向前一个节点、next指向后一个节点；
javascript链表
weixin_46224014的博客
11-06 8482
1.什么是链表？ 链表是多个元素组成的列表 元素存储不连续，用next指针连接到一起 JS中没有链表，但是可以用Object模拟链表 2.常用操作 新增节点 append 删除节点 remove 插入节点 insert 输出节点 索引 indexOf ...
在JavaScript中的数据结构（链表）
肥晨开发的学习之路
06-16 1172
链表是多个元素组成的列表，元素存储不连续，用next指针连接到一起，JS中没有链表，但是可以用Object模拟链表。
JS链表系列
qq_48701993的博客
07-24 1725
什么是链表，链表是一种通过指针串联在一起的线性结构，每一个节由两部分组成，一个是数据域，一个是指针域（存放指向下一个节点的指针），最后一个节点的指针域指向null（空指针的意思）链接的入口节点称为链表头节点也就是head。.........
Python实现数据结构与算法——反转链表
12-21
题目描述： 反转一个单链表。 示例: 输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULL 进阶: 你可以迭代或递归地反转链表。你能否用两种方法解决这道...这个过程相当于，在遍历链表的过程中，每一个当前节点的nex
JavaScript数据结构与算法之链表
10-22
链表就是线性表中针对顺序存储结构的一种优化手段，但是在javascript语言中由于数组的特殊性（自动更新引用位置），所以我们可以采用对象的方式做链表存储的结构
C语言——链表的归并_c语言链表详解
12-21
用c语言写链表归并
数据结构与算法 —— Java 实现（链表）
01-21
数据结构与算法 —— Java 实现（链表）一、单链表1.1 链表的定义1.2 链表添加一个新的节点1.3 判断当前节点是否为最后一个节点 （isLast）1.4 删除下一节点 （removeNext）1.5 显示节点信息（show）1.6 插入一个...
js(JavaScript)数据结构之链表（Linked List）
最新发布
星辰迷上大海的博客
01-12 1024
链表（Linked List）是一种常见的数据结构，它由一系列节点组成，每个节点都包含了数据和指向下一个节点的指针。
JavaScript：链表
weixin_51249285的博客
05-04 769
JavaScript：链表（js没有链表吗，203. 移除链表元素，204. 设计链表，206. 反转链表，142.环形链表II）
js实现链表
ssjjrr的博客
02-02 920
js实现链表
JS 链表
qq_60754128的博客
04-23 120
【代码】JS 链表。
JS实现链表
Sco_jing的博客
06-18 4032
链表
算法：JS 中的链表简介
一枚不断学习的小码农一枚~
03-17 2125
链表的概念 首先我们需要知道链表的概念： 多个元素组成的列表 元素存储不连续， 用next 指针连在一起 那我们数组和链表的区别是什么呢？ 3. 数组在增加或者删除非首尾元素时往往需要移动元素 4. 链表在增删非首尾元素时不需要移动元素，只需要更改next 指针即可 JS 中的链表 js 中没有链表这个数据结构 我们可以使用 object 对象来模拟链表 模拟链表 我们使用 object 中定义 val 值与添加next 属性得到如下一个链表 遍历链表 let p = a // 声明一个指针,指
JavaScript实现双向链表
qwe02315的博客
04-13 319
双向链表：既可以从头遍历到尾，又可以从尾遍历到头。也就是说链表连接的过程是双向的，它的实现原理是：一个节点既有向前连接的引用，也有一个向后连接的引用。每次在插入或删除某个节点时，都需要处理四个引用，而不是两个，实现起来会困难些；相对于单向链表，所占内存空间更大一些；但是，相对于双向链表的便利性而言，这些缺点微不足道。双向链表不仅有head指针指向第一个节点，而且有tail指针指向最后一个节点；item储存数据、prev指向前一个节点、next指向后一个节点；
用JS实现链表 --单链表
weixin_43850639的博客
02-15 941
用JS实现单链表
哈希表设计与实现——链表法
05-10
哈希表是一种高效的数据结构，可以用来存储和查找键值对。其中，哈希函数将键映射到一个特定的桶中，每个桶中存储一组键值对。在哈希表中，如果两个键被映射到同一个桶中，就会发生碰撞。为了解决这个问题，可以使用链表法。 链表法是一种解决哈希表碰撞问题的方法。具体来说，对于哈希表中的每个桶，可以使用一个链表来存储所有映射到该桶的键值对。如果发生碰撞，只需要将新的键值对添加到链表的末尾即可。 下面是一个使用链表法实现哈希表的示例代码： ```python class Node: def __init__(self, key, value): self.key = key self.value = value self.next = None class HashTable: def __init__(self, capacity): self.capacity = capacity self.buckets = [None] * capacity def hash_function(self, key): return hash(key) % self.capacity def put(self, key, value): index = self.hash_function(key) node = self.buckets[index] while node: if node.key == key: node.value = value return node = node.next new_node = Node(key, value) new_node.next = self.buckets[index] self.buckets[index] = new_node def get(self, key): index = self.hash_function(key) node = self.buckets[index] while node: if node.key == key: return node.value node = node.next return None def remove(self, key): index = self.hash_function(key) node = self.buckets[index] prev = None while node: if node.key == key: if prev: prev.next = node.next else: self.buckets[index] = node.next return prev = node node = node.next ``` 在这个示例中，我们定义了一个Node类来表示哈希表中的每个节点，每个节点包含一个键、一个值和一个指向下一个节点的指针。我们还定义了一个HashTable类来实现哈希表，其中包含一个桶数组和一些基本的操作方法，如put、get和remove。 在put方法中，我们首先使用哈希函数计算出键的索引，然后遍历桶中的链表，查找该键是否已经存在于哈希表中。如果找到了该键，我们只需要更新其对应的值即可。否则，我们创建一个新的节点，并将其添加到链表的开头。 在get方法中，我们同样使用哈希函数计算出键的索引，然后遍历桶中的链表，查找该键的值。如果找到了该键，我们返回其对应的值。否则，返回None。 在remove方法中，我们首先使用哈希函数计算出键的索引，然后遍历桶中的链表，查找该键。如果找到了该键，我们将其从链表中删除即可。 总的来说，链表法是一种简单且常用的哈希表解决碰撞问题的方法。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Jackson Mseven

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

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

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

打赏作者

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

抵扣说明：

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

余额充值