【JS数据结构与算法】双向链表（DoublylinkedList）封装及其方法

最新推荐文章于 2023-03-09 17:38:59 发布
最新推荐文章于 2023-03-09 17:38:59 发布
阅读量493 收藏 5
点赞数 2
分类专栏： JS数据结构与算法 文章标签： JS数据结构与算法 JavaScript 双向链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42339197/article/details/98038833
版权

 

目录

双向链表结构

双向链表的封装

一、追溯方法（append(data)）

二、toString()的两种方式。

1、forwardString()（返回正向遍历的节点字符串形式）

2、backwardString() （返回反向遍历的节点字符串形式）

3、toString() （由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值。）

4、代码测试

三、 inset(position, element) 

四、get(position)

1.方法一（对于多元素的获取效率非常低）

2、方法二（利用双向列表的双向性）

3、代码检验

五、indexOf(data)

六、upDate

方法一：（与get方法情况类似，可改进）

方法二：（改进后）

七、removeAt(position)

八、remove(element)

九、判断链表是否为空

十、返回链表的长度

十一、完整代码

双向链表结构

双向链表的封装

    //封装双向链表
    function DoublyLinkedList(){
      // 封装一个内部类，可创建一个新节点
      function Node(data){
        this.data = data;
        this.prev = null;
        this.next = null;
      }

      // 属性
      this.head = null;
      this.tail = null;
      this.length = 0;
    }

一、追溯方法（append(data)）

向双向链表尾部添加一个新的节点（该方法与单向链表的append方法类似）

1、创建新节点

// 1、创建新节点
var newNode = new Node(data);

2、判断双向链表的长度是否为0；

     1.如果是，如图操作

this.head = newNode;
// 两种情况都需要的
this.tail = newNode;

      2.如果不是为0，则是下面这种操作。

newNode.prev = this.tail;
this.tail.next = newNode;
// 两种情况都需要的
this.tail = newNode;

3、append方法代码：

DoublyLinkedList.prototype.append = function(data){
        // 1、创建新节点
        var newNode = new Node(data);

        // 2、判断链表是否为空
        if (this.length == 0) {//2.1 链表为空
          this.head = newNode;
        }else{//2.2 链表不为空
          newNode.prev = this.tail;
          this.tail.next = newNode;
        }

        // 两种情况都需要的
        this.tail = newNode;

        // 3、长度要加1
        this.length += 1;
}

二、toString()的两种方式。

1、forwardString()（返回正向遍历的节点字符串形式）

DoublyLinkedList.prototype.forwardString = function(){
        var current = this.head;
        var resultString = '';
        while(current){
          resultString += current.data + ' ';
          current = current.next;
        }

        return resultString;
}

2、backwardString() （返回反向遍历的节点字符串形式）

 DoublyLinkedList.prototype.backwardString = function(){
        var previous = this.tail;
        var resultString = '';
        while(previous){
          resultString += previous.data + ' ';
          previous = previous.prev;
        }

        return resultString;
}

3、toString() （由于列表项使用了Node类，就需要重写继承自JavaScript对象默认的toString方法，让其只输出元素的值。）

这里是正向遍历，所以直接调用forwardString()即可。

DoublyLinkedList.prototype.toString = function(){
        return this.forwardString();
}

4、代码测试

    // 测试代码
    // 创建DoublyLinkedList
    var DLinkedList = new DoublyLinkedList();

    DLinkedList.append('a');
    DLinkedList.append('b');
    DLinkedList.append('c');
    DLinkedList.append('d');


    alert(DLinkedList.forwardString()); //a b c d 
    alert(DLinkedList.backwardString());  //d c b a 
    alert(DLinkedList.toString()); //a b c d

三、 inset(position, element) 

向链表的特定位置插入一个新的节点。思路与单向链表的inset方法类似，具体操作如图所示。

1、当链表为空时。

// head和tail都指向newNode
this.head = newNode;
this.tail = newNode;

2、当链表不为空，插入的位置为0时。

newNode.next = this.head;
this.head.prev = newNode;
this.head = newNode;

3、当链表不为空，插入的位置是在表尾，与append的第二种方法相同（2.如果不是为0，则是下面这种操作。）

