JavaScript数据结构与算法Item4--链表_数据结构中链表item算法

最新推荐文章于 2024-07-24 23:21:10 发布
最新推荐文章于 2024-07-24 23:21:10 发布
阅读量663 收藏 15
点赞数 11
分类专栏： 作者\/ 文章标签： 数据结构 javascript 链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85124837/article/details/139240685
版权 
return head;

};


总的结构代码：

function LinkedList(){
function Node(element){
this.element = element;
this.next = null;
}

  this.head = null;
  this.length = 0;

  this.append = function(element){
    var node = new Node(element),
        current;

    if(this.head == null){
      this.head = node;
    }else{
      current = this.head;
      while(current.next){
        current = current.next;
      }
    current.next = node;
    }
    this.length ++;
  }

  this.removeAt = function(position){
    var current = this.head,
    index = 0,
        prev;
    if(position > -1 && position < this.length){ //检查越界值
      if (position == 0){  //删除第一项，将head指向第一个元素即可；
        this.head = current.next;
      }
      else{
        while(index++ < position){ //将previous与current的下一项链接起来：跳过current，从而移除它,此处找到前一项；
          prev = current;
          current = current.next;
        }
        prev.next = current.next; //此处跳过current；
      }
      this.length --;
      return true;
    }else{
      return null;
    }
  }

  this.insert = function(position, element){
    var current = this.head,
    index = 0,
    prev,
    node = new Node(element);
    if(position> -1 && position < this.length){
      if(position == 0){
        this.head = node;
        node.next = current;
      }else{
        while(index++ < position){
          prev = current;
          current = current.next;
        }
        prev.next = node;
        node.next = current
      }
      this.length ++;
    }else{
      return false;
    }
  }

  this.indexOf = function(element){
    var current = this.head;
    index = -1;
    while(current){
      index ++;
      if(current.element === element){
        return index;
      }
      current = current.next;
    }
      return -1;
  }

  this.remove = function(element){
    var index = this.indexOf(element);
    this.removeAt(index);
  }

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

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

  this.getHead = function(){
    return this.head;
  }

  this.toString = function(){
    var current = this.head,
        string = '';
        while(current){
          string += current.element + '-->';
          current = current.next;
        }
        return string;
  }

}

var linkedList = new LinkedList();
linkedList.append(10);
linkedList.append(15);
linkedList.append(20);
linkedList.append(25);
linkedList.append(30);
linkedList.append(35);
console.log(linkedList.toString());
linkedList.removeAt(2);
console.log(linkedList.toString());
linkedList.insert(2,111);
console.log(linkedList.toString());
console.log(linkedList.indexOf(10))


### 2 双向链表


链表有多种不同的类型，这一节介绍双向链表。双向链表和普通链表的区别在于，在链表中，   
 一个节点只有链向下一个节点的链接，而在双向链表中，链接是双向的：一个链向下一个元素，   
 另一个链向前一个元素，如下图所示：


