1. // 无序数组
    2.     class List {
    3.       // 1.创建空的数组 指定size
    4.       constructor() {
    5.         this.arr = new Array(10);
    6.         this.size = 10;
    7.         this.length = 0;
    8.         this.realloc = () => {
    9.           let new_arr = null;
    10.           // 扩大
    11.           if(this.length === this.size) {
    12.             // 增加空间 原来数据拷贝到新数据
    13.             this.size = this.size*2;
    14.             new_arr = new Array(this.size);
    15.           } else if(this.length < (this.size/4)) {
    16.             // 判断是否需要缩小
    17.             this.size = Math.floor(this.size/2);
    18.             new_arr = new Array(this.size);
    19.           }
    20.           if(new_arr) {
    21.             for(let i = 0; i < this.length; i++){
    22.               new_arr[i] = this.arr[i]
    23.             }
    24.             delete this.arr;
    25.             this.arr = new_arr;
    26.           }
    27.         };
    28.         this.checkRange= (index) => {
    29.           if(typeof index !== 'number' || index < 0 || index >= this.length) {
    30.             throw new RangeError();
    31.           }
    32.         }
    33.       }
    35.       getItem(index){
    36.         this.checkRange(index);
    37.         return this.arr[index];
    38.       }
    40.       setItem(index, value) {
    41.         this.checkRange(index);
    42.         return this.arr[index] = value;
    43.       }
    44.       // 添加
    45.       append(value){
    46.         this.arr[this.length] = value;
    47.         this.length++;
    48.         // 如果超出 扩展空间
    49.         this.realloc();
    50.       }
    52.       // 插入
    53.       insert(value, pointIndex) {
    54.         if(pointIndex < 0 || pointIndex > this.length) {
    55.           throw new RangeError();
    56.         } else if (pointIndex === this.length) {
    57.           append(value);
    58.         } else {
    59.           // 1.index的数据都向后移动一位
    60.           for(let j = this.length; j > pointIndex; j --) {
    61.             this.arr[j] = this.arr[j-1];
    62.           }
    63.           // 2.新的数据放到 index 位置上
    64.           this.arr[pointIndex] = value;
    65.           this.length++;
    66.           // 如果超出 扩展空间
    67.           this.realloc();
    68.         }
    69.       }
    71.       // 删除某一项
    72.       delete(index) {
    73.         this.checkRange(index);
    74.         // 1.index的数据都向前移动一位
    75.         for(let j = index; j < this.length -1; j ++) {
    76.           this.arr[j] = this.arr[j+1];
    77.         }
    78.         this.length--;
    79.         this.realloc();
    80.       }
    82.       // 有序的数组 二分法查找 适用于搜索性能更高
    83.       search(value) {
    84.         let s = 0;
    85.         let e = this.arr.length - 1;
    87.         while(s <= e) {
    88.           let center = Math.floor((s+e)/2);
    89.           if(value === this.arr[center]) {
    90.             return center;
    91.           } else if(value < this.arr[center]) {
    92.             e = center - 1;
    93.           } else {
    94.             s = center + 1;
    95.           }
    96.         }
    97.         return -1;
    98.       }
    100.     }
    102.     // 有序数组 先继承无序数组的属性和方法
    103.     class OrderList extends List{
    104.       constructor() {
    105.         // 继承父级
    106.         super();
    107.         this.adjusted = (index) => {
    108.           // 调整顺序
    109.           // 往前调整 我比前面小
    110.           if(index > 0 && this.arr[index] < this.arr[index-1]){
    111.             for (let i = index; i > 0; i --) {
    112.               if(this.arr[i] < this.arr[i-1]) {
    113.                 let temp = this.arr[i-1];
    114.                 this.arr[i-1] = this.arr[i];
    115.                 this.arr[i] = temp;
    116.               } else {
    117.                 break;
    118.               } 
    119.             }
    120.           } else if(index < (this.length - 1) &&  this.arr[index] > this.arr[index+1]) {
    121.             // 往后调整 我比后面的大
    122.             for (let i = index; i < (this.length - 1); i ++) {
    123.               if(this.arr[i] > this.arr[i+1]) {
    124.                 let temp = this.arr[i+1];
    125.                 this.arr[i+1] = this.arr[i];
    126.                 this.arr[i] = temp;
    127.               } else {
    128.                 break;
    129.               } 
    130.             }
    131.           }
    132.         }
    133.       }
    135.       setItem(index, value) {
    136.         // 先调用父级方法 然后在调用自己的方法
    137.         super.setItem(index, value);
    138.         this.adjusted(index);
    139.       }
    141.       append(value){
    142.         // 先调用父级方法 然后在调用自己的方法
    143.         super.append(value);
    144.         this.adjusted(this.length -1);
    145.       }
    147.       insert(value, index){
    148.         // 先调用父级方法 然后在调用自己的方法
    149.         super.insert(value, index);
    150.         this.adjusted(index);
    151.       }
    152.     }
    154.     const list = new OrderList();
    155.     list.append(1);
    156.     list.append(9);
    157.     list.append(5);
    158.     list.append(2);
    159.     list.append(4);
    160.     list.insert(2, 1);
    161.     console.log(list);