newNode.prev = this.tail;
this.tail.next = newNode;
// 两种情况都需要的
this.tail = newNode;

4、当链表不为空，插入的位置是在链表之中。

var index = 0;
var current = this.head;
while(index++ < position){
   current = current.next;
}
newNode.prev = current.prev; // 1
current.prev.next = newNode; // 2
newNode.next = current; // 3
current.prev = newNode; // 4

注意：这里需要注意的是，current所指向之前的节点（current.prev）和节点所带的next指向（current.prev.next）是新节点需要定位的节点，所以在改变current.prev的指向之前需要先执行①和②的操作。

5、链表长度加1

this.length += 1;

6、代码实现

      DoublyLinkedList.prototype.inset = function(position, data){
        
        // 1、 先判断position是否合法
        if (position < 0 || position > this.length) return false;

        // 2、创建新节点
        var newNode = new Node(data);

        // 3、 判断链表长度是否为0
        if (this.length == 0) { // 3.1 链表长度为0
          // head和tail都指向newNode
          this.head = newNode;
          this.tail = newNode;
        }else{ // 3.2链表长度为0

          // 4、 判断插入位置是否为0
          if (position == 0) { // 4.1 插入位置为0
            newNode.next = this.head;
            this.head.prev = newNode;
            this.head = newNode;
          }else if(position == this.length){// 4.2插入位置为链表末尾
            newNode.prev = this.tail;
            this.tail.next = newNode;
          }else{  // 4.3 插入位置在链表之中
            var index = 0;
            var current = this.head;
            while(index++ < position){
              current = current.next;
            }
            newNode.prev = current.prev;
            current.prev.next = newNode;
            newNode.next = current;
            current.prev = newNode;
          }
        }
        // 5、长度要加1
        this.length += 1;
      }

7、代码检验

    // 测试代码
    // 创建DoublyLinkedList
    var DLinkedList = new DoublyLinkedList();

    DLinkedList.append('a');
    DLinkedList.append('b');
    DLinkedList.append('c');
    DLinkedList.append('d');
    alert(DLinkedList.toString()); //a b c d 

    DLinkedList.inset(0,'e');
    alert(DLinkedList.toString()); //e a b c d 

    DLinkedList.inset(2,'f');
    alert(DLinkedList.toString()); //e a f b c d 

    DLinkedList.inset(6,'g');
    alert(DLinkedList.toString()); //e a f b c d g

四、get(position)

获取对应位置的元素

1.方法一（对于多元素的获取效率非常低）

      DoublyLinkedList.prototype.get =function(position){
        // 1、 先判断position是否合法
        if (position < 0 || position > this.length - 1) return null;

        // 2、根据position位置信息找到对应节点
        var index = 0;
        var current = this.head;
        while(index++ < position){
          current = current.next;
        }
        return current.data;
      }

2、方法二（利用双向列表的双向性）

      DoublyLinkedList.prototype.getFast =function(position){
        // 1、 先判断position是否合法
        if (position < 0 || position > this.length - 1) return null;

        // 2、根据position位置信息找到对应节点
        var previous = this.head;
        var current = this.tail;
        if (position < this.length / 2) {  //从前往后遍历
          var index = 0;
          while(index++ < position){
            previous = previous.next;
          }
          return previous.data;
        }else{    // 从后往前遍历
          var index = this.length - 1;
          while(index-- > position){
            current = current.prev;
          }
          return current.data;
        }
      }

 

3、代码检验

    // 测试代码
    // 创建DoublyLinkedList
    var DLinkedList = new DoublyLinkedList();

    DLinkedList.append('a');
    DLinkedList.append('b');
    DLinkedList.append('c');
    DLinkedList.append('d');
    DLinkedList.append('e');
    alert(DLinkedList.getFast(-1)); //null
    alert(DLinkedList.getFast(0)); //a
    alert(DLinkedList.getFast(1)); //b
    alert(DLinkedList.getFast(2)); //c
    alert(DLinkedList.getFast(3)); //d
    alert(DLinkedList.getFast(4)); //e
    alert(DLinkedList.getFast(5)); //null

五、indexOf(data)