![](http://i.imgur.com/Pwwfs3T.png)


先从实现DoublyLinkedList类所需的变动开始：

function DoublyLinkedList() {
var Node = function(element){
this.element = element;
this.next = null;
this.prev = null; //新增的

};
var length = 0;
var head = null;
var tail = null; //新增的
//这里是方法

}


#### **在任意位置插入一个新元素**


向双向链表中插入一个新项跟（单向）链表非常类似。区别在于，链表只要控制一个next   
 指针，而双向链表则要同时控制next和prev（previous，前一个）这两个指针。   
 ![](http://i.imgur.com/gLGi5Up.png)

this.insert = function(position, element){
var current = this.head,
index = 0,
prev,
node = new Node(element);
if(position> -1 && position < this.length){
if(position == 0){
if(!this.head){//插入空的链表中的首位
this.head = node;
this.tail = node;
}else{
this.head = node;
node.next = current;
current.prev = node;
}
}else if(position == this.length){
current = tail;
current.next = node;
node.prev = current;
this.tail = node;
}else{
while(index++ < position){
previous = current;
current = current.next;
}
previous.next = node;
node.next = current;
node.prev = previous;
current.prev = node;
}
this.length ++;
return true;
}else{
return false;
}
}


#### **从任意位置移除元素**


我们需要处理三种场景：从头部、从中间和从尾部移除一个元素。   
 ![](http://i.imgur.com/e1GVogB.png)

this.removeAt = function(position){
var current = this.head,
index = 0,
prev;
if(position > -1 && position < this.length){ //检查越界值
if (position == 0){ //删除第一项，将head指向第一个元素即可；
this.head = current.next;
if(this.length == 1){
this.tail = null;
}else{
this.head.prev = null;
}
}else if(position == this.length -1){
current = this.tail;
this.tail = current.prev;
this.tail.next = null;

     }
     else{
       while(index++ < position){ //将previous与current的下一项链接起来：跳过current，从而移除它,此处找到前一项；
         previous = current;
         current = current.next;
       }
       previous.next = current.next; //此处跳过current；
       current.next.prev = previous; 

     }
     this.length --;
     return current.element;
   }else{
     return null;
   }
 }


### 3 循环链表


循环链表可以像链表一样只有单向引用，也可以像双向链表一样有双向引用。循环链表和链   
 表之间唯一的区别在于，最后一个元素指向下一个元素的指针（tail.next）不是引用null，   
 而是指向第一个元素（head），如下图所示。


![](http://i.imgur.com/WyodomJ.png)   
 双向循环链表有指向head元素的tail.next，和指向tail元素的head.prev。   
 ![](http://i.imgur.com/AhA8THL.png)


双向链表总程序

function DoubleLinkedList(){
function Node(element){
this.element = element;
this.prev = null;
this.next = null;
}

 this.head = null;
 this.tail = null;
 this.length = 0;

 this.append = function(element){
   var node = new Node(element),
       current;

   if(this.head == null){
     this.head = node;
     this.tail = node;
   }else{
     current = this.head;
     while(current.next){
       current = current.next;
     }
   current.next = node;
   node.prev = current;
   this.tail = node;
   }
   this.length ++;
 }

 this.removeAt = function(position){
   var current = this.head,
   index = 0,
       prev;
   if(position > -1 && position < this.length){ //检查越界值
     if (position == 0){  //删除第一项，将head指向第一个元素即可；
       this.head = current.next;
       if(this.length == 1){
         this.tail = null;
       }else{
         this.head.prev = null;
       }
     }else if(position == this.length -1){
       current = this.tail;
       this.tail = current.prev;
       this.tail.next = null;

     }
     else{
       while(index++ < position){ //将previous与current的下一项链接起来：跳过current，从而移除它,此处找到前一项；
         previous = current;
         current = current.next;
       }
       previous.next = current.next; //此处跳过current；
       current.next.prev = previous; 

     }
     this.length --;
     return current.element;
   }else{
     return null;
   }
 }

 this.insert = function(position, element){
   var current = this.head,
   index = 0,
   prev,
   node = new Node(element);
   if(position> -1 && position < this.length){
     if(position == 0){
       if(!this.head){//插入空的链表中的首位
         this.head = node;
         this.tail = node;
       }else{
         this.head = node;
         node.next = current;
         current.prev = node;
       }
     }else if(position == this.length){
       current = tail;
       current.next = node;
       node.prev = current;
       this.tail = node;
     }else{
       while(index++ < position){
         previous = current;
         current = current.next;
       }
       previous.next = node;
       node.next = current;
       node.prev = previous;
       current.prev = node;
     }
     this.length ++;
     return true;
   }else{
     return false;
   }
 }

 this.indexOf = function(element){
   var current = this.head;
   index = -1;
   while(current){
     index ++;
     if(current.element === element){
       return index;
     }
     current = current.next;
   }
     return -1;
 }

 this.remove = function(element){
   var index = this.indexOf(element);
   this.removeAt(index);
 }

 this.isEmpty = function(){
   return this.length === 0;
 }
2401_85124837
关注
  • 11
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript中数据结构与算法(三)：链表
12-02
链表是一种重要的数据结构，它在计算机科学中广泛应用于各种算法和数据结构的实现。相对于数组，链表在处理动态数据变化时具有显著优势。在JavaScript中，由于数组的优化，如快速的push、pop、shift和unshift等操作...
JavaScript数据结构与算法之链表
10-22
在JavaScript中，链表是一种非连续的线性数据结构，它通过节点间的引用关系来组织数据，而不是像数组那样按照连续的内存位置存储。链表的主要优势在于它可以在不预先知道数据大小的情况下灵活地添加和删除元素，因为...
JavaScript数据结构与算法Item4--链表
小平果的欢乐谷
09-27 879
要存储多个元素，数组（或列表）可能是最常用的数据结构,，每种 语言都实现了数组。这种数据结构非常方便，提供了一个便利的[]语法来访问它的元素。然而， 这种数据结构有一个缺点：（在大多数语言中）数组的大小是固定的，从数组的起点或中间插入 或移除项的成本很高，因为需要移动元素.链表存储有序的元素集合，但不同于数组，链表中的元素在内存中并不是连续放置的。每个 元素由一个存储元素本身的节点和一个指向
javascript数据结构与算法----单向链表
Seeyoucm
06-03 474
javascript数据结构与算法----单向链表
JavaScript版数据结构与算法-链表
weixin_43550660的博客
01-09 326
JavaScript版数据结构与算法-链表 链表 多个元素组成的列表 元素存储不连续,用next指针连在一起 链表 VS 数组 **数组:**增删非首尾元素时往往需要移动元素 **链表:**增删非首尾元素,不需要移动元素,只需要更改next的指向即可 js的链表 js中是没有链表 可以用Object模拟链表 const a = { val : 'a'} const b = { val : 'b'} const c = { val : 'c'} const d = { val : 'd'} a.
学习JavaScript 数据结构与算法
我是一只蘑菇17的博客
11-10 2378
学习链接：https://github.com/XPoet/js-data-structures-and-algorithms JavaScript 数据结构与算法 1.数据结构(data structure) 数据结构是数据对象，以及存在于该对象的实例和组成实例的数据元素之间的各种联系 ​ 是计算机中存储、组织数据的方式。通常情况下，精心选择的数据结构可以带来最优效率的算法 2.解决问题方法的效率，根据数据的组织方式有关 3.常见的数据结构：数组，栈，链表，图，散列表，队
JS中的算法与数据结构之链表(Linked-list)实例详解
10-16
主要介绍了JS中的算法与数据结构之链表(Linked-list),结合实例形式详细分析了javascript中链表的概念、原理、定义及常用操作技巧,需要的朋友可以参考下
c语言（7.23）
fhgfyrsg的博客
07-23 587
【代码】c语言（7.23）
【算法与数据结构】并查集
2301_79728896的博客
07-23 340
合并和查询集合的数据结构，KruskalLCA查询的时间复杂度：小于O(log2​n)近乎O(1)
Linux嵌入式学习——数据结构——线性表的链式结构
m0_71703182的博客
07-24 760
在链表的尾部插入一个新节点，该节点包含指定的数据data。函数返回成功或失败的状态码。
手撕数据结构02--二分搜索（附源码）
weixin_64593595的博客
07-24 343
对于二分搜索的理论与实现的知识点学习。
数据结构：逻辑结构与物理结构
Weiki的博客
07-24 957
数据结构：逻辑结构与物理结构
数据结构之深入理解简单选择排序：原理、实现与示例（C，C++）
qq_35320456的博客
07-24 793
简单选择排序虽然在大数据量下效率不高，但它易于理解和实现，是理解排序算法基本思想的良好起点。在实际应用中，如果数据量较小或者对排序稳定性要求不高，选择排序可以作为一种简单有效的选择。
【初阶数据结构】复杂度算法题篇
2301_79849925的博客
07-24 321
我们可以先将所有元素翻转，这样尾部的 kmodn 个元素就被移至数组头部，然后我们再翻转 [0,kmodn−1] 区间的元素和 [kmodn,n−1] 区间的元素即能得到最后的答案。该方法基于如下的事实：当我们将数组的元素向右移动 k 次后，尾部 kmodn 个元素会移动至数组头部，其余元素向后移动 kmodn 个位置。时间复杂度：O(n)空间复杂度：O(1)
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 434
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
算法 - 查找算法（顺序、折半、红黑树、AVL树、B+树、散列）
暴力扬
07-21 958
本文一共讲解了以下查找算法： 1. 顺序查找 2. 折半查找（二分查找） 3. 分块查找 4. 二叉排序树查找 5. 平衡二叉树（AVL树）查找 6. 红黑树查找 7. B树查找 8. B+树查找 9. 散列查找 每种查找算法都包括了其查找原理、实现步骤、代码实现思路、C语言代码以及代码解释。
数据结构--二叉树详解
2302_81705247的博客
07-24 740
二叉树的分类、二叉树的遍历。一棵树的节点个数，求叶子节点的个数，获取k层节点的个数，树的高度，找到某个节点，检查两棵树是否相同，第二棵树是否是第一棵树的子树，翻转二叉树，判断一棵二叉树是否是平衡二叉树，对称二叉树
【数据结构】顺序表（c语言实现）（附源码）
最新发布
2301_80955819的博客
07-24 857
顺序表的概念和结构，顺序表的分类，顺序表的功能实现
JavaScript数据结构与算法详解：从基础到高级实践
"《JS数据结构与算法.pdf》是一本深度讲解JavaScript编程中数据结构与算法的专业书籍，由巴西作者Loiane Groner撰写，中文版由孙晓博、邓钢、吴双、陈迪和袁源翻译。该书旨在为前端Web开发人员以及所有对JavaScript...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值