JavaScript实现栈与队列的操作

栈

栈是一种非常常见的数据结构，在程序中应用广泛。

我们知道数组是一种线性结构
虽然麻烦，但可以在数组的任意位置插入和删除数据。但为了实现某些功能，必须对这种任意性加以限制，而栈和队列就是比较常见的受限的线性结构

栈(stack) ，它是一种受限的线性表， 后进先出(LIFO last in first out)。
限制:仅在表的一端进行插入和删除运算，这一端被称为栈顶， 相对地另一端称为栈底。
向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素。
从一个栈删除元素又称作出栈或退栈，它就是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈的实现：

• ES5写法

function Stack() {
    //用数组模拟栈
    var stack = [];

    //入栈
    this.push = function (element) {
        stack.push(element);
    }

    //出栈
    this.pop = function () {
        stack.pop();
    }

    //查看栈顶元素
    this.peek = function () {
        return stack[stack.length-1];
    }

    //判断栈是否为空
    this.isAmpty = function () {
        return stack.length === 0;
    }

    //返回栈的长度
    this.size = function () {
        return stack.length;
    }

    //清空栈中所有内容
    this.clear = function () {
        stack = [];
    }

    //以字符串显示栈中所有内容
    this.print = function () {
        return stack.toString();
    }
}

• ES6写法

class Stack {
    //构造函数
    constructor() {
        //用数组模拟栈
        this.stack = [];
    }

    //入栈
    push(element) {
        this.stack.push(element);
    }

    //出栈 返回栈顶元素
    pop() {
        return this.stack.pop();
    }

    //返回栈顶元素
    peek() {
        return this.stack[this.stack.length-1];
    }

    //判断栈是否为空
    isAmpty() {
        return this.stack.length === 0;
    }

    //清空栈
    clear() {
        this.stack = [];
    }

    //返回栈的长度
    size() {
        return this.stack.length;
    }

    //以字符串显示栈中的内容
    print() {
        return this.stack.toString();
    }
}

例子：

//十进制转化为二进制
var dtob = function(number) {
    //定义一个栈
    var stack = []

    //转化为二进制
    while(number > 0) {
        stack.push(number%2)
        number = Math.floor(number/2)
    }

    //输出
    var s = ''
    while(stack.length !== 0) {
        s += stack.pop()
    }
    return s
}

console.log(dtob(100)) //1100100

队列

队列(Queue)，它是一种受限的线性表，先进先出(FIFO First In First Out)。
受限之处在于它只允许在表的前端( front )进行删除操作，而在表的后端( rear )进行插入操作。

队列的实现：

• ES5写法

function Queue() {
    var queue = [];

    //入队列
    var enqueue = function (element) {
        queue.push(element);
    }

    //出队列
    var dequeue = function () {
        return queue.shift();
    }

    //查看队列中的第一个元素
    var front = function () {
        return queue[0];
    }

    //判断队列是否为空
    var isAmpty = function () {
        return queue.length === 0;
    }

    //返回队列的长度
    var size = function () {
        return queue.length;
    }

    //清空队列
    var clear = function () {
        queue = [];
    }

    //将队列元素以字符串显示
    var print = function () {
        return queue.toString();
    }
}

• ES6写法

class Queue {
    constructor() {
        //用数组模拟队列
        this.queue = [];
    }

    //入队列
    enqueue(element) {
        this.queue.push(element);
    }

    //出队列
    dequeue() {
        return this.queue.shift();
    }

    //查看队列中的第一个元素
    front() {
        return this.queue[0];
    }

    //判断队列是否为空
    isAmpty() {
        return this.queue.length === 0;
    }

    //返回队列的长度
    size() {
        return this.queue.length;
    }

    //清空队列的内容
    clear() {
        this.queue = [];
    }

    //以字符串显示队列内容
    print() {
        return this.queue.toString();
    }
}

例子：

//击鼓传花
function flower(nameList,num) {
    var queue = []
    
    for(var i=0;i<nameList.length;i++) {
        queue.push(nameList[i])
    }
    
    while (queue.length>1) {
        for(var j=0;j<num-1;j++) {
            queue.push(queue.shift())
        }
        queue.shift()
    }
    
    return queue;
}

var name = ['1','2','3']
console.log(flower(name,2)) //结果：3