返回元素在列表中的索引，如果列表中没有该元素则返回-1

      DoublyLinkedList.prototype.indexOf =function(data){
        var index = 0;
        var current = this.head;

        while(current){
          if (current.data == data) return index;
          current = current.next;
          index += 1;
        }

        return -1;
      }

2、测试代码

    // 测试代码
    // 创建DoublyLinkedList
    var DLinkedList = new DoublyLinkedList();

    DLinkedList.append('a');
    DLinkedList.append('b');
    DLinkedList.append('c');
    alert(DLinkedList.indexOf('a')); //0
    alert(DLinkedList.indexOf('b')); //1
    alert(DLinkedList.indexOf('c')); //2
    alert(DLinkedList.indexOf('d')); //-1
    alert(DLinkedList.indexOf('e')); //-1

六、upDate

修改某位置的元素

方法一：（与get方法情况类似，可改进）

      DoublyLinkedList.prototype.upDate = function(position, data){
 
        // 越界判断
        if (position < 0 || position >= this.length) return false;
 
        var index = 0;
        var current = this.head;
        while(index++ < position){
          current = current.next;
        }
        current.data = data;
        return true;
      }

方法二：（改进后）

      DoublyLinkedList.prototype.upDate = function(position, data){
 
        // 越界判断
        if (position < 0 || position >= this.length) return false;
 
        // 2、根据position位置信息找到对应节点
        var previous = this.head;
        var current = this.tail;
        if (position < this.length / 2) {  //从前往后遍历
          var index = 0;
          while(index++ < position){
            previous = previous.next;
          }
          previous.data = data;
        }else{ //从后往前遍历
          var index = this.length - 1;
          while(index-- > position){
            current = current.prev;
          }
          current.data = data;
        }
        return true;
      }

七、removeAt(position)

删除相应位置的元素，如果删除成功返回其值

情况一：当链表的长度为1

this.head = null;
this.tail = null;

情况二：链表长度不为1，删除第一个节点。

this.head.next.prev = null
this.head = this.head.next;

情况三：链表长度不为1，删除最后一个节点。

this.tail.prev.next = null;
this.tail = this.tail.prev;

情况二：链表长度不为1，删除的节点不是第一个和最后一个。

var index = 0;
var current = this.head;
while(index++ < position){
    current = current.next;
}
current.prev.next = current.next;
current.next.prev = current.prev;

最后别忘记length-1

