数据结构之双向链表

最新推荐文章于 2023-08-01 17:33:40 发布
最新推荐文章于 2023-08-01 17:33:40 发布
阅读量532 收藏
点赞数
分类专栏： JavaScript 文章标签： 链表 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45641191/article/details/123511802
版权

认识双向链表

单向链表:

  • 只能从头遍历到尾或者从尾遍历到头(一般从头到尾)
  • 也就是链表相连的过程是单向的.
  • 实现的原理是上一个链表中有一个指向下一个的引用.

单向链表有一个比较明显的缺点:

  • 我们可以轻松的到达下一个节点，但是回到前一个节点是很难的.但是，在实际开发中，经常会遇到需要回到上一个节点的情况
  • 举个例子 :假设一个文本编辑用链表来存储文本.每一行用一个String对象存储在链表的一个节点中，当编辑器用户向下移动光标时，链表直接操作到下一个节点即可.但是当用于将光标向上移动呢?这个时候为了回到上一个节点，我们可能需要从first开始，依次走到想要的节点上。

双向链表:

  • 既可以从头遍历到尾，又可以从尾遍历到头
  • 也就是链表相连的过程是双向的.那么它的实现原理，你能猜到吗?
  • 一个节点既有向前连接的引用，也有一个向后连接的引用.
  • 双向链表可以有效的解决单向链表中提到的问题.

双向链表有什么缺点呢?

  • 每次在插入或删除某个节点时，需要处理四个引用，而不是两个，也就是实现起来要困难一些
  • 并且相当于单向链表，必然占用内存空间更大一些
  • 但是这些缺点和我们使用起来的方便程度相比，是微不足道的.
双向链表图解

双向链表长什么样子呢？
请添加图片描述

双向链表的特点:

  1. 可以使用一个head和一个tail分别指向头部和尾部的节点
  2. 每个节点都由三部分组成:前个节点的指针(prev)/保存的元素(item)/后个节点的指针(next)
  3. 双向链表的第一个节点的prev是null
  4. 双向链表的最后的节点的next是null

请添加图片描述

双向链表结构的封装
  // 封装双向链表
  function DoublyLinkedList() {
    // 内部类：节点类
    function Node(data) {
      this.data = data
      this.prev = null
      this.next = null
    }

    // 属性
    this.head = null  // 头部
    this.tail = null  // 尾部
    this.length = 0


    // 常见的操作:方法
  }

双向链表的常见操作

我们先来认识一下， 双向链表中应该有哪些常见的操作

  • append(element) :向列表尾部添加一个新的项
  • insert(position, element) :向列表的特定位置插入一个新的项。
  • get(position) :获取对应位置的元素
  • indexOf(element) :返回元素在列表中的索引。如果列表中没有该元素则返回-1.
  • update(position, element) :修改某个位置的元素
  • removeAt(position) :从列表的特定位置移除项。
  • remove(element) :从列表中移除项。
  • isEmpty() :如果链表中不包含任何元素，返回true，如果链表长度大于0则返回false.
  • size() :返回链表包含的元素个数。与数组的length属性类似。
  • toString() :由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值。
  • forwardString() :返回正向遍历的节点字符串形式
  • backwordString() :返回反向遍历的节点字符串形式
1.append方法
    // 1.append方法
    DoublyLinkedList.prototype.append = function (data) {
      // 1.根据data创建节点
      let newNode = new Node(data);

      // 2.判断添加的节点是否是第一个节点
      if (this.length == 0) {
        this.head = newNode
        this.tail = newNode
      } else {
        newNode.prev = this.tail
        this.tail.next = newNode
        this.tail = newNode
      }
      // 3.length+1
      this.length += 1

    }
2.insert方法

请添加图片描述

    // 3. insert方法
    DoublyLinkedList.prototype.insert = function (position, data) {
      // 1.越界判断
      if (position < 0 || position > this.length) return false
      
      // 2.根据data创建新的节点
      let newNode = new Node(data)
      
      // 3.判断原来的列表是否为空
      if (this.length === 0) {
        this.head = newNode
        this.tail = newNode
      } else {
        if (position == 0) {  // 3.1.判断position是否为0
          this.head.prev = newNode
          newNode.next = this.head
          this.head = newNode
        } else if (position == this.length) {  // 3.2.position==length
          newNode.prev = this.tail
          this.tail.next = newNode
          this.tail = newNode
        }else { //3.3.其他情况
          let current = this.head
          let index = 0

          while (index++ < position) {
            current = current.next
          }
          // 修改指针
          newNode.next = current
          newNode.prev = current.prev
          current.prev.next = newNode
          current.prev = newNode
        }
      }
      // 4.length+1
      this.length += 1
      return true
    }
