【算法】双链表

最新推荐文章于 2026-01-05 22:36:07 发布
原创 最新推荐文章于 2026-01-05 22:36:07 发布 · 74 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法 #java #前端

该文章展示了一个JavaScript类，用于创建和操作双链表。类包含方法如添加元素、在指定位置插入元素、删除元素、向前和向后遍历链表、获取元素、检查元素存在性以及获取链表的长度等。 
<!DOCTYPE html>
<html lang="en">
    <head>
        <meta charset="UTF-8" />
        <meta http-equiv="X-UA-Compatible" content="IE=edge" />
        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
        <title>Document</title>
    </head>
    <body>
        <script>
            class DoubleLinkedList {
                head = null;
                tail = null;
                length = 0;
                static Node = class Node {
                    constructor(key) {
                        this.key = key;
                        this.next = null;
                        this.prev = null;
                    }
                };
                append(key) {
                    let newNode = new DoubleLinkedList.Node(key);
                    if (this.length === 0) {
                        this.head = newNode;
                        this.tail = newNode;
                    } else {
                        this.tail.next = newNode;
                        newNode.prev = this.tail;
                        this.tail = newNode;
                    }
                    this.length += 1;
                    return newNode.key;
                }
                insert(position, key) {
                    if (position < 0 || position > this.length) {
                        return -1;
                    }

                    let newNode = new DoubleLinkedList.Node(key);
                    if (this.length === 0) {
                        this.head = newNode;
                        this.tail = newNode;
                    } else {
                        if (position === 0) {
                            this.head.prev = newNode;
                            newNode.next = this.head;
                            this.head = newNode;
                        } else if (position === this.length - 1) {
                            this.tail.next = newNode;
                            newNode.prev = this.tail;
                            this.tail = newNode;
                        } else {
                            let len = Math.floor(this.length / 2);
                            if (len > position) {
                                let current = this.head;
                                let index = 0;
                                while (index++ < position) {
                                    current = current.next;
                                }
                                newNode.prev = current.prev;
                                newNode.next = current;
                                current.prev.next = newNode;
                                current.prev = newNode;
                            } else {
                                let current = this.tail;
                                let index = this.length - 1;
                                while (index-- > position) {
                                    current = current.prev;
                                }
                                newNode.prev = current.prev;
                                newNode.next = current;
                                current.prev.next = newNode;
                                current.prev = newNode;
                            }
                        }
                    }

                    this.length += 1;
                    return newNode.key;
                }
                forwardString() {
                    let current = this.head;
                    let str = "";
                    while (current) {
                        str += current.key + "=>";
                        current = current.next;
                    }
                    return str;
                }
                backwardString() {
                    let current = this.tail;
                    let str = "";
                    while (current) {
                        str += current.key + "=>";
                        current = current.prev;
                    }
                    return str;
                }
                indexOf(key) {
                    let current = this.head;
                    let index = 0;
                    while (current) {
                        if (current.key === key) {
                            return index;
                        }
                        index += 1;
                        current = current.next;
                    }
                    return -1;
                }
                get(position) {
                    if (position < 0 || position > this.length - 1) {
                        return -1;
                    }
                    if (position === 0) {
                        return this.head.key;
                    }
                    if (position === this.length - 1) {
                        return this.tail.key;
                    }
                    let index = 0;
                    let current = null;
                    let len = Math.floor(this.length / 2);
                    if (len > position) {
                        current = this.head;
                        while (index++ < position) {
                            current = current.next;
                        }
                    } else {
                        current = this.tail;
                        index = this.length - 1;
                        while (index-- > position) {
                            current = current.prev;
                        }
                    }
                    return current.key;
                }
                has(key) {
                    let current = this.head;
                    while (current) {
                        if (current.key === key) {
                            return true;
                        }
                        current = current.next;
                    }
                    return false;
                }
                remove(key) {
                    let position = this.indexOf(key)
                    return this.removeAt(position)
                }
                removeAt(position) {
                    if (position < 0 || position > this.length - 1) {
                        return -1;
                    }
                    let current = this.head;
                    let index = 0;
                    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 {
                            while (index++ < position) {
                                current = current.next;
                            }
                            current.prev.next = current.next;
                            current.next.prev = current.prev
                        }
                    }
                    this.length -= 1
                    return current.key;
                }
                getHead() {
                    return this.head;
                }
                getTail() {
                    return this.tail;
                }
                size() {
                    return this.length;
                }
                isEmpty() {
                    return this.length === 0 ? true : false;
                }
                toString() {
                    return this.forwardString();
                }
            }
            let d = new DoubleLinkedList();
            d.append("AAA");
            d.append("BBB");
            d.append("CCC");
            d.insert(0, "AAA");
            d.insert(0, "BBB");
            d.insert(1, "CCC");
            d.insert(3, "DDD");
            // console.log("get", d.get(0));
            // console.log("get", d.get(6));
            // console.log("get", d.get(3));
            // console.log(d.indexOf("AAA"));
            // console.log("length", d.size());
            // console.log("isempty", d.isEmpty());
            // console.log("has", d.has("AAA"));
            // console.log("has", d.has("0"));
            // console.log("has", d.has("DDD"));
            // console.log("has", d.has("BBB"));
            console.log("removeAt", d.removeAt(0));
            console.log("removeAt", d.removeAt(1));
            console.log("removeAt", d.removeAt(4));
            console.log("removeAt", d.removeAt(3));
            console.log("removeAt", d.removeAt(2));
            console.log("length", d.size());
            console.log("remove ", d.remove('DDD'));
            console.log(d.toString());
            console.log(d);
        </script>
    </body>