完整代码

     DoublyLinkedList.prototype.removeAt = function(position){
        // 判断position是否合法
        if (position < 0 || position >= this.length) return false;

        // 寻找节点
        var current = this.head;
        if (this.length == 1) {
          this.head = null;
          this.tail = null;
        }else{
          if (position == 0) {
            // 让head指向第二个节点
            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{
            var index = 0;
            while(index++ < position){
              current = current.next;
            }
            current.prev.next = current.next;
            current.next.prev = current.prev;
          }
        }

        // length-1
        this.length -= 1;

        return current.data;
      }

测试代码

    // 测试代码
    // 创建DoublyLinkedList
    var DLinkedList = new DoublyLinkedList();

    DLinkedList.append('a');
    DLinkedList.append('b');
    DLinkedList.append('c');
    DLinkedList.removeAt(3);
    alert(DLinkedList.toString()); //a b c 
    DLinkedList.removeAt(0);
    alert(DLinkedList.toString()); //b c 
    DLinkedList.removeAt(1);
    alert(DLinkedList.toString()); //b
    DLinkedList.removeAt(0);
    alert(DLinkedList.toString()); //

八、remove(element)

删除一项数据

      DoublyLinkedList.prototype.remove = function(data){
        // 根据data获取元素位置
        var index = this.indexOf(data);

        // 根据index将对应节点删除
        return this.removeAt(index);
      }

这里删除的是indexOf遍历时满足的第一个节点，后续不再查找。

九、判断链表是否为空

DoublyLinkedList.prototype.isEmpty = function(){
    return this.length === 0;
}

十、返回链表的长度

DoublyLinkedList.prototype.size = function(){
    return this.length;
}

十一、完整代码

<!DOCTYPE html>
<html>
<head>
  <meta charset="utf-8">
  <title>双向链表的封装</title>
</head>
<body>
  <script type="text/javascript">

    //封装双向链表
    function DoublyLinkedList(){
      // 封装一个内部类，可创建一个新节点
      function Node(data){
        this.data = data;
        this.prev = null;
        this.next = null;
      }

      // 属性
      this.head = null;
      this.tail = null;
      this.length = 0;

      // 一、append方法:
      DoublyLinkedList.prototype.append = function(data){
        // 1、创建新节点
        var newNode = new Node(data);

        // 2、判断链表是否为空
        if (this.length == 0) {//2.1链表为空
          this.head = newNode;
        }else{//2.2 链表不为空
          newNode.prev = this.tail;
          this.tail.next = newNode;
        }

        // 两种情况都需要的
        this.tail = newNode;

        // 3、长度要加1
        this.length += 1;
      }

      // 二、两种toString方法

      // 2.1forwardString
      DoublyLinkedList.prototype.forwardString = function(){
        var current = this.head;
        var resultString = '';
        while(current){
          resultString += current.data + ' ';
          current = current.next;
        }

        return resultString;
      }
      
      // 2.2 backwardString
      DoublyLinkedList.prototype.backwardString = function(){
        var previous = this.tail;
        var resultString = '';
        while(previous){
          resultString += previous.data + ' ';
          previous = previous.prev;
        }

        return resultString;
      }

      // 2.3 toString
      DoublyLinkedList.prototype.toString = function(){
        return this.forwardString();
      }


      // 三、 inset()
      DoublyLinkedList.prototype.inset = function(position, data){
        
        // 1、 先判断position是否合法
        if (position < 0 || position > this.length) return false;

        // 2、创建新节点
        var newNode = new Node(data);

        // 3、 判断链表长度是否为0
        if (this.length == 0) { // 3.1 链表长度为0
          // head和tail都指向newNode
          this.head = newNode;
          this.tail = newNode;
        }else{ // 3.2链表长度为0
          // 4、 判断插入位置是否为0
          if (position == 0) { // 4.1 插入位置为0
            newNode.next = this.head;
            this.head.prev = newNode;
            this.head = newNode;
          }else if(position == this.length){// 4.2插入位置为链表末尾
            newNode.prev = this.tail;
            this.tail.next = newNode;
          }else{  // 4.3 插入位置在链表之中
            var index = 0;
            var current = this.head;
            while(index++ < position){
              current = current.next;
            }
            newNode.prev = current.prev;
            current.prev.next = newNode;
            newNode.next = current;
            current.prev = newNode;
          }
        }
        // 5、长度要加1
        this.length += 1;
      }

      // 四、get()

      // 方法一
      DoublyLinkedList.prototype.get =function(position){
        // 1、 先判断position是否合法
        if (position < 0 || position > this.length - 1) return null;

        // 2、根据position位置信息找到对应节点
        var index = 0;
        var current = this.head;
        while(index++ < position){
          current = current.next;
        }
        return current.data;
      }

      // 方法二（优化）
      DoublyLinkedList.prototype.getFast =function(position){
        // 1、 先判断position是否合法
        if (position < 0 || position > this.length - 1) return null;

        // 2、根据position位置信息找到对应节点
        var previous = this.head;
        var current = this.tail;
        if (position < this.length / 2) {
          var index = 0;
          while(index++ < position){
            previous = previous.next;
          }
          return previous.data;
        }else{
          var index = this.length - 1;
          while(index-- > position){
            current = current.prev;
          }
          return current.data;
        }
      }


      // 五、
      DoublyLinkedList.prototype.indexOf =function(data){
        var index = 0;
        var current = this.head;

        while(current){
          if (current.data == data) return index;
          current = current.next;
          index += 1;
        }

        return -1;
      }

      // 六
      DoublyLinkedList.prototype.upDate = function(position, data){
 
        // 越界判断
        if (position < 0 || position >= this.length) return false;
 
        // 2、根据position位置信息找到对应节点
        var previous = this.head;
        var current = this.tail;
        if (position < this.length / 2) {
          var index = 0;
          while(index++ < position){
            previous = previous.next;
          }
          previous.data = data;
        }else{
          var index = this.length - 1;
          while(index-- > position){
            current = current.prev;
          }
          current.data = data;
        }
        return true;
      }


      // 七
      DoublyLinkedList.prototype.removeAt = function(position){
        // 判断position是否合法
        if (position < 0 || position >= this.length) return false;

        // 寻找节点
        var current = this.head;
        if (this.length == 1) {
          this.head = null;
          this.tail = null;
        }else{
          if (position == 0) {
            // 让head指向第二个节点
            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{
            var index = 0;
            while(index++ < position){
              current = current.next;
            }
            current.prev.next = current.next;
            current.next.prev = current.prev;
          }
        }

        // length-1
        this.length -= 1;

        return current.data;
      }


      // 八、remove(data)
      DoublyLinkedList.prototype.remove = function(data){
        // 根据data获取元素位置
        var index = this.indexOf(data);

        // 根据index将对应节点删除
        return this.removeAt(index);
      }

      // 九、判断链表是否为空
      DoublyLinkedList.prototype.isEmpty = function(){
        return this.length == 0;
      }

      // 十、获取队列中的元素个数
      DoublyLinkedList.prototype.size = function(){
        return this.length;
      }


    }

    // 创建DoublyLinkedList
    var DLinkedList = new DoublyLinkedList();

    // 测试代码


  </script>
</body>
</html>

 

hcq29
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
看动画学算法之:doublyLinkedList
程序那些事
07-27 2万+
文章目录简介doublyLinkedList的构建doublyLinkedList的操作头部插入尾部插入插入给定的位置删除指定位置的节点 简介 今天我们来学习一下复杂一点的LinkedList：doublyLinkedList。 和LinkedList相比，doublyLinkedList中的节点除了next指向下一个节点之外，还有一个prev之前的一个节点。所以被称为doublyLinkedList。 doublyLinkedList是一个双向链表，我们可以向前或者向后遍历list。 今天我们来学习一下d
DoublyLinkedList(双向链表)
ding7530的博客
08-26 408
　　本来还不会写双向链表的，但最近学习了二叉树后，突然意识到这不就是双向链表嘛，然后通过对二叉树的理解，实现了一下双向链表。 　　代码： #define SIZE 10 DouLL * head, *n, *p; head =（DouLL * )malloc(sizeof(DouLL)); p = head;　　/* p指针的作用很重要 */ p->Item...
double linked list双向链表
晨识草的博客
04-27 3973
[tags] C++双向链表的实现与单向链表相近 节点结构体 类声明 总结双向链表的实现（与单向链表相近）1. 节点结构体struct DouListNode { int elem; DouListNode *prev, *next; DouListNode(int e = 0, DouListNode *p = 0, DouListNode *n = 0) { elem = e
List（double linked）
PYPARA的博客
02-21 999
简易版链表 ，目前还有些问题， 1.由于构造函数中会new一个Node，所以链表中会对出一个由默认T()构造的Node 2.打印链表中的元素非常不方便 等/* LIST-SEARCH(L,k) x=L.head while x!=NIL and key !=k x=x.next return xLIST-INSERT(L,x) x.next= L.head if L.head!=NIL
java-doubly-linked-list:Java中的双向链接列表的实现
05-01
java-doubly-linked-list Java中的双向链接列表的实现
tongxunlu.rar_C语言双向链表_city_doubly linked list_tongxunlu_数据结构 通讯录
09-22
用〈〈数据结构〉〉中的双向链表作数据结构，结合C语言基本知识。编写一个通讯录管理系统。以把所学数据结构知识应用到实际软件开发中去。 设计内容：本系统应完成一下几方面的功能： 输入信息——enter() 显示信息...
JS中的算法与数据结构之链表(Linked-list)实例详解
10-16
主要介绍了JS中的算法与数据结构之链表(Linked-list),结合实例形式详细分析了javascript中链表的概念、原理、定义及常用操作技巧,需要的朋友可以参考下
【Java数据结构与算法】双向链表
12-21
双向链表 单向链表的缺点分析 单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找 单向链表不能自我删除，需要靠辅助节点，而双向链表，则可以自我删除，所以前面删除单向链表节点时，需要找到...
数据结构与算法:单向链表实现与封装
08-26
"数据结构与算法：单向链表实现与封装" 在计算机科学中，数据结构是指计算机中存储、组织和管理数据的方式。链表是一种基本的数据结构，单向链表是指链表中的每个节点 chỉ指向下一个节点的数据结构。今天，我们将...
Java LinkedList 双向链表实现原理
01-20
相信大家都明白 LinkedList 是基于双向链表而实现的，本篇文章主要讲解一下双向链表的实现，并且我们参考 LinkedList 自己实现一个单链表尝试一下。 什么是链表？ 简单的来讲一下什么是链表：首先链表是一种线性的数据结构（其他数据结构还有，树、图），是在每一个节点里存到下一个节点（next）的指针（Pointer）。 链表最大的好处则是采用了见缝插针的方式，链表中的每一个节点分布在内存的不同位置（链表不需要一块连续完整的空间），依靠 next 指针关联起来。这样可以灵活有效地利用零散的碎片空间。由于不必须按顺序存储，链表的插入和删除操作可以达到 O(1) 的复杂度。 而双向链表比单
DoublyLinkedList.Java:Java 中的双向链表
06-07
双链表.Java 我在 2013 年秋季为 cs2110 实现的 Java 双向链表
C++实现双向链表（完整代码）
05-10
使用面向对象实现的双向链表，适合初学者的学习与借鉴。（完整代码已测试）
线性表之双链表--DoublyLinkList，类似于类库中的 LinkedList
tanjiquan的博客
02-16 650
线性表之双链表（DoublyLinkList），笔者自己定义的一个双链表，和类库中的LinkedList 类似， 可能很多方法写的还是不是很全，共享给读者。若想了解更多参见类库源代码及文档。
表-双链表(list/doubly-linked-list)
weixin_30576859的博客
01-29 74
双链表 链表是表ADT的一种链式映像。双链表是链表的一种，即每个结点有两个指针域，一个指向前驱，一个指向后继。 (这里的链表是带有头结点的链表，头结点前驱指向最后一个结点，或无前驱) 双链表的结点的声明与定义如下： //clare node struct Node; typedef struct Node *PtrToNode; typedef struct PtrToNode Positi...
List接口实现类LinkedList源码及详解
听海的博客
06-20 342
LinkedList概述 一看名字就知道它肯定是使用链表实现的List集合，LinkedList是基于双向链表实现的， 实现所有可选的列表操作，并允许所有元素（包括null）。注意LinkedList实现不是同步的，所以如果需要在多线程中使用它，则它必须在外部进行同步。使用这样的： List list = Collections.synchronizedList(new Linked
PHP标准库SplDoublyLinkedList双向链表类
Shelly Long的博客
01-18 148
常量： /* 常量 */ const integer IT_MODE_LIFO = 2 ;// 迭代器模式后进先出(iterator mode Last In,First Out) const integer IT_MODE_FIFO = 0 ;// 迭代器模式先进先出(iterator mode First In,First Out) const integer IT_MODE_DELETE...
数据结构之链表(Linked-List)及操作
David的博客
07-07 4032
一、 数据结构之链表(Linked-List) 线性表是最常用的存储结构，线性表的每个单元称为元素，元素拥有一个数据及一个地址线性表有两种物理存储方式：顺序存储方式和链式存储方式数组是具有代表性的顺序存储方式的线性表，单链表是具有代表性的链式存储方式的线性表。 1.数组 数组的内存是连续分配的，可以通过数组的索引直接获取对应的数据，其索引就是线性表中所说的元素的“地址”，但索引不是地...
双向循环链表的模板封装
最新发布
freex64的专栏
03-09 170
程序员对双向循环链表的熟悉程度，那就像周星扮演的唐伯虎说《椿树秋香图》一样——“画了几百次啦，熟得很”！。所以直接进入正题模板封装，封装之后模板名称是rubbish::structlist。
js实现简单双向链表封装
Hiroshi's
03-25 183
function DoublyLinkedList() { this.head = null; this.tail = null; this.length = 0; function Node(data) { this.previous = null; ...
软考辅导-数据结构与算法(“结点”文档)共134张.pptx
12-01
"该资源为软考辅导资料，专注于数据结构与算法的讲解，特别是关于‘结点’的深入理解。包含134张PPT，涵盖了数据结构的基础概念、逻辑结构、存储结构以及各类算法的分析和应用，如线性表、树、图、排序算法和查找...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值