js数组操作

function Stack() {
    //存储元素数组
    var aElement = new Array();
    /*
    * @brief: 元素入栈
    * @param: 入栈元素列表
    * @return: 堆栈元素个数
    * @remark: 1.Push方法参数可以多个
    *    2.参数为空时返回-1
    */
    Stack.prototype.Push = function (vElement) {
        if (arguments.length == 0)
            return -1;
        //元素入栈
        for (var i = 0; i < arguments.length; i++) {
            aElement.push(arguments[i]);
        }
        return aElement.length;
    }
    /*
    * @brief: 元素出栈
    * @return: vElement
    * @remark: 当堆栈元素为空时,返回null
    */
    Stack.prototype.Pop = function () {
        if (aElement.length == 0)
            return null;
        else
            return aElement.pop();
    }
    /*
    * @brief: 获取堆栈元素个数
    * @return: 元素个数
    */
    Stack.prototype.GetSize = function () {
        return aElement.length;
    }
    /*
    * @brief: 返回栈顶元素值
    * @return: vElement
    * @remark: 若堆栈为空则返回null
    */
    Stack.prototype.GetTop = function () {
        if (aElement.length == 0)
            return null;
        else
            return aElement[aElement.length - 1];
    }
    /*
    * @brief: 将堆栈置空
    */
    Stack.prototype.MakeEmpty = function () {
        aElement.length = 0;
    }
    /*
    * @brief: 判断堆栈是否为空
    * @return: 堆栈为空返回true,否则返回false
    */
    Stack.prototype.IsEmpty = function () {
        if (aElement.length == 0)
            return true;
        else
            return false;
    }
    /*
    * @brief: 将堆栈元素转化为字符串
    * @return: 堆栈元素字符串
    */
    Stack.prototype.toString = function () {
        var sResult = (aElement.reverse()).toString();
        aElement.reverse()
        return sResult;
    }
}

function Queue() {
    //存储元素数组
    var aElement = new Array();
    /*
    * @brief: 元素入队
    * @param: vElement元素列表
    * @return: 返回当前队列元素个数
    * @remark: 1.EnQueue方法参数可以多个
    *    2.参数为空时返回-1
    */
    Queue.prototype.EnQueue = function (vElement) {
        if (arguments.length == 0)
            return -1;
        //元素入队
        for (var i = 0; i < arguments.length; i++) {
            aElement.push(arguments[i]);
        }
        return aElement.length;
    }
    /*
    * @brief: 元素出队
    * @return: vElement
    * @remark: 当队列元素为空时,返回null
    */
    Queue.prototype.DeQueue = function () {
        if (aElement.length == 0)
            return null;
        else
            return aElement.shift();

    }
    /*
    * @brief: 获取队列元素个数
    * @return: 元素个数
    */
    Queue.prototype.GetSize = function () {
        return aElement.length;
    }
    /*
    * @brief: 返回队头素值
    * @return: vElement
    * @remark: 若队列为空则返回null
    */
    Queue.prototype.GetHead = function () {
        if (aElement.length == 0)
            return null;
        else
            return aElement[0];
    }
    /*
    * @brief: 返回队尾素值
    * @return: vElement
    * @remark: 若队列为空则返回null
    */
    Queue.prototype.GetEnd = function () {
        if (aElement.length == 0)
            return null;
        else
            return aElement[aElement.length - 1];
    }
    /*
    * @brief: 将队列置空
    */
    Queue.prototype.MakeEmpty = function () {
        aElement.length = 0;
    }
    /*
    * @brief: 判断队列是否为空
    * @return: 队列为空返回true,否则返回false
    */
    Queue.prototype.IsEmpty = function () {
        if (aElement.length == 0)
            return true;
        else
            return false;
    }
    /*
    * @brief: 将队列元素转化为字符串
    * @return: 队列元素字符串
    */
    Queue.prototype.toString = function () {
        var sResult = (aElement.reverse()).toString();
        aElement.reverse()
        return sResult;
    }
}

function List() {
    //存储元素数组
    var aElement = new Array();

    //列表的大小  
    List.prototype.size = function () {
        return aElement.length;
    }
    //向列表添加一个元素  
    List.prototype.add = function (element) {
        aElement.push(element);
    }
    //批量添加元素到列表  
    List.prototype.addAll = function (list) {
        if (list && isList(list)) {
            var size = list.size();
            var element;
            for (var i = 0; i < size; i++) {
                element = list.get(i);
                aElement.push(element);
            }
        }
    }
    //转化成数组  
    List.prototype.toArray = function () {
        return aElement;
    }
    //移除数组（根据下标）  
    List.prototype.remove = function (index) {
        if (index >= this.size()) {
            index = this.size() - 1;
        }
        aElement.splice(index, 1);
    }
    List.prototype.get = function (index) {
        return aElement[index];
    }
    //清除列表原色  
    List.prototype.clear = function () {
        array = new Array();
    }
    //是否为空列表  
    List.prototype.isEmpty = function () {
        return this.size() === 0;
    }
    //是否包含某个元素  
    List.prototype.contains = function (element) {
        return this.indexOf(element) >= 0;
    }
    //判断列表的某个元素的第一个元素在列表的下标位置  
    //-1则表示没有这个元素  
    List.prototype.indexOf = function (element) {
        var size = this.size();
        if (null === element) {
            for (var i = 0; i < size; i++) {
                if (aElement[i] === null) {
                    return i;
                }
            }
        } else {
            for (var i = 0; i < size; i++) {
                if (aElement[i] === element) {
                    return i;
                }
            }
        }
        return -1;
    }
    var isList = function (list) {
        return list instanceof List;
    }
}

function StringBuilder() {
    //存储元素数组
    var aElement = new Array();

    //追加数据到StringBuilder类
    StringBuilder.prototype.append = function (element) {
        aElement.push(element);
    }
    //转换成String
    StringBuilder.prototype.toString = function () {
        return aElement.join("");
    }
}

function Map() {
    //初始化map集合
    var aElement = new Array();
    var _size = 0;
    var _keySet = new Array();

    //map的大小
    Map.prototype.size = function () {
        return this._size;
    }
    //将数据放入map中
    Map.prototype.put = function (key, value) {
        if (!this.containsKey(key)) {
            aElement[key] = value;
            this._size++;
        }
    }
    //根据key获得map的其中一个value
    Map.prototype.get = function (key) {
        return aElement[key];
    }
    //map是否为空集合
    Map.prototype.isEmpty = function () {
        return this._size === 0;
    }
    //map集合是否包含key
    Map.prototype.containsKey = function (key) {
        return aElement[key] !== undefined ? true : false;
    }
    //移除指定的key
    Map.prototype.remove = function (key) {
        if (this.containsKey(key)) {
            delete aElement[key];
            this._size--;
        }
    }
    //移除所有集合
    Map.prototype.clear = function () {
        //初始化map集合
        aElement = new Array();
        this._size = 0;
        this._keySet = new Array();
    }
    //map集合转化成Array
    Map.prototype.toArray = function () {
        return aElement;
    }
}