前端学算法（二）：线性表

线性表（List），是一种非常常见的数据结构，可以分为两种，一般线性表和受限线性表。一般线性表可以对节点自由地进行增删查改；而受限线性表，则只能在一定的限制下对节点进行操作，例如栈、队列等。

作为一名前端自然就用JavaScript了。

要实现线性表，要解决三个问题，采用什么样的方式存储数据，实现哪些操作数据的方法，又怎么样实现操作数据的方法。

至于存储方式，就采用数组。

线性表操作数据的方法：

1、返回List长度

2、清空List

3、判断List是否存在某个元素

4、返回当前元素

5、在某元素后，插入一个元素

6、在List末尾添加一个元素

7、删除List的某个元素

8、返回List的当前指针

9、将指针移到List首

10、将指针移到List末

11、将指针前移一位

12、将指针后移一位

13、将指针移到指定位置

14、将所有元素以字符串的形式输出

15、遍历输出所有元素

16、返回一个排序好的数组（快速排序）

具体实现：

1、声明List的构造函数，初始化List的长度，指针，储存数据的数组。

function List() {
  this.listSize = 0;
  this.pos = 0;
  this.dataStore = [];
};

2、返回List长度。

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

既然，List有listSize属性为什么又要一个获取List长度的length()方法呢？为了实现封装，将listSize设为私有变量。

3、实现清空表的clear方法。

this.clear = function() {
  delete this.dataStore;
  this.dataStore = [];
  this.listSize = 0;
};

清空表，不仅仅是将this.dataStore赋予一个空数组，和将this.listSize归0，最好将原来的this.dataStore delete掉。因为这样能增加算法性能，虽然不多，但可以优化的，还是要优化。

4、实现查找某个元素，存在则返回位置，不存在则返回-1

this.find = function ( element ){
  for (var i = 0; i < this.dataStore.length; i++) {
    if ( this.dataStore[i] === element ) {
      return i;
    };
  };
  return -1;
};

5、实现判断是否存在某个元素的方法。

this.contains = function ( element ) {
  var isContains = this.find(element);
  return isContains > -1 ? true : false;
};

6、实现返回当前元素的方法。

this.getElement = function () {
  return this.dataStore[this.pos];
};

7、在某元素后，插入一个元素。

this.insert = function ( element, after ) {
  var insertPos = this.find(after);
  if ( insertPos > -1 ) {
    this.dataStore.splice(insertPos+1, 0, element);
    this.listSize += 1;
    return true;
  };
  return false;
};

8、在List末尾添加一个元素。

this.append = function ( element ){
  this.dataStore[this.listSize++] = element;
};

9、删除List的某个元素。

this.remove = function ( element ){
  var foundAt = this.find(element);
  if ( foundAt > -1 ) {
    this.dataStore.splice(foundAt,1);
    this.listSize -= 1;
    return true;
  };
  return false;
};

10、返回List的当前指针。

this.currPos = function () {
  return this.pos;
};

11、将指针移到List首。

this.front = function () {
  this.pos = 0;
};

12、将指针移到List末。

this.end = function () {
  this.pos = this.listSize - 1;
};

13、将指针前移一位。

this.prev = function () {
  if ( this.pos > 0 ) {
    this.pos -= 1;
  };
};

12、将指针后移一位。

this.next = function () {
  if ( this.pos < this.listSize ) {
    this.pos += 1;
  }
};

13、将指针移到指定位置。

this.moveTo = function ( position ) {
  this.pos = position
};

14、将所有元素以字符串的形式输出。

this.toString = function () {
  return this.dataStore.toString()
};

15、遍历输出所有元素。

this.displayList = function () {
  for (list.front(); list.currPos() < list.length(); list.next()) {
    console.log(list.currPos(),list.getElement());
  };
};

16、返回一个排序好的数组（快速排序）。

this.sort = function () {
  var less = [],
      pivotList = [],
      more = [],
      result = [],
      length = this.listSize,
      arr = this.dataStore;
  if (length <= 1) {
    return arr;
  };
  var pivot = arr[0];
  for (var i = 0; i < length; i++) {
    if (arr[i] < pivot) {
      less.push(arr[i]);
    } else if (arr[i] > pivot) {
      more.push(arr[i]);
    } else {
      pivotList.push(arr[i]);
    };
  };
  less = quick(less);
  more = quick(more);
  result = result.concat(less,pivotList,more)
  return result;
};

这里借助了JavaScript数组的方法，实现了快速排序。

完整实现：

#!/usr/bin/node
function List() {
  this.listSize = 0;
  this.pos = 0;
  this.dataStore = [];
  this.clear = function () {
    delete this.dataStore;
    this.dataStore = [];
    this.listSize = this.pos = 0;
  };
  this.find = function ( element ){
    for (var i = 0; i < this.dataStore.length; i++) {
      if ( this.dataStore[i] === element ) {
        return i;
      };
    };
    return -1;
  };
  this.toString = function () {
    return this.dataStore.toString()
  };
  this.insert = function ( element, after ) {
    var insertPos = this.find(after);
    if ( insertPos > -1 ) {
      this.dataStore.splice(insertPos+1, 0, element);
      this.listSize += 1;
      return true;
    };
    return false;
  };
  this.append = function ( element ){
    this.dataStore[this.listSize++] = element;
  };
  this.remove = function ( element ){
    var foundAt = this.find(element);
    if ( foundAt > -1 ) {
      this.dataStore.splice(foundAt,1);
      this.listSize -= 1;
      return true;
    };
    return false;
  };
  this.front = function () {
    this.pos = 0;
  };
  this.end = function () {
    this.pos = this.listSize - 1;
  };
  this.prev = function () {
    if ( this.pos > 0 ) {
      this.pos -= 1;
    };
  };
  this.next = function () {
    if ( this.pos < this.listSize ) {
      this.pos += 1;
    }
  };
  this.currPos = function () {
    return this.pos;
  };
  this.moveTo = function ( position ) {
    this.pos = position
  };
  this.getElement = function () {
    return this.dataStore[this.pos];
  };
  this.length = function () {
    return this.listSize;
  }
  this.contains = function ( element ) {
    var isContains = this.find(element);
    return isContains > -1 ? true : false;
  };
  this.displayList = function () {
    for (list.front(); list.currPos() < list.length(); list.next()) {
      console.log(list.currPos(),list.getElement());
    };
  };
  this.sort = function () {
    var less = [],
        pivotList = [],
        more = [],
        result = [],
        length = this.listSize,
        arr = this.dataStore;
    if (length <= 1) {
      return arr;
    };
    var pivot = arr[0];
    for (var i = 0; i < length; i++) {
      if (arr[i] < pivot) {
        less.push(arr[i]);
      } else if (arr[i] > pivot) {
        more.push(arr[i]);
      } else {
        pivotList.push(arr[i]);
      };
    };
    less = quick(less);
    more = quick(more);
    result = result.concat(less,pivotList,more)
    return result;
  };
};