3.get方法
    // 4.get方法
    DoublyLinkedList.prototype.get = (position) => {
      // 越界判断
      if (position < 0 || position > this.length) return null

      // this.length / 2 > position: 从头向后遍历
      // this.length / 2 < position: 从后向前遍历

      // 2.获取元素
      let current = this.head
      let index = 0

      while (index++ < position) {
        current = current.next
      }

      return current.data
    }
4.indexOf方法
    // 5.indexOf方法
    DoublyLinkedList.prototype.indexOf = data => {
      // 定义变量
      let current = this.head
      let index = 0

      // 2.查找和data相同的节点
      while (current) {
        if (current.data == data) {
          return index
        }
        current = current.next
        index ++
      }
      return -1
    }
5.update方法
    // 6.update方法
    DoublyLinkedList.prototype.update = (position, newData) => {
      // 1.越界判断
      if (position < 0 || position > this.length) return false
      // 2.寻找正确的节点
      let current = this.head
      let index = 0
      while (index++ < position) {
        current = current.next
      }
      // 3.修改找到节点的data信息
      current.data = newData
      return true
    }
6.removeAt方法
    // 7.removeAt方法
    DoublyLinkedList.prototype.removeAt = position => {
      // 1.越界判断
      if (position < 0 || position > this.length) return null

      // 2.判断是否只有一个节点
      let current = this.head
      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) {  // 最后节点
          let current = this.tail
          this.tail.prev.next = null
          this.tail = this.tail.prev
        } else {
          let index = 0

          while (index++ < position){
            current = current.next
          }
          current.prev.next = current.next
          current.next.prev = current.prev
        }
      }
      // 3.length-1
      this.length -= 1

      return current.data
    }
