Javascript中的链表

function LinkedList() {
        // 辅助类,表示加入链表的每一项
        var Node=function(element){
          this.element=element;
          this.next=null;
        }
        // 列表,存储链表的长度
        var length=0;
        var head=null;
        this.append=function(element){
          var node=new Node(element),current;
          if(head===null){
            head=node;
          }else{
            current=head;
            // 找到链表中的最后一个元素
            while (current.next) {
              current=current.next;
            }
            current.next=node;
          }
          length++;
        };
        this.insert=function(pos,element){
          if (pos>=0 && pos<=length) {
            var node=new Node(element),current=head,previous,index=0;
            if(position===0){
              node.next=current;
              head=node;
            }else{
              while (index++<pos) {
                previous=current;
                current=current.next;
              }
              node.next=current;
              previous.next=node;
            }
            length++;
            return true;
          }else{
            return false;
          }
        };
        this.removeAt=function(pos){
          if(pos>-1 && pos<length){
            var current=head,previous,index=0;
            if(pos==0){
              head=current.next;
            }else{
              while (index++<pos) {
                previous=current;
                current=current.next;
              }
              previous.next=current.next;
            }
            length--;
            return current.element;
          }else{
            return null;
          }
        };
        this.remove=function(element){
          var index=this.indexOf(element);
          return this.removeAt(index);//不太好,重复遍历了2次
        };
        this.indexOf=function (element) {
          var current=head,index=0;
          while (current) {
            if(element===current.element){
              return index;
            }
            index++;
            current=current.next;
          }
          return -1;
        };
        this.isEmpty=function () {
          return length===0;
        };
        this.size=function () {
          return length;
        };
        this.toString=function(){
          var current=head,str=‘‘;
          while (current) {
            str+=","+current.element;
            current=current.next;
          }
          return str.slice(1);
        };
        this.print=function(){
          console.log(this.toString());
        };
        this.getHead=function(){
          return head;
        }
      }
      function DoublyLinkedList() {
        // 辅助类,表示加入链表的每一项
        var Node=function(element){
          this.element=element;
          this.next=null;
          this.prev=null;
        }
        // 列表,存储链表的长度
        var length=0;
        var head=null;
        var tail=null;
        this.append=function(element){
          var node=new Node(element),current;
          if(head===null){
            head=node;
          }else{
            current=head;
            // 找到链表中的最后一个元素
            while (current.next) {
              current=current.next;
            }
            current.next=node;
          }
          length++;
        };
        this.insert=function(pos,element){
          if (pos>=0 && pos<=length) {
            var node=new Node(element),current=head,previous,index=0;
            if(pos===0){
              if(!head){
                head=node;
                tail=node;
              }else{
                node.next=current;
                current.prev=node;
                head=node;
              }
            }else if(pos==length){
              current=tail;
              current.next=node;
              node.prev=current;
              tail=node;
            }else{
              while (index++<pos) {
                previous=current;
                current=current.next;
              }
              node.next=current;
              node.prev=previous;
              previous.next=node;
              current.prev=node;
            }
            length++;
            return true;
          }else{
            return false;
          }
        };
        this.removeAt=function(pos){
          if(pos>-1 && pos<length){
            var current=head,previous,index=0;
            if(pos==0){
              head=current.next;
              if(!length===1){
                tail=null;
              }else{
                head.prev=null;
              }
            }else if(pos==length-1){
              current=tail;
              tail=current.prev;
              tail.next=null;
            }else{
              while (index++<pos) {
                previous=current;
                current=current.next;
              }
              previous.next=current.next;
              current.next.prev=current.prev;
            }
            length--;
            return current.element;
          }else{
            return null;
          }
        };
        this.remove=function(element){
          var index=this.indexOf(element);
          return this.removeAt(index);//不太好,重复遍历了2次
        };
        this.indexOf=function (element) {
          var current=head,index=0;
          while (current) {
            if(element===current.element){
              return index;
            }
            index++;
            current=current.next;
          }
          return -1;
        };
        this.isEmpty=function () {
          return length===0;
        };
        this.size=function () {
          return length;
        };
        this.toString=function(){
          var current=head,str=‘‘;
          while (current) {
            str+=","+current.element;
            current=current.next;
          }
          return str.slice(1);
        };
        this.print=function(){
          console.log(this.toString());
        };
        this.getHead=function(){
          return head;
        }
}

  

时间: 2024-10-24 10:39:10

Javascript中的链表的相关文章

javascript中的链表结构

1.定义 很多编程语言中数组的长度是固定的,就是定义数组的时候需要定义数组的长度,所以当数组已经被数据填满的时候,需要再加入新的元素就很困难.只能说在部分变成语言中会有这种情况,在javascript中和php中数组的长度是可以任意增加的.在数组中添加和删除元素也是比较麻烦,因为要将数组中其他元素向前或者向后平移,这个在javascript中也不是问题,javascript中有一个很方便的方法splice()方法很方便的就可以添加或删除元素. 但是凡是都是相对的,javascript中的数组也有

