用JS的class类模拟一个栈

什么是栈？

        遵循后进先出原则的数据结构。

基于数组的模拟的栈

我们先创造一个基于数组的栈，由于lifo原则，需要对元素的插入和删除做限制。

这次描述的栈有以下几个功能

push(element(s))：添加一个（或几个）新元素到栈顶。

pop()：移除栈顶的元素，同时返回被移除的元素。

 peek()：返回栈顶的元素，不对栈做任何修改（该方法不会移除栈顶的元素，仅仅返回它）。

 isEmpty()：如果栈里没有任何元素就返回true，否则返回false。

 clear()：移除栈里的所有元素。❑ size()：返回栈里的元素个数。该方法和数组的length属性很类似。

class Stack {
    constructor() {
        this.items = []
    }
    // 增
    push(element) {
        this.items.push(element)
    }
    // 删
    pop(){
        return this.items.pop()
    }
    // 查 我们查看的正事栈顶部最后的元素
    peek() {
        return this.items[this.items.length -1];
    }
    // 判断你的栈是否为空
    isEmpty() {
        return this.items.length === 0;
    }
    // 获取你的栈的长度
    size() {
        return this.items.length;
    }
    // 清空你的栈里面所有的元素
    clear() {
        this.items=[]
    }
}

就这样一个最简单的模拟栈已经做好了，接下来我们体验一下它 

const stackList = new Stack();
// 判断这个栈是否为空
console.log(stackList.isEmpty()) // true
// 我们来添加元素
stackList.push('niubi_1')
stackList.push('niubi_2')
// 我们使用peek方法  返回栈顶的元素  会返回谁呢? 
// 会返回niubi_2 因为它是最后添加的 它在栈顶上  
console.log(stackList.peek()) // niubi_2

再实现一个基于对象模拟的栈

创建一个Stack类最简单的方式是使用一个数组来存储其元素。在处理大量数据的时候（这在现实生活中的项目里很常见），我们同样需要评估如何操作数据是最高效的。

在使用数组时，大部分方法的时间复杂度是O(n)。O(n)的意思是，我们需要迭代整个数组直到找到要找的那个元素，在最坏的情况下需要迭代数组的所有位置，其中的n代表数组的长度。如果数组有更多元素的话，所需的时间会更长。

另外，数组是元素的一个有序集合，为了保证元素排列有序，它会占用更多的内存空间。如果我们能直接获取元素，占用较少的内存空间，并且仍然保证所有元素按照我们的需要排列，那不是更好吗？对于使用JavaScript语言实现栈数据结构的场景，我们也可以使用一个JavaScript对象来存储所有的栈元素，保证它们的顺序并且遵循LIFO原则。我们来看看如何实现这样的行为。

class Stack {
    constructor() {
        this.count = 0;
        this.items = {}
    }
    // 这里和数组的数据结构就不一样了  
    // 使用key和value
    push(element) {
        this.items[this.count] = element;
        this.count++;
    }
    size() {
        return this.count;
    }
    // 特别注意 再和数字比对时一定要用===
    isEmpty() {
        return this.count === 0
    }
    pop() {
        if(this.isEmpty()) return undefined;
        this.count-- ;
        // 将你要删除的元素先保存下来
        const result = this.items[this.count]
        delete this.items[this.count]
        return result
    }
    peek() {
        if(this.isEmpty() )return undefined;
        return this.items[this.count -1]
    }
    clear() {
        this.items ={}
        this.count = 0 
    }
}
const stackObj =new Stack()
stackObj.push(1)
stackObj.push(2)
console.log(stackObj.items) // { '0': 1, '1': 2 }
console.log(stackObj.peek())  // 2 
stackObj.pop() //执行删除栈顶元素
console.log(stackObj.items) //{ '0': 1 }

数组和对象风格的栈的比对

       数组栈我们再计算时，复杂度均为O(n） 因为我们再找到某一项元素时候 因为是数组 所以可能会遍历一遍，因此性能会变差

     对象创建的方法的复杂度均为O(1)，代表我们可以直接找到目标元素并对其进行操作