7.其他方法
  // 封装双向链表
  function DoublyLinkedList() {
    // 内部类：节点类
    function Node(data) {
      this.data = data
      this.prev = null
      this.next = null
    }

    // 属性
    this.head = null  // 头部
    this.tail = null  // 尾部
    this.length = 0


    // 常见的操作:方法
    // 1.append方法
    DoublyLinkedList.prototype.append = function (data) {
      // 1.根据data创建节点
      let newNode = new Node(data);

      // 2.判断添加的节点是否是第一个节点
      if (this.length == 0) {
        this.head = newNode
        this.tail = newNode
      } else {
        newNode.prev = this.tail
        this.tail.next = newNode
        this.tail = newNode
      }
      // 3.length+1
      this.length += 1

    }

    // 2.将链表转成字符串形式
    // 2.1. toString方法
    DoublyLinkedList.prototype.toString = function () {
      return this.backwardString()
    }

    // 2.2. forwardString方法
    DoublyLinkedList.prototype.forwardString = function () {
        // 1.定义变量
        let current = this.tail
        let resultString = ""

        // 2.依次向前遍历，获取每一个节点
        while (current) {
          resultString += current.data + " "
          current = current.prev
        }
        return resultString
      }

    // 2.3. backwardString方法
    DoublyLinkedList.prototype.backwardString = function () {
      // 1.定义变量
      let current = this.head
      let resultString = ""

      // 2.依次向后遍历，获取每一个节点
      while (current) {
        resultString += current.data + " "
        current = current.next
      }
      return resultString
    }

    // 3. insert方法
    DoublyLinkedList.prototype.insert = function (position, data) {
      // 1.越界判断
      if (position < 0 || position > this.length) return false
      
      // 2.根据data创建新的节点
      let newNode = new Node(data)
      
      // 3.判断原来的列表是否为空
      if (this.length === 0) {
        this.head = newNode
        this.tail = newNode
      } else {
        if (position == 0) {  // 3.1.判断position是否为0
          this.head.prev = newNode
          newNode.next = this.head
          this.head = newNode
        } else if (position == this.length) {  // 3.2.position==length
          newNode.prev = this.tail
          this.tail.next = newNode
          this.tail = newNode
        }else { //3.3.其他情况
          let current = this.head
          let index = 0

          while (index++ < position) {
            current = current.next
          }
          // 修改指针
          newNode.next = current
          newNode.prev = current.prev
          current.prev.next = newNode
          current.prev = newNode
        }
      }
      // 4.length+1
      this.length += 1
      return true
    }

    // 4.get方法
    DoublyLinkedList.prototype.get = (position) => {
      // 越界判断
      if (position < 0 || position > this.length) return null

      // this.length / 2 > position: 从头向后遍历
      // this.length / 2 < position: 从后向前遍历

      // 2.获取元素
      let current = this.head
      let index = 0

      while (index++ < position) {
        current = current.next
      }

      return current.data
    }

    // 5.indexOf方法
    DoublyLinkedList.prototype.indexOf = data => {
      // 定义变量
      let current = this.head
      let index = 0

      // 2.查找和data相同的节点
      while (current) {
        if (current.data == data) {
          return index
        }
        current = current.next
        index ++
      }
      return -1
    }

    // 6.update方法
    DoublyLinkedList.prototype.update = (position, newData) => {
      // 1.越界判断
      if (position < 0 || position > this.length) return false
      // 2.寻找正确的节点
      let current = this.head
      let index = 0
      while (index++ < position) {
        current = current.next
      }
      // 3.修改找到节点的data信息
      current.data = newData
      return true
    }

    // 7.removeAt方法
    DoublyLinkedList.prototype.removeAt = position => {
      // 1.越界判断
      if (position < 0 || position > this.length) return null

      // 2.判断是否只有一个节点
      let current = this.head
      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) {  // 最后节点
          let current = this.tail
          this.tail.prev.next = null
          this.tail = this.tail.prev
        } else {
          let index = 0

          while (index++ < position){
            current = current.next
          }
          current.prev.next = current.next
          current.next.prev = current.prev
        }
      }
      // 3.length-1
      this.length -= 1

      return current.data
    }

    // 8.remove方法
    DoublyLinkedList.prototype.remove = data => {
      //  根据data获取下标值
      let index = this.indexOf(data)
      // 根据index删除对应位置的节点
      return this.removeAt(index)
    }

    // 9.isEmpty方法
    DoublyLinkedList.prototype.isEmpty = () => {
      return this.length == 0
    }

    // 10.size方法
    DoublyLinkedList.prototype.size = () => {
      return this.length
    }

    // 11.获取链表的第一个元素
    DoublyLinkedList.prototype.getFirst = () => {
      return this.head.data
    }

    // 12.获取链表的最后一个元素
    DoublyLinkedList.prototype.getLast = () => {
      return this.tail.data
    }

  }

  // 测试代码
  let list = new DoublyLinkedList();

  list.append("aaa")
  list.append("bbb")
  list.append("ccc")

  // 2.测试转成字符串的方法
  // alert(list)
  // alert(list.forwardString())
  // alert(list.backwardString())

  // 3.测试insert方法
  list.insert(0, 'ddd')
  list.insert(4, 'ddd')
  list.insert(2, 'ddd')
  // alert(list)

  // 4.测试get方法
  // alert(list.get(2))
  // alert(list.get(3))
  // alert(list.get(1))

  // 5.测试indexOf方法
  // alert(list.indexOf('ccc'))
  // alert(list.indexOf('abc'))
  // alert(list.indexOf('bbb'))
  // alert(list.indexOf('ddd'))

  // 6.测试update方法
  list.update(0, 'mmm')
  list.update(2, 'ppp')
  alert(list)

  // 7.测试removeAt方法
  alert(list.removeAt(2))
  alert(list)

  // 8.测试remove方法
  alert(list.remove('aaa'))
  alert(list)
  alert(list.remove('bbb'))
  alert(list)

  // 9.其他方法
  alert(list.isEmpty())
  alert(list.size())
  alert(list.getFirst())
  alert(list.getLast())
