js实现单向链表

  1. add() 添加元素
  2. clear() 清空链表
  3. contains(data) 是否包含元素
  4. display() 显示链表
  5. get(position) 得到索引位置的元素
  6. isEmpty() 链表是否为空
  7. remove(position) 移除索引位置的元素
  8. reverse() 倒置链表
  9. set(position, data) 向链表指定位置设置修改元素
  10. size() 返回链表的长度
var Node = function (data) {
  this.data = data;
  this.next = null;
};

var LList = function () {
  this.firstNode = null;
  this.lastNode = null;
  this.length = 0;
};

LList.prototype = {
  clear: function () {
    this.firstNode = null;
    this.lastNode = null;
    this.length = 0;
  },

  get: function (position) {
    var currentNode = this.firstNode;
    for (var i = 1; i < position + 1; i++) {
      currentNode = currentNode.next;
    }
    return currentNode;
  },
  isEmpty: function () {
    var result = false;
    if (this.length == 0 && this.firstNode == null) {
      result = true;
    }
    return result;
  },
  add: function () {
    if (arguments.length == 1) {
      data = arguments[0];
      var newNode = new Node(data);
      if (this.isEmpty()) {
        this.firstNode = newNode;
      } else {
        this.lastNode.next = newNode;
      }
      this.lastNode = newNode;
      this.length++;
      return true;
    } else if (arguments.length == 2) {
      var isSuccessful = true;
      var position = arguments[0];
      var data = arguments[1];
      if (position < this.length + 1) {
        var newNode = new Node(data);
        if (this.isEmpty()) {
          this.firstNode = newNode;
          this.lastNode = newNode;
        } else if (position == this.length) {
          this.lastNode.next = newNode;
          this.lastNode = newNode;
        } else if (position == 0) {
          newNode.next = this.firstNode;
          this.firstNode = newNode;
        } else {
          var nodeBefore = this.get(position - 1);
          var nodeAfter = nodeBefore.next;
          newNode.next = nodeAfter;
          nodeBefore.next = newNode;
        }
        this.length++;
      } else {
        isSuccessful = false;
      }
      return isSuccessful;
    }
  },
  display: function () {
    var str = ‘‘;
    var currentNode = this.firstNode;
    while (currentNode != null) {
      str += currentNode.data + ‘, ‘
      currentNode = currentNode.next;
    }
    str = str.substr(0, str.length - 2);
    console.log(str);
  },
  remove: function (position) {
    var result = null;
    if (!this.isEmpty() && (position < this.length)) {
      if (position == 0) {
        result = this.firstNode.data;
        this.firstNode = this.firstNode.next;
        this.lastNode = null;
      } else {
        var nodeBefore = this.get(position - 1);
        var nodeToRemove = nodeBefore.next;
        var nodeAfter = nodeToRemove.next;
        nodeBefore.next = nodeAfter;
        result = nodeToRemove.data;
        if (position == this.length - 1) {
          this.lastNode = nodeBefore;
        }
      }
      this.length--;
    }
    return result;
  },
  set: function (position, data) {
    var isSuccessfule = true;
    if (!this.isEmpty() && (position < this.length)) {
      var desireNode = this.get(position);
      desireNode.data = data;
    } else {
      isSuccessfule = false;
    }
    return isSuccessfule;
  },
  contains: function (data) {
    var found = false;
    var currentNode = this.firstNode;

    while (!found && (currentNode != null)) {
      if (data === currentNode.data) {
        found = true;
      } else {
        currentNode = currentNode.next;
      }
    }
    return found;
  },
  size: function() {
    return this.length;
  },
  reverse: function() {
    var newList = new LList();
    for(var i=this.length-1; i>=0; i--) {
      newList.add(this.get(i).data);
    }
    return newList;
  }
};
时间: 2024-10-12 21:07:38

js实现单向链表的相关文章

原生JS实现单向链表

1.前言 用JS实现一个简单的单向链表,并完成相关的功能 2.功能说明 push(value):从链表尾部添加一个新的节点 insertAfer(value,item):向链表中的item节点之后插入一个 值为value的新节点 remove(value):删除链表中值为value的节点 removeAt(pos):删除链表中第pos个节点 find(value):查找链表中值为value的节点 findPrevious(value):查找链表中值为value的节点的前一个节点 indexof(

数据结构与算法学习-单向链表的实现

链表(Chain本文所说链表均为单向链表,以下均简称单向链表)实际上是由节点(Node)组成的,一个链表拥有不定数量的节点.而向外暴露的只有一个头节点(Head),我们对链表的所有操作,都是直接或者间接地通过其头节点来进行的. 节点(Node)是由一个需要储存的对象及对下一个节点的引用组成的.也就是说,节点拥有两个成员:储存的对象.对下一个节点的引用. 这样说可能大家不是很明白,我贴一张图大家可能更容易理解. package LinkedList; /** * <p><strong>

算法总结之 反转部分单向链表

给定单链表的表头节点head, 以及两个整数from 和 to, 在单向链表上把fro个节点到第to个节点这一部分进行反转 思路: 本题 有可能存在换头的问题,所以函数应该返回调整后的新的头节点 1 判断是否满足 1<=from<=to<=N 如果不满足,直接返回原来的头节点 2 找到第from-1个节点pre和第to+1个节点tPos,fPre即要反转部分的前一个节点,tPos是反转部分的后一个节点,把反转部分先反转,然后正确的链接fPre和tPos package TT; impor

C语言之字符单向链表

/* * @Author: suifengtec * @Date:   2017-09-02 16:06:33 * @Last Modified by:   suifengtec * @Last Modified time: 2017-09-02 20:47:13 **/ /* 字符单向链表 gcc -o a.exe main.c && a  */ #include <stdio.h> #include <stdlib.h> #include <stdbool

C++__单向链表(练习)

单向链表 link.h #ifndef LINK_H_ #define LINK_H_ #define HEADER 0 #define TAIL -1 typedef int data_type; enum LINK_OP { LINK_ERR = -1, LINK_OK }; class LINK { private: data_type data; LINK *next; public: LINK(); LINK(data_type data); virtual ~LINK(); data

单向链表模板

写个单向链表模板练练手: #include <bits/stdc++.h> using namespace std; //create // delete // modify // search class Node{ public: int data; Node* ptr; Node(int elem= 0, Node* node= NULL){ this->data= elem; this->ptr= NULL; } }; class MyList{ private: Node

C#学习单向链表和接口 IList&lt;T&gt;

作者:乌龙哈里 时间:2015-11-04 平台:Window7 64bit,Visual Studio Community 2015 参考: MSDN 索引器(C# 编程指南) <数据结构(C#语言版)>下载 When to use IEnumerable, ICollection, IList and List 章节: 单向链表元素 定义单向链表操作接口 逐步实现单向链表 正文: 前面学习了 IEnumerable<T>.IComparable<T>.ICollec

循环单向链表(约瑟夫环)

#include <stdio.h> #include <stdlib.h> typedef struct List { int data; struct List *next; }List; //创建循环单向链表n为长度 List *list_create(int n) { List *head, *p; int i; head = (List *)malloc(sizeof(List)); p = head; p->data = 1; //创建第一个结点 for (i =

给定单向链表的头指针和一个结点指针,定义一个函数在O(1)时间删除该结点

#include <iostream> #include <string.h> #include <stdlib.h> #include <stack> using namespace std; struct Node { int data; struct Node* next; }; struct Node* create_list(int len) { if (len <= 0) return NULL; struct Node* head; st