数据结构（JS实现）——栈的封装与应用

一.什么是栈

栈是一种先进后出（LIFO）的有序集合，新添加的元素在栈顶，旧元素在栈底。

二.栈的封装

我们封装栈的常见方式有两种：

基于数组实现

基于链表实现

我们使用数组实现

function Stack(params) {
        // 栈中的属性
        this.items=[];
       
        // 栈中的相关操作
        // 栈中的相关操作
        // push（element）：添加一个新元素到栈顶位置
        // pop():移除栈顶元素，同时返回被移除的元素
        // peek():返回栈顶元素，不对栈做任何修改（这个方法不会移除栈顶元素，仅仅返回它）
        // isEmpty():判空
        // size():返回长度
        // tostring():输出
    }

三、栈的常见的操作

push（element）：添加一个新元素到栈顶位置

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

peek():返回栈顶元素，不对栈做任何修改（这个方法不会移除栈顶元素，仅仅返回它）

isEmpty():判空

size():返回长度

tostring():输出

3.1 push（element）：添加一个新元素到栈顶位置

 Stack.prototype.push=function(element){
            this.items.push(element);
            return element;
        }

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

 Stack.prototype.pop=function(){
            return this.items.pop();
        }

3.3 peek():返回栈顶元素，不对栈做任何修改（这个方法不会移除栈顶元素，仅仅返回它）

  Stack.prototype.peek=function(){
            return this.items[this.items.length-1];
        }

3.4 isEmpty():判空

  Stack.prototype.isEmpty=function(){
            return this.items.length==0;
        }

3.5 size():返回长度

     Stack.prototype.size=function(){
            return this.items.length;
        }

3.6 tostring():输出

  Stack.prototype.tostring=function(){
            var str='';
            for (let index = 0; index < this.items.length; index++) {
                str+=this.items[index]+' '
            }
            return str;
        }

四、栈的应用(十进制转二进制)

十进制转二进制

思路：

例如num为100

则：1. 100/2=50…0

\2. 50/2=25…0

\3. 25/2=12…1

\4. 12/2=6…0

\5. 6/2=3…0

\6. 3/2=1…1

\7. 1/2=0…1

结果为：1100100

 // 十进制转二进制
    function dec2bin(num) {
        var target=new Stack();
        while (num>0) {
            target.push(num%2);
            num=Math.floor(num/2);
        }

        // 弹栈
        var str='';
        while (!target.isEmpty()) {
            str+=target.pop()+' ';
        }
        return str;
    }
    console.log(dec2bin(100));

五. 源码

 // 封装栈类
 function Stack(params) {
    // 栈中的属性
    this.items=[];
    // 栈中的相关操作
    // push（element）：添加一个新元素到栈顶位置
    Stack.prototype.push=function(element){
        this.items.push(element);
        return element;
    }

    // pop():移除栈顶元素，同时返回被移除的元素
    Stack.prototype.pop=function(){
        return this.items.pop();
    }

    // peek():返回栈顶元素，不对栈做任何修改（这个方法不会移除栈顶元素，仅仅返回它）
    Stack.prototype.peek=function(){
        return this.items[this.items.length-1];
    }


    // isEmpty():判空
    Stack.prototype.isEmpty=function(){
        return this.items.length==0;
    }

    // size():返回长度
    Stack.prototype.size=function(){
        return this.items.length;
    }


    // tostring():输出
    Stack.prototype.tostring=function(){
        var str='';
        for (let index = 0; index < this.items.length; index++) {
            str+=this.items[index]+' '
        }
        return str;
    }
}