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(position, element){
        if (position >=0 && position <=length){
            var node = new Node(element),
                current = head,
                previous,
                index =0;
            if (position === 0){
                node.next = current;
                head = node;
            } else {
                while (index++ < position){
                    previous = current;
                    current = current.next;
                }
                node.next = current;
                previous.next = node;
            }
            length++;
            return true;
        } else {
            return false;
        }
    };

    this.removeAt = function(position){
        if (position > -1 && position < length){
            var current = head,
                previous,
                index = 0;
            if (position === 0){
                head = current.next;
            } else {
                while (index++ < position){
                    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);
    };

    this.indexOf = function(element){
        var current = head,
            index = -1;
        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,
            string = ‘‘;
        while (current){
            string += current.element;
            current = current.next;
        }
        return string;
    };

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

    this.print = function(){

    };
}

var list = new LinkedList();
list.append(15);
list.append(10);
console.log(list.toString());

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.insert = function(position, element){
        if(position >=0 && position <= length){
            var node = new Node(element),
                current = head,
                previous,
                index = 0;

            if (position === 0){
                if (!head){
                    head = node;
                    tail = node;
                } else {
                    node.next = current;
                    current.prev = node;
                    head = node;
                }
            } else if (position === length){
                current = tail;
                current.next = node;
                node.prev = current;
                tail = node;
            } else {
                while (index++ < position){
                    previous = current;
                    current = current.next;
                }
                node.next = current;
                previous.next = node;

                current.prev = node;
                node.prev = previous;
            }
            length++;
            return true;
        } else {
            return false;
        }
    }

    this.removeAt = function(position){
        if (position > -1 && position < length){
            var current = head,
                previous,
                index = 0;

            if (position === 0){
                head = current.next;
                if (length === 1){
                    tail = null;
                } else {
                    head.prev = null;
                }
            } else if(position == length-1){
                current = tail;
                tail = current.prev;
                tail.next = null;
            } else {
                while (index++ < position){
                    previous = current;
                    current = current.next;
                }
                previous.next = current.next;
                current.next.prev = previous;
            }
            length--;
            return current.element;
        } else {
            return null;
        }
    }
}

时间: 2024-10-12 12:10:38

javascript普通链表及双向链表的相关文章

数据结构与算法JavaScript (三) 链表

数据结构与算法JavaScript (三) 链表 我们可以看到在javascript概念中的队列与栈都是一种特殊的线性表的结构,也是一种比较简单的基于数组的顺序存储结构.由于 javascript的解释器针对数组都做了直接的优化,不会存在在很多编程语言中数组固定长度的问题(当数组填满后再添加就比较困难了,包括添加删除, 都是需要把数组中所有的元素全部都变换位置的,javascript的的数组确实直接给优化好了,如 push,pop,shift,unshift,split方法等等…) 线性表的顺序

线性链表的双向链表——java实现

.线性表链式存储结构:将采用一组地址的任意的存储单元存放线性表中的数据元素. 链表又可分为: 单链表:每个节点只保留一个引用,该引用指向当前节点的下一个节点,没有引用指向头结点,尾节点的next引用为null. 循环链表:一种首尾相连的链表. 双向链表:每个节点有两个引用,一个指向当前节点的上一个节点,另外一个指向当前节点的下一个节点. 下面给出线性表双向链表的实现:java中LinkedList是线性表的链式实现,是一个双向链表. import java.util.NoSuchElementE

[算法]反转单向链表和双向链表

题目: 分别实现反转单向链表和双向链表的函数. 要求: 如果链表长度为N,时间复杂度为O(N),额外空间复杂度要求为O(1). 程序: 反转单向链表: public class Node{ public Node(int data){ this.value=data; } public int value; public Node next; } public static Node reverseList(Node node){ Node pre=null; Node next=null; w

栈,队列,单链表,双向链表

1. 定义头文件 实现栈方法的定义,注意这里用到了全局的静态数组,可以通过这种方式保护数据. main.c,实现存储 队列,创建头文件queue.h 创建queue.c 实现main函数 单链表 在定义头文件的时候,最好使用: #ifndef 变量A #define变量A 函数声明和结构声明等声明 #endif 通过上面的这种方式可以避免重复调用头文件时候产生的负面影响. 定义头文件link.h:(注意加上extern) 定义link.c 编写main.c 4.双向链表 创建link.h头文件

单向链表和双向链表的原理及其相关实现

(一)什么是链表? 链表是线性表的一种,所谓的 线性表包含顺序线性表和链表,顺序线性表是用数组实现的,在内存中有顺序排列,通过改变数组大小实现.而链表不是用顺序实现的,用指针实现,在内存中不连 续.意思就是说,链表就是将一系列不连续的内存联系起来,将那种碎片内存进行合理的利用,解决空间的问题. 所以,链表允许插入和删除表上任意位置上的节点,但是不允许随即存取.链表有很多种不同的类型:单向链表.双向链表及循环链表. 1.那么先从单向链表着手,先看看单向链表的模拟图: 单向链表包含两个域,一个是信息

【 C# 数据结构】(一) -------------------------- 泛型带头节点的单链表,双向链表实现

在编程领域,数据结构与算法向来都是提升编程能力的重点.而一般常见的数据结构是链表,栈,队列,树等.事实上C#也已经封装好了这些数据结构,在头文件 System.Collections.Generic 中,直接创建并调用其成员方法就行.不过我们学习当然要知其然,亦知其所以然. 本文实现的是链表中的单链表和双向链表,并且实现了一些基本方法 一. 定义一个链表接口 MyList 接口里声明了我们要实现的方法: interface MyList<T> { int GetLength(); //获取链表

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

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

JavaScript数据结构——链表的实现

前面楼主分别讨论了数据结构栈与队列的实现,当时所用的数据结构都是用的数组来进行实现,但是数组有的时候并不是最佳的数据结构,比如在数组中新增删除元素的时候需要将其他元素进行移动,而在javascript中使用spit()方法不需要访问其他元素.如果你在使用数组的时候发现很慢,就可以考虑使用链表. 链表的概念 链表是一种常见的数据结构.它是动态地进行存储分配的一种结构.链表有一个"头指针"变量,以head表示,它存放一个地址,指向一个元素.每个结点都使用一个对象的引用指标它的后继,指向另一

JavaScript数据结构——链表

链表:存储有序的元素集合,但不同于数组,链表中的元素在内存中不是连续放置的.每个元素由一个存储元素本身的节点和一个指向下一个元素的引用(也称指针或链接)组成. 好处:可以添加或移除任意项,它会按需扩容,且不需要移动其他元素. 与数组的区别: 数组:可以直接访问任何位置的任何元素: 链表:想要访问链表中的一个元素,需要从起点(表头)开始迭代列表直到找到所需的元素. 现实案例:康佳舞队.寻宝游戏 单向链表:一个节点只有链向下一个节点的链接: 双向链表:链接是双向的,一个链向下一个元素,另一个链向前一