javascript中的链表结构—从链表中删除元素

1.概念 上一个博文我们讲到链表,其中有一个方法remove()是暂时注释的,这个方法有点复杂,需要添加一个Previous()方法找到要删除的元素的前一个节点,这一个博文我们来分析一下这个remove()方法. 从链表中删除节点的时候,需要先找到这个待删除节点的前面的节点.找到这个节点之后修改它的next属性,使其指向待删除节点的下一个节点,这样就把待删除节点给删除了,是不是很简单呢?但是问题来了,我们是不是要找到待删除节点的前面一个节点呢?这样就需要添加一个findPrevious()方法来

javascript中的链表结构—双向链表

1.概念 上一个文章里我们已经了解到链表结构,链表的特点是长度不固定,不用担心插入新元素的时候新增位置的问题.插入一个元素的时候,只要找到插入点就可以了,不需要整体移动整个结构. 这里我们了解一下双向链表的结构.尽管从链表中头节点遍历到尾节点很容易,但是反过来,从后向前遍历就没有那么简单.通过给Node对象增加一个属性,该属性存储指向前驱节点的链接,这样就容易多了.此时祥链表中插入一个节点需要更多的工作,我们需要指出该节点正确的前驱和猴急.但是在从链表中删除节点的时候效率更高了,不需要再查找待删

javascript中在链表中向前(向后)移动n个节点

/** * 实现在链表中向前移动n个节点和向后移动n个节点 * * */ //链表节点 function Node(element){ this.element = element; this.next = null; this.previous = null; } //链表 function LList(){ this.head = new Node('head'); this.find = find; this.insert = insert; this.display = display;

Javascript 中的回调函数和递归函数简单实际分析学习

Javascript 中的回调函数和递归函数简单实际分析学习 1 回调函数 所谓回调函数简单理解就是将一个函数做为参数传递给其他的函数供其使用.(只是在js中,因为其它的语言中有指针这个概念). 举一个简单的例子,当我们在统计账单的时候就要整理材料这些,然后就需要计算器,计算器我们想象成为一个可以实现计算的函数.统计账单是另外的另一个函数,当统计账单的时候就会需要计算器这个函数的支持,其实这就是一个简单的回调.可以按这个理解. 下来我借用网上的一个例子: //先定义一个函数fun1 functi

JavaScript中的继承与原型链

先看一个例子 function User(){} var u1 = new User(); console.log(u1.prototype);// undefined 使用对象实例无法访问到prototype console.log(User.prototype);//{},使用构造函数名访问prototype console.log(u1.__proto__);//{},使用对象实例访问prototype的指针 这个是 __proto__ 和prototype最基本的区别:说明构造的对象无p

JavaScript实现单向链表

JavaScript 本身提供了十分好用的数据类型,以满足大家的日常使用.单靠 Array  和 Object 也的确足够应付日常的绝大部分需求,这也导致了很多前端er对数据结构这一块不是十分的了解. 数据结构是 CS 的必修科目,前端这个圈子非科班的童鞋比例较高,相信很多人对数据结构的了解并不多.虽然本人大学读的也是 CS,但那时候上课基本都在睡觉,数据结构也是学得一塌糊涂,现在也基本上全忘了. 那下面我们来了解一下,如何用 JavaScript 来实现一个 单向链表 . 维基百科中,对链表的

JavaScript中的内存泄漏以及如何处理

随着现在的编程语言功能越来越成熟.复杂,内存管理也容易被大家忽略.本文将会讨论JavaScript中的内存泄漏以及如何处理,方便大家在使用JavaScript编码时,更好的应对内存泄漏带来的问题. 概述 像C语言这样的编程语言,具有简单的内存管理功能函数,例如malloc( )和free( ).开发人员可以使用这些功能函数来显式地分配和释放系统的内存. 当创建对象和字符串等时,JavaScript就会分配内存,并在不再使用时自动释放内存,这种机制被称为垃圾收集.这种释放资源看似是"自动"

简单说说Javascript中的作用域链

    Javascript中作用域就是变量与函数的可访问范围,即作用域控制着变量与函数的可见性和生命周期.变量的作用域有全局作用域和局部作用域两种.当查找变量的时候,会先从当前上下文的变量对象中查找,如果没有找到,就会从父级执行上下文的变量对象中查找,一直找到全局上下文的变量对象,也就是全局对象.这样由多个执行上下文的变量对象构成的链表就叫做作用域链. 看几个题目: A : 1 var a = 1 2 function fn1(){ 3 function fn2(){ 4 console.lo