javascript数据结构笔记 （栈、队列）

 

栈（后进先出）LIFO（last in first out）

 

栈的常见操作

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

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

• peek():(查看)返回栈顶的元素，不对栈进行任何修改(这个方法不会移除栈顶的元素，仅仅返回)

• isEmpty():(判空)如果栈里面的没有任何元素就返回true，否则返回false

• size():返回栈里面的元素个数，这个方法和数组的length属性很类似

• toString()：将栈结构的内容以字符串形式返回

函数和方法的区别

方法：和某一个对象有实例

函数：在构造函数外面声明的function

//实现栈结构有两种比较常见的方式
        // 1.基于数组实现
        // 2.基于链表实现
        function Stack() {
            //栈中的属性
            this.items = []
​
            //栈的相关操作
            // 1.将元素压入栈
            Stack.prototype.push = function (ele) {
                this.items.push(ele)
            }
            // 2.从栈中取出元素 删除元素同时返回被移除的元素
            Stack.prototype.pop = function (ele) {
                return this.items.pop(ele)
            }
            // 3.查看一下栈元素 peek返回栈顶的元素 不改变栈结构
            Stack.prototype.peek = function () {
                return this.items[this.items.length - 1]
            }
            // 4.判断栈是否为空
            Stack.prototype.isEmpty = function () {
                return this.items.length == 0
            }
            // 5.获取栈中元素的个数
            Stack.prototype.size = function () {
                return this.items.length
            }
            // 6.toString
            Stack.prototype.toString = function () {
​
                var resultString = ''
                // items.join(' ')
                for (var i = 0; i < this.items.length; i++) {
                    resultString = this.items.join(' ')
                }
                return resultString
            }
        }
        var s = new Stack()
        s.push(20)
        s.push(10)
        s.push(100)
        s.push(77)
        alert(s)
​
        s.pop()
        s.pop()
        alert(s)
        // 查看栈顶的元素
        alert(s.peek())
        //判断栈是否为空
        alert(s.isEmpty())
        alert(s.size())
        alert(s.toString())

队列（受限的线性结构）

特点：先进先出（FIFO Frist in Frist Out）

只允许在前端删除元素，在后端插入元素

队列的应用

打印队列

文档按次序放入打印队列中

打印机按队列依次取出文档，优先放入的文档优先被取出打印

线程队列

实现队列

1. 基于数组实现

2. 基于链表实现

队列相关的操作

• enqueue(ele):向尾部添加一个(或多个)新的项

• dequeue():移除队列的第一项（排在前端的项），返回被移除的元素

• front():返回队列中的第一个元素——最先被添加，也将是最先被移除的元素，队列不做任何改动

• isEmpty():判空 包含元素返回true 不包含元素返回false

• size():返回队列包含的个数，数组的length

• toString():将队列中的内容转成字符串形式

封装队列

//封装队列类
        function Queue() {
            // 属性
            this.items = []
            // 方法
            // 1.在末尾添加 进入队列
            Queue.prototype.enqueue = function (ele) {
                this.items.push(ele)
            }
            //2.移除第一项 删除队列
            Queue.prototype.dequeue = function () {
                return this.items.shift()
            }
            // 3.查看第一个元素，返回第一个值
            Queue.prototype.front = function () {
                return this.items[0]
            }
            // 4.判空
            Queue.prototype.isEmpty = function () {
                return this.items.length == 0
            }
            // 5.返回队列包含的个数
            Queue.prototype.size = function () {
                return this.items.length
            }
            // 6.toString
            Queue.prototype.toString = function () {
                var str = ''
                // str = this.items.join(' ')
                // return str
                for (var i = 0; i < this.items.length; i++) {
                    str += this.items[i] + ' '
                }
                return str
            }
        }
        var queue = new Queue()

面试题

击鼓传花

算法：将所有成员按顺序放入队列，最前面的就是轮到他报数，如果没有淘汰就被从后面加入队列，如果淘汰了，就在最顶部淘汰掉

优先级队列

与普通队列的区别：会比较每一个元素的优先级，根据优先级排队，普通的就是直接往后排队

主要考虑的问题：

1. 每个元素不只是一个数据，而是包含数据的优先级

2. 在添加中方式中，根据优先级放入正确的位置

优先队列的应用场景

优先级队列的封装

//主要是插入部分不同
 function PriorityQueue() {
            //内部类 传递数据和优先级，进行保存 相当于构造函数进行初始化
            function QueueElement(ele, pri) {
                this.ele = ele;
                this.pri = pri;
            }
            // 封装属性
            this.items = []
            // 1.插入
            PriorityQueue.prototype.enqueue = function (ele, pri) {
                // 使用构造函数创建QueryElement对象 数组包含对象
                var queueElement = new QueueElement(ele, pri)
​
                // 2.判断队列是否为空
                if (this.items.length == 0) {
                    this.items.push(queueElement)
                } else {
                    var flag = false
                    // 进行优先级比较
                    for (var i = 0; i < this.items.length; i++) {
                        if (queueElement.pri > this.items[i].pri) {
                            // 在数组中间插入，在i这里插入元素
                            this.items.splice(i, 0, queueElement)
                            flag = true
                            //找到之后就停止循环
                            break
                        }
                    }
                    // 没有插入就放在最后
                    if (flag == false) {
                        this.items.push(queueElement)
                    }
                }
            }
 }