javascript实现数据结构与算法系列：线性表的静态单链表存储结构

有时可借用一维数组来描述线性链表，这就是线性表的静态单链表存储结构。

在静态链表中，数组的一个分量表示一个结点，同时用游标（cur）代替指针指示结点在数组中的相对位置。
数组的第0分量可看成头结点，其指针域指示链表的第一个结点。
这种存储结构需要预先分配一个较大的空间，但在线性表的插入和删除操作时不需移动元素，
仅需要修改指针，故仍具有李安是存储结构的主要优点

 

结构图：

 

静态单链表的实现：

(function(module){
  function SLinkList(data, cur, MAXSIZE) {
    this[0] = {};
    this[0].data = data;
    this[0].cur = cur;
    this.MAXSIZE = MAXSIZE || 1000;
  }
  module.exports = SLinkList;
  SLinkList.prototype = {
    /**
     * 在静态单链线性表L中查找第1个值为e的元素，
     * 若找到，则返回它在L中的位序
     * @param data
     */
    locateElem: function (data) {
      var i = this[0].cur;
      while (i && this[i].data !== data) {
        i = this[i].cur;
      }
      return i;
    },
    /**
     * 将一维数组中各分量链成一个备用链表
     * this[0].cur为头指针
     */
    initSpace: function () {
      for (var i = 0; i < this.MAXSIZE - 1; ++i) {
        this[i] = this[i] || {};
        this[i].cur = i + 1;
      }

      this[this.MAXSIZE - 1] = this[this.MAXSIZE - 1] || {};
      this[this.MAXSIZE - 1].cur = 0;
    },
    /**
     * 若备用链表非空，则返回分配的结点下标，反则返回0
     * @returns {*}
     */
    malloc: function () {
      var i = this[0].cur;
      if (this[0].cur) this[0].cur = this[i].cur;
      return i;
    },
    /**
     * 将下标为k的空闲结点回收到备用链表
     * @param k
     */
    free: function (k) {
      this[k].cur = this[0].cur;
      this[0].cur = k;
    },
    /**
     * 在一维数组中建立表示集合(A-B)U(B-A)
     * 的静态链表，s为其头指针。
     * @returns {*}
     */
    difference: function (arr1, arr2) {
      // 初始化备用空间
      this.initSpace();
      // 生成s的头结点
      var s = this.malloc();
      // r指向s的当前最后结点
      var r = s;
      // 删除A和B的元素个数
      var m = arr1.length;
      var n = arr2.length;

      // 建立集合A的链表
      for (var j = 0; j < m; ++j) {
        //分配结点
        var i = this.malloc();
        // 输入A元素的值
        this[i].data = arr1[j];
        // 插入到表尾
        this[r].cur = i;
        r = i;
      }
      // 尾结点的指针为空
      this[r].cur = 0;

      // 依次输入B的元素，若不在当前表中，则插入，
      // 否则删除
      for (j = 0; j < n; ++j) {
        var b = arr2[j];
        var p = s;
        // k指向集合中的第一个结点
        var k = this[s].cur;
        // 在当前表中查找
        while (k !== this[r].cur && this[k].data !== b) {
          p = k;
          k = this[k].cur;
        }
        // 当前表中不存在该元素，插入在r所指结点之后，且r的位置不变
        if (k === this[r].cur) {
          i = this.malloc();
          this[i].data = b;
          this[i].cur = this[r].cur;
          this[r].cur = i;

          // 该元素已在表中，删除之
        } else {
          this[p].cur = this[k].cur;
          this.free(k);
          // 若删除的是r所指结点，则需修改尾指针
          if (r === k) r = p;
        }
      }
    }
  };

  var sl = new SLinkList(1, 0, 10);
  var ret = sl.difference([1, 2, 3], [3, 4, 5]);
  console.log(sl);
})(this.module|| this);