什么是栈？栈的基本操作

2022-08-22 19:33:54 阅读：192 来源： 互联网

标签：function 什么元素栈顶 item push 基本操作 stack

什么是栈？

栈（stack），它是一种运算受限的线性表,后进先出(LIFO)

LIFO(last in first out)表示就是后进入的元素, 第一个弹出栈空间. 类似于自动餐托盘, 最后放上的托盘, 往往先把拿出去使用.
其限制是仅允许在表的一端进行插入和删除运算。这一端被称为栈顶，相对地，把另一端称为栈底。
向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；
从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

栈的基本操作

函数调用栈

　　 　　var A = function(){
            B();
            console.log("A");
        }
        var B = function(){
            C()
            console.log("B");
        }
        var C = function(){
            A()
            console.log("C");
        }
        A()

未捕获的RangeError:超过最大调用堆栈大小

　　　　 var A = function(){
            B();
            console.log("A");
        }
        var B = function(){
            C()
            console.log("B");
        }
        var C = function(){
            // A()
            console.log("C");
        }
        A()

常用操作

push(element): 添加一个新元素到栈顶位置.

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

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

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

clear()：移除栈里的所有元素。

size()：返回栈里的元素个数。这个方法和数组的length属性很类似。

通过ES5进行封装栈方法：

1、函数

function Stack() {
            //开辟空间  保存栈元素
            this.item = []

            // 1向栈添加元素 数组的最后添加元素
             this.push = function(ele){
                this.item.push(ele)
             }
            // 2 移除栈顶元素 ，返回栈顶元素（数组最后一个元素）
            this.pop = function(){
                let delnode = this.item.pop()
                return delnode
            }
            // 3 返回栈顶元素（数组最后一个元素）
            this.peek = function(){
                let index =this.item.length-1;
                return this.item[index]
            }
            // 4判空 栈为空true 数组的length长度来判断是否为空
            this.isEmpty = function(){
                return this.item.length ==0;
            }

            // 5清空栈
            this.clear = function(){
                this.item = []
            }

            // 6栈元素的个数   数组中元素的个数
            this.size = function(){
                return this.item.length
            }

        }
        let stack = new Stack()
        stack.push(1)
        stack.push(2)
        console.log(stack.pop(2))
        stack.push(3)
        stack.push(4)
        stack.push(5)
        console.log(stack);

2、原型

 function Stack() {
            //开辟空间  保存栈元素
            this.item = []

            // 1向栈添加元素 数组的最后添加元素
             Stack.prototype.push = function(ele){
                this.item.push(ele)
             }
            // 2 移除栈顶元素 ，返回栈顶元素（数组最后一个元素）
            Stack.prototype.pop = function(){
                let delnode = this.item.pop()
                return delnode
            }
            // 3 返回栈顶元素（数组最后一个元素）
            Stack.prototype.peek = function(){
                let index =this.item.length-1;
                return this.item[index]
            }
            // 4判空 栈为空true 数组的length长度来判断是否为空
            Stack.prototype.isEmpty = function(){
                return this.item.length ==0;
            }

            // 5清空栈
            Stack.prototype.clear = function(){
                this.item = []
            }

            // 6栈元素的个数   数组中元素的个数
            Stack.prototype.size = function(){
                return this.item.length
            }

        }
        let stack = new Stack()

        console.log(stack);

通过ES6进行封装

class Stack {

            constructor() {
                this.item = []
            }
            // 1.向栈顶添加元素   数组的最后添加元素
            push(ele) {
                this.item.push(ele)
            }

            // 2.移除栈顶元素,返回栈顶元素(数组最后一个元素)
            pop() {
                let delnode = this.item.pop();
                return delnode
            }

            // 3.返回栈顶元素(数组最后一个元素)
            peek() {
                let index = this.item.length - 1;
                return this.item[index]
            }

            // 4.判空 栈为空true  数组的length长度来判断栈是否为空
            isEmpty() {
                return this.item.length == 0;
            }

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

            // 6.栈元素的个数 == 数组中元素的个数
            size() {
                return this.item.length
            }

        }

 　　　　let stack = new Stack()

        console.log(stack);

栈应用

进制转换

　　　　function zhuanhuan(chushu, base) {
　　
            let stack = new Stack()
            let arr = ["A", "B", "C", "D", "E", "F"]
            while (chushu > 0) {
                let yushu = chushu % base
                if (yushu > 9) {
                    stack.push(arr[yushu - 10])
                } else (
                    stack.push(yushu)
                )
                chushu = Math.floor(chushu / base)
            }
            let str = ""
            while (!stack.isEmpty()) {
                str += stack.pop()
            }
            return str
        }
        console.log(zhuanhuan(20, 2))

标签：function,什么,元素,栈顶,item,push,基本操作,stack
来源： https://www.cnblogs.com/LIXI-/p/16612874.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

ICode9