程序猿小离
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C#数据结构之双向链表(DbLinkList)实例详解
09-03
主要介绍了C#数据结构之双向链表(DbLinkList),结合实例形式较为详细的讲解了双向链表的概念及C#实现双向链表的相关技巧,具有一定参考借鉴价值,需要的朋友可以参考下
数据结构学习——双向链表
weixin_62410421的博客
05-03 4955
文章目录前言——双向链表含义一、双向链表结构（图解）二、 双向链表的实际操作1、 结构2、创建头结点3、打印4、插入5、定位6、删除完整代码运行结果 前言——双向链表含义 双向链表也叫双链表，是链表的一种，它的每个数据结点中都有两个指针，分别指向直接后继和直接前驱。所以，从双向链表中的任意一个结点开始，都可以很方便地访问它的前驱结点和后继结点。一般我们都构造双向循环链表。 一、双向链表结构（图解） 二、 双向链表的实际操作 1、 结构 /** * Double linked list of integ
数据结构-链表结构-双向链表
qq_44715376的博客
08-01 3029
双向链表
数据结构 —— 双向链表（超详细图解 & 接口函数实现）
十里坡小白的博客
08-08 5968
数据结构是计算机存储、组织数据的方式。数据结构是指相互之间存在一种或多种特定关系的数据元素的集合。博主将会用代码结合大量图解，对数据结构进行深度剖析。
数据结构之链表详解(2)——双向链表
weixin_69283129的博客
08-29 8948
C语言版万字详解：数据结构之链表详解(2)——双向链表的结构和功能实现
数据结构——双向链表
dongxue727504的博客
03-14 1275
5000字带头双向链表内容，以及尾插尾删等操作讲解。
Python数据结构之双向链表的定义与使用方法示例
09-20
主要介绍了Python数据结构之双向链表的定义与使用方法,结合实例形式分析了Python双向链表的概念、原理、使用方法及相关注意事项,需要的朋友可以参考下
JavaScript数据结构之双向链表定义与使用方法示例
10-19
主要介绍了JavaScript数据结构之双向链表定义与使用方法,简单介绍了双向链表的原理,并结合实例形式分析了双向链表的定义与使用方法,需要的朋友可以参考下
JavaScript数据结构之双向链表和双向循环链表的实现
10-18
本篇文章主要介绍了JavaScript数据结构之双向链表和双向循环链表的实现，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
数据结构 双向链表（C++）
06-07
数据结构　双向链表的实现
【JavaScript源代码】JavaScript数据结构之双向链表.docx
12-29
JavaScript数据结构之双向链表 　单向链表在遍历时只能从头到尾或者从尾遍历到头；所以单向链表可以轻松到达下一节点，但是回到上一个节点是很困难的　而双向链表既可以从头遍历到尾, 又可以从尾遍历到头，链表的...
C语言实现数据结构和双向链表操作
01-21
数据结构 双向链表的实现 双向链表中的每一个结点都含有两个指针域，一个指针域存放其后继结点的存储地址，另一个指针域则存放其前驱结点的存储地址。 双向链表结点的类型描述： //双向链表的类型描述 typedef ...
数据结构双向链表
09-24
编译环境vs2010,C语言实现双向链表的基础操作，详细注释，基础必备。
数据结构之双向链表(完整版)
09-12
双向聊表的实现细节以及菜单显示，对数据结构的同学很有帮助，有注释！大学必备源码，可直接运行，c程序设计加数据结构
数据结构—双向链表（详解）
梅山
03-20 6020
双向链表 在之前一篇文章中介绍了单向链表的实现，可以看出单向链表实现过程中，只能够逐次向下继续查找，指针一直指向下一个节点，而本文中的双向链表，在结构体定义的时候多了一个指向上一节点的指针，因此，无论是在插入还是删除来说，从后往前和从前往后遍历都极大的提高了便利性。下面来介绍双向链表的具体实现。 双向非循环链表的实现 1、链表结构体封装 /* 双向链表的结构 */ typedef struct llist_st { int data; struct llist_st * prev;
数据结构（三）链表
m0_58847961的博客
04-18 946
链表和数组一样，可以用来存储一系列的元素，但是链表和数组的机制完全不同 数组：要存储多个元素，数组（或列表）可能是最常用的数据结构 数组的缺点：1.数组的创建通常都需要申请一段连续的内存空间（一整块的内存），并且大小是固定的（大多数编程语言都是固定的），所以当当前数组不能满足容量需求时，需要扩容（一般情况下是申请一个更大的数组，比如2倍，然后将原来的数组中的元素复制过去） 2.在数组开头或中间插入数据的成本很高，需要大量元素的位移，比如说要在1345里面插入2，就需要把345往后都移动，即使是java
【数据结构】双向链表
m0_73648729的博客
06-28 4467
和单向链表一样，双向链表每个节点都是由结构体组成的数据类型，但是双向链表结构体中增加了一个指向前一个节点的指针。//方便修改数据类型//指向下一个节点的指针//指向前一个节点的指针//存储的数据}LTNode;我们今天要将的是带哨兵卫头节点的双向循环链表，它的头节点不存储有效数据，头节点中的prev指针指向最后一个节点。
数据结构双向链表创建
最新发布
09-29
双向链表是一种具有两个方向的链表结构，每个结点都包含了一个指向前一个结点和后一个结点的指针。创建双向链表的方法有多种。 一种常见的方法是使用结构体来实现双向链表。结构体中的每个结点包含了一个前指针域、数据域和一个后指针域。通过设置指针的指向，可以构建出一个完整的双向链表。 另一种方法是使用构造函数和类来创建双向链表。在构造函数中定义一个节点类，每个节点类包含一个数据元素、一个指向下一个结点的指针和一个指向前一个结点的指针。通过实例化这个类，可以创建一个双向链表对象。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值