javascript实现数据结构：串--定长顺序存储表示以及kmp算法实现

串（string）（或字符串）是由零个或多个字符组成的有限序列。串中字符的数目称为串的长度。零个字符的串称为空串（null string），它的长度为零。

串中任意个连续的字符组成的子序列称为该串的子串。包含子串的串相应地称为主串。通常称字符在序列中的序号为该字符在串中的位置。子串在主串中的位置则以子串的第一个字符在主串中的位置来表示。

只有当两个串的长度相等，并且各个对应位置的字符都相等时才相等。

串有3种机内表示方法：
* 1.定长顺序存储表示
* 2.堆分配存储表示
* 3.串的块链存储表示

定长顺序存储表示：

类似于线性表的顺序存储结构，用一组地址连续的存储单元存储串值得字符序列。在串的定长顺序存储结构中，按照预定义的大小，为每个定义的串变量分配一个固定长度的存储区，则可用定长数组来描述。

以下标为0的数组分量存放串的实际长度：

结构图：

实现：

 function SString() {
         this.MAXSTRLEN = 10;
     }

     exports.SString = SString;
     SString.prototype = {
         constructor: SString,
         // 返回由s1和s2连接而成的新串
         concat: function (s2) {
             var t = new SString();
             // 未截断
             if (this[0] + s2[0] <= this.MAXSTRLEN) {
                 copyStr2T(this);
                 copyStr2T(s2, this[0]);
                 t[0] = this[0] + s2[0];

                 // 截断
             } else if (this[0] < this.MAXSTRLEN) {
                 copyStr2T(this);
                 copyStr2T(s2, this[0], this.MAXSTRLEN - this[0]);
                 t[0] = this.MAXSTRLEN;

                 // 截断（仅取s1）
             } else {
                 copyStr2T(this, 0, this.MAXSTRLEN);
                 t[0] = this[0] = this.MAXSTRLEN;
             }

             return t;

             function copyStr2T(str, start, end) {
                 start = start || 0;
                 for (var i = 1, len = end || str[0]; i <= len; i++) {
                     t[start + i] = str[i];
                 }
             }
         },
         substring: function (position, len) {
             position = ~~position || 0;
             len = ~~len || this[0];
             if (position < 0 || position > this[0] - 1 || len < 0 || len > this[0] - position)
                 throw new Error('unexpected parameter');

             var sub = new SString();
             for (var i = 1; i <= len; i++) {
                 sub[i] = this[position + i - 1];
             }
             sub[0] = len;

             return sub;
         },
         toString: function () {
             var str = '';
             for (var i = 1; this[i]; i++) {
                 str += this[i];
             }
             return str;
         },
         // 返回子串sstring在主串中的第position个字符之后的位置
         index: function (sstring, position) {
             var i = position || 0;
             var j = 1;

             while (i <= this[0] && j <= sstring[0]) {
                 if (this[i] === sstring[j]) {
                     i++;
                     j++;
                 } else {
                     i = i - j + 2;
                     j = 1;
                 }
             }

             return j > sstring[0] ? i - sstring[0] : -1;
         },
         kmpIndex: function (sstring, position) {
             var i = position || 0;
             var j = 1;
             var next = getNext(sstring);

             while (i <= this[0] && j <= sstring[0]) {
                 if (j === 0 || this[i] === sstring[j]) {
                     ++i;
                     ++j;
                 } else {
                     j = next[j];
                 }
             }

             return j > sstring[0] ? i - sstring[0] : -1;
         }
     };

     function getNext(sstring) {
         var i = 1;
         var next = {1: 0};
         var j = 0;

         while (i < sstring[0]) {
             if (j === 0 || sstring[i] === sstring[j]) {
                 if(sstring[++i] !== sstring[++j]){
                     next[i] = j;
                 } else {
                     next[i] = next[j];
                 }
 //                next[++i] = ++j;
             } else {
                 j = next[j];
             }
         }

         return next;
     }

     var a = new SString();
     var b = new SString();
     for (var i = 0; i < 4; i++) {
         a[i + 1] = i + '';
         b[i + 1] = i + '';
     }
     a[0] = b[0] = 4;
     var t = a.concat(b);
     console.log(t + '');       //

     var d = new SString();
     var str = 'acabaabaabcacaabc';
     for(i = 0; i < str.length; i++){
         d[i + 1] = str[i];
     }
     d[0] = str.length;

     var c = new SString();
     str = 'abaabc';
     for(i = 0; i < str.length; i++){
         c[i + 1] = str[i];
     }
     c[0] = str.length;

     console.log(d.index(c));
     console.log(d.kmpIndex(c));

单元测试代码：

 describe('SString tests', function(){
   var a = new SString();
   var b = new SString();

   it('should concat without break strings', function(){
     for(var i = 0; i < 4; i++){
       a[i + 1] = i + '';
       b[i + 1] = i + '';
     }
     a[0] = b[0] = 4;

     var t = a.concat(b);
     console.log(a);
     console.log(b);
     expect(t[0]).toBe(8);
     expect(t + '').toBe('01230123');
   });

   it('should break strings of b', function(){
     for(var i = 0; i < 7; i++){
       b[i + 1] = i + '';
     }
     b[0] = 7;

     var t = a.concat(b);
     console.log(a);
     console.log(b);
     expect(t[0]).toBe(10);
     expect(t + '').toBe('0123012345');
   });

   it('should break strings of a', function(){
     for(var i = 4; i < 10; i++){
       a[i + 1] = i + '';
     }
     a[0] = 10;

     var t = a.concat(b);
     console.log(a);
     console.log(b);
     expect(t[0]).toBe(10);
     expect(t + '').toBe('0123456789');
   });

   it('should get substring', function(){
     console.log(a);
     var t = a.substring(1, 10);
     expect(t + '').toBe('0123456789');

     t = a.substring(3, 5);
     expect(t + '').toBe('23456');
   });
 });

在顺序存储结构中，实现串操作的原操作为“字符串序列的复制”，操作时间复杂度基于复制的字符串序列的长度。
另一操作特点是，如果在操作中出现串值序列的长度超过MAXSTRLEN时，约定用截尾法处理，这种情况不仅在求连接串时可能发生，在串的其他操作中，如插入，置换等也可能发生，克服这个弊病唯有不限定串长的最大长度，即动态分配串值的存储空间。