增量操作时，当栈元素多于 k 个，将栈底的 k 个元素都加 val，栈元素少于 k 个时将所有元素都加上 val。
复杂度分析
时间复杂度：push 和 pop 是 $O(1)$，inc 是 $O(k)$。
空间复杂度：$O(maxSize)$。
链表
也可以使用链表来模拟栈，入栈出栈都只操作 head，也能实现时间复杂度 $O(1)$ 的 push 和 pop 操作，但 inc 操作的话，由于找到从链表尾端开始的第 k 个元素 (可以用双指针来找) 的时间复杂度是 $O(n)$，然后将链表尾端的 k 个元素进行增量操作的时间复杂度是 $O(k)$，所以增量操作总的时间复杂度是 $O(n+k)$。
复杂度分析
时间复杂度：push 和 pop 是 $O(1)$，inc 是 $O(n+k)$。
空间复杂度：$O(maxSize)$。
代码
JavaScript Code
/**
* @param {number} maxSize
*/
var CustomStack = function (maxSize) {
this.list = [];
this.maxSize = maxSize;
};
/**
* @param {number} x
* @return {void}
*/
CustomStack.prototype.push = function (x) {
if (this.list.length < this.maxSize) {
this.list.push(x);
}
};
/**
* @return {number}
*/
CustomStack.prototype.pop = function () {
const item = this.list.pop();
return item === void 0 ? -1 : item;
};
/**
* @param {number} k
* @param {number} val
* @return {void}
*/
CustomStack.prototype.increment = function (k, val) {
for (let i = 0; i < k && i < this.list.length; i++) {
this.list[i] += val;
}
};
/**
* Your CustomStack object will be instantiated and called as such:
* var obj = new CustomStack(maxSize)
* obj.push(x)
* var param_2 = obj.pop()
* obj.increment(k,val)
*/
Python Code
class CustomStack(object):
def __init__(self, maxSize):
"""
:type maxSize: int
"""
self.list = []
self.maxSize = maxSize
def size(self):
return len(self.list)
def push(self, x):
"""
:type x: int
:rtype: None
"""
if self.size() < self.maxSize:
self.list.append(x)
def pop(self):
"""
:rtype: int
"""
return -1 if self.size() == 0 else self.list.pop()
def increment(self, k, val):
"""
:type k: int
:type val: int
:rtype: None
"""
size = k if k < self.size() else self.size()
for i in range(0, size):
self.list[i] += val
# Your CustomStack object will be instantiated and called as such:
# obj = CustomStack(maxSize)
# obj.push(x)
# param_2 = obj.pop()
# obj.increment(k,val)
