进入博客查看更多内容
栈
基础栈的实现
class Stack {
constructor () {
this.data = {}
this.count = 0
}
push (item) {
this.data[this.count] = item
this.count++
}
pop () {
if (this.isEmpty()) {
console.log('栈为空!')
return
}
const temp = this.data[this.count - 1]
delete this.data[--this.count]
return temp
}
isEmpty () {
return this.count === 0
}
top () {
if (this.isEmpty()) {
console.log('栈为空!')
return
}
return this.data[this.count - 1]
}
size () {
return this.count
}
clear () {
this.data = []
this.count = 0
}
}
const s = new Stack()
s.push('a')
s.push('b')
s.push('c')
包含min函数的栈
class MinStack {
constructor () {
this.stackA = []
this.countA = 0
this.stackB = []
this.countB = 0
}
push (item) {
this.stackA[this.countA++] = item
if (this.countB === 0 || item <= this.min()) {
this.stackB[this.countB++] = item
}
}
min () {
return this.stackB[this.countB - 1]
}
top () {
return this.stackA[this.countA - 1]
}
pop () {
if (this.top() === this.min()) {
delete this.stackB[--this.countB]
}
delete this.stackA[--this.countA]
}
}
const m = new MinStack()
包含min函数的栈-数组方法
class MinStack {
constructor () {
this.stack = []
}
push (item) {
this.stack.push(item)
}
top () {
return this.stack[this.stack.length - 1]
}
min () {
return Math.min.apply(null, this.stack)
}
pop () {
return this.stack.pop()
}
}
const m = new MinStack()
队列
队列的实现-基于数组
class Queue {
constructor () {
this.queue = []
this.count = 0
}
enQueue (item) {
this.queue[this.count++] = item
}
deQueue () {
if (this.isEmpty()) {
return
}
this.count--
return this.queue.shift()
}
isEmpty () {
return this.count === 0
}
top () {
if (this.isEmpty()) {
return
}
return this.queue[0]
}
size () {
return this.count
}
clear () {
this.length = 0
this.count = 0
}
}
const q = new Queue()
队列的实现-基于对象
class Queue {
constructor () {
this.queue = {}
this.count = 0
this.head = 0
}
enQueue (item) {
this.queue[this.count++] = item
}
deQueue () {
if (this.isEmpty()) {
return
}
const headData = this.queue[this.head]
delete this.queue[this.head]
this.head++
return headData
}
length () {
return this.count - this.head
}
isEmpty () {
return this.length() === 0
}
clear () {
this.queue = {}
this.count = 0
this.head = 0
}
}
const q = new Queue()
双端队列
class Deque {
constructor () {
this.queue = {}
this.count = 0
this.head = 0
}
addFront (item) {
this.queue[--this.head] = item
}
addBack (item) {
this.queue[this.count++] = item
}
removeFront () {
if (this.isEmpty()) {
return
}
const headData = this.queue[this.head]
delete this.queue[this.head++]
return headData
}
removeBack () {
if (this.isEmpty()) {
return
}
const backData = this.queue[this.count - 1]
delete this.queue[--this.count]
return backData
}
frontTop () {
if (this.isEmpty()) {
return
}
return this.queue[this.head]
}
backTop () {
if (this.isEmpty()) {
return
}
return this.queue[this.count - 1]
}
isEmpty () {
return this.size() === 0
}
size () {
return this.count - this.head
}
}
const deq = new Deque()
队列的最大值
在这里插入代码片var MaxQueue = function() {
this.queue = {}
this.deque = {}
this.countQ = this.countD = this.headQ = this.headD = 0
};
MaxQueue.prototype.push_back = function(value) {
this.queue[this.countQ++] = value
while (!this.isEmptyDeque() && value > this.deque[this.countD - 1]) {
delete this.deque[--this.countD]
}
this.deque[this.countD++] = value
};
MaxQueue.prototype.pop_front = function() {
if (this.isEmptyQueue()) {
return - 1
}
if (this.queue[this.headQ] === this.deque[this.headD]) {
delete this.deque[this.headD++]
}
const frontData = this.queue[this.headQ]
delete this.queue[this.headQ++]
return frontData
};
MaxQueue.prototype.max_value = function() {
if (this.isEmptyDeque()) {
return -1
}
return this.deque[this.headD]
};
MaxQueue.prototype.isEmptyDeque = function () {
return !(this.countD - this.headD)
};
MaxQueue.prototype.isEmptyQueue = function () {
return !(this.countQ - this.headQ)
};