</html>
MysTic_
关注
双向链表的反转算法
qq_43750656的博客
05-10 3023
在双向链表中使用尾插法速度是非常快的，达到了O(1)级别，因为链表内部维护了一个tail属性，指向了最后一个元素，那么在插入的时候直接将tail指向的尾节点重新指向新插入的节点，新插入的节点再和原尾节点指向的节点做双向关联即可． 算法一 public void reverse(){ TowWayList<T> list = new TowWayList<>(); for(int i = length - 1;i >= 0;i++){ list.add(getNode
算法设计题——双向链表
WYMei_529
12-02 1557
设有一个双向链表，每个结点中除了有prior、data和next三个域外，还有一个访问频度域freq，在链表被启用前，所有结点的freq域的值均为零。每当在双链表上进行Locate(L,X)运算时，令元素值为x的结点中的freq的值加1，并使此链表中结点保持访问频度递减的顺序排列。试设计实现Locate(L,X)运算的算法。 双向链表的插入操作和删除操作具体代码实现。
双链表实现LRU算法
恋恋风辰的技术博客
12-30 1211
链表 所谓链表就是一个节点指向另一个节点的数据结构，像一条链子把每个节点连接起来。 如果一个节点既指向了后面的节点，也指向了前面的节点，这些节点就构成了双向链表。 我们先定义这个节点结构 class NodeLRU { public: NodeLRU(int v) : val(v), prev(nullptr), next(nullptr) {} int val; NodeLRU *prev; NodeLRU *next; }; val为节点的数据域表示节点存储的数值 p
数据结构与算法 双链表的转置
XLB
03-29 369
1、实现双链表转置的算法，按个人理解是，将原双链表的头结点与后面的结点分开，将后面的结点逐个用头插的方法插到只含头结点的双链表中。2、第二种方法，将头结点与后面结点断开，找到后面结点的最后一个结点，使用尾插法插入到只含头结点的双链表中也能实现链表的转置（缺点：严重增加算法的复杂度，增加cpu的负担，算法的速度变慢）
数据结构与算法——链表（双向链表，顺序表与链表的比较)
weixin_68773927的博客
10-25 1249
在双向链表中有此操作（如：ListLength，GetElem等）因此涉及一个方向的指针。故它们的算法与线性表相同，但在插入，删除时则需要同时修改两个方向上的指针，两者的操作的时间复杂度均为T(n)=O(n)双向链表：在单链表的每个结点里在增加一个指向其直接前驱的指针域prior 这样链表就形成了有两个方向不同的链。p的后继结点的前驱结点为自身。即：p的前驱结点的后继结点为它自身。
Java数据结构与算法——双向链表
贝尔摩德苦艾酒
03-11 6409
Java数据结构与算法——双向链表
前端必会算法——双向链表
qq_63664183的博客
04-04 504
双向链表 双向链表就是我不但可以指向下一个,也可以指向上一个 代码演示： function Node(value) { this.value; this.next = null; // 指向后面 this.prev = 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
【算法】【优选算法】链表
yj20040627的博客
12-18 4335
链表题目解题方法
双向链表-算法2.13-2.14
m0_65185254的博客
10-07 2395
数据结构作业
双链表各种基本运算的算法
Hey3399的博客
05-04 5323
初始化双链表 //初始化线性表 void InitList(DLinkNode *&L) { //创建头结点 L=(DLinkNode *)malloc(sizeof(DLinkNode)); L->next=L->prior=NULL; } 头插法建立双链表 //采用头插法建立双链表 void CreateListF(DLinkNode *&L,ElemType a[],int n) { DLink...
C++经典算法 双向链表
12-13
### C++经典算法：双向链表 在计算机科学领域中，数据结构是极其重要的基础知识之一。其中链表作为一种常见的线性表实现方式，在各种应用场景中都有广泛的应用。本篇文章将根据给定的代码片段深入探讨双向链表的...
数据结构的双链表算法
09-27
双链表是数据结构中的一种重要类型，它在计算机科学中有着广泛的应用。与单链表相比，双链表的特点在于每个...通过理解和熟练掌握双链表及其算法，对于提升编程能力，尤其是解决复杂数据处理问题的能力，具有重要意义。
双向链表及其基本操作
10-29
C语言，实现双向链表以及其基本操作，基本操作：链表初始化、创建、查询、删除、释放，查询和删除均有两种方式，一种是按照值，另一种是按照结点的序号。
【Java数据结构与算法】双向链表
12-21
在计算机科学中，数据结构是组织、存储和处理数据的方式，而算法是解决问题或执行特定任务的步骤。...熟练掌握双向链表及其操作对于理解和优化算法至关重要，因为它能够提高数据处理的效率，降低复杂度。
Java算法实例-双向链表操作
08-22
双向链表因其特性，在很多算法问题中都有所应用，如LRU缓存淘汰策略、实现堆栈或队列等。熟练掌握双向链表的使用，对于提升编程能力非常有帮助。在学习过程中，可以通过编写和运行上述代码，加深对双向链表的理解。...
01_树的 dfs 序
2403_88695928的博客
12-31 1171
本文介绍了算法竞赛中树的DFS序（dfn序）这一重要概念。文章首先讲解了基于先序遍历的dfn序定义及其代码实现，通过深度优先遍历为树节点编号。随后阐述了dfn序的三个关键性质：子树dfn序的连续性、祖先节点编号小于子孙节点、子树编号区间计算公式。文章重点展示了dfn序的两个应用：高效判断节点是否在子树中（时间复杂度从O(nq)优化到O(n+q)），以及将树上问题转化为序列问题以便使用线段树等数据结构处理。最后提供了两道模板题（DFS序1和DFS序2）的完整代码实现，演示了如何利用树状数组和线段树来维护dfn
【算法基础篇】（四十）数论之算术基本定理深度剖析：从唯一分解到阶乘分解
2301_79248256的博客
12-30 1208
本文围绕算术基本定理展开，详解其 “大于 1 的自然数可唯一分解为质数乘积” 的核心内涵及在算法竞赛中的应用。先介绍质因数分解的试除法实现与优化技巧，包括枚举范围优化、溢出防护，以及结合线性筛的高效分解方法；再聚焦阶乘分解这一高频考点，拆解核心公式与两种解法（试除法累加、线性筛 + 公式），并通过洛谷经典例题演示实战；最后延伸讲解约数个数、约数和、gcd/lcm 等衍生应用，搭配避坑指南，助力快速掌握数论基础核心技能。
leetcode算法（144.二叉树的前序遍历）
最新发布
m0_61706299的博客
01-05 344
leetcode算法（144.二叉树的前序遍历）
基于扩展的增量流形学习算法IMM-ISOMAP的方案
aini_lovee的博客
12-30 392
基于 扩展的增量流形学习算法IMM-ISOMAP 的方案，结合 动态邻域更新 和 切空间扩展 策略，解决传统ISOMAP在增量数据和多流形场景下的局限性
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值