javascript数据结构——栈

//数组模拟栈
class Stack {
    constructor() {
        this.items = []
    }
    push(element) {  //添加元素
        this.items.push(element)
    }
    pop() {   //删除元素
        return this.items.pop()
    }
    clear() {  //清空栈
        this.items = []
    }
    peek() {  //返回栈顶元素
        return this.items[this.items.length - 1]
    }
    isEmpty() {  //判断栈是否为空
        return this.items.length === 0
    }
    size() {  //栈大小
        return this.items.length
    }
}

//对象模拟栈
class Stack {
    constructor() {
        this.items = {}
        this.num = 0 //记录栈大小
    }
    push(element) {   //添加元素
        this.items[this.num] = element
        this.num++
    }
    size() {  //栈大小
        return this.num
    }
    pop() {  //删除元素
        if (this.num === 0) {
            return undefined
        }
        this.num--
        const result = this.items[this.num]  //保存结果以返回
        delete this.items[this.num]
        return result
    }
    clear() {  //清空栈
        this.items = {}
        this.num = 0
    }
    peek() {  //返回栈顶元素
        if (this.num === 0) {
            return undefined
        }
        return this.items[this.num]
    }
    isEmpty() {  //判断栈是否为空
        return this.num === 0
    }
    toString() {   //字符串化
        if (this.num === 0) {
            return ''
        }
        let stackString = `${this.items[0]}`
        for(let i=1;i<this.num;i++){
            stackString = `${stackString},${this.items[i]}`
        }
        return stackString
    }
}

---

栈相关算法习题（力扣easy+middle题）

1.有效括号（力扣20）

var getObjectKey = (object, value) => {  //根据值名获取键名
    return Object.keys(object).find(key => object[key] === value);
};
var isValid = function (s) {
    let stack = [];
    const obj = {
        "(": ")",
        "[": "]",
        "{": "}"
    }
    for (let i = 0; i < s.length; i++) {
        if (Object.values(obj).includes(s[i])) {   //所有值名[ ')', ']', '}' ]
            //判断stack中最后一项是否等于当前值名对应的键名
            if (stack[stack.length - 1] === getObjectKey(obj, s[i])) {
                //删除键名
                stack.pop()
            } else {
                return false
            }
        } else {
            //向stack推入键名
            stack.push(s[i])
        }
    }
    if (stack.length === 0) {
        return true
    } else {
        return false
    }
};

2.最小栈（力扣155）

var MinStack = function() {
    this.items = []
};


MinStack.prototype.push = function(val) {
    this.items.push(val)
};


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


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


MinStack.prototype.getMin = function() {
    let min = this.items[0]
    for(let i=0;i<this.items.length;i++){
        min = Math.min(min,this.items[i])
    }
    return min
};

 

3.棒球比赛（力扣682）

var calPoints = function (ops) {
    if (ops.length === 1) {
        return ops[0]
    }
    if (ops.length === 2) {
        return ops[0] + ops[1]
    }
    let num = 0
    let stack = []
    for (let i = 0; i < ops.length; i++) {
        if (ops[i] === "C") {
            stack.pop()
        } else if (ops[i] === 'D') {
            stack.push(stack[stack.length - 1] * 2)
        } else if (ops[i] === '+') {
            stack.push(stack[stack.length - 1] + stack[stack.length - 2])
        } else {
            ops[i] = Number(ops[i])
            stack.push(ops[i])
        }
    }
    stack.forEach(value => {
        num += value
    })
    return num
};

4.删除字符串中所有重复项（力扣1047）

var removeDuplicates = function (s) {
    let stack = [];
    for (let i = 0; i < s.length; i++) {
        if (!stack.includes(s[i])) {
            stack.push(s[i])
        } else if (stack.includes(s[i]) && stack[stack.length - 1] === s[i]) {
            stack.pop(stack[stack.length - 1])
        } else {
            stack.push(s[i])
        }
    }
    let result = stack.toString().replace(/[,]/g, '')
    return result
};

5.整理字符串（力扣1544）

var makeGood = function (s) {
    if (s.length === 1) {
        return s[0]
    }
    let stack = []
    stack[0] = s[0]
    console.log(stack)
    for (let i = 1; i < s.length; i++) {  //l e 
        if (s[i] === stack[stack.length - 1]) {
            stack.push(s[i])
        } else if (s[i].toUpperCase() === stack[stack.length - 1] || s[i].toLowerCase() === stack[stack.length - 1]) {
            stack.pop()
        } else {
            stack.push(s[i])
        }
    }
    let result = stack.toString().replace(/[,]/g, '')
    return result
};

6.验证栈序列（946-middle）

var validateStackSequences = function (pushed, popped) {
  let stack = [];
  var clear_stack = function () {
    while (stack[stack.length - 1] === popped[0] && stack.length !== 0) {
      stack.pop()
      popped.shift()
    }
  }
  for (let i = 0; i < pushed.length; i++) {
    stack.push(pushed[i])
    clear_stack()
  }
  return stack.length === 0
};

其它

任意进制转换算法

const baseConverter = function (decNumber, base) {
  let stack = [];
  let digits = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
  let rem;
  let str = "";
  if (base < 2 || base > 36) {
    return ''
  }
  while (decNumber > 0) {
    rem = Math.floor(decNumber % base);
    stack.push(rem);
    decNumber = Math.floor(decNumber / base);
  }
  while (stack.length !== 0) {
    str += digits[stack.pop()]
  }
  return str
}