算法day10|232，225

今日任务：

• 理论基础

• 232.用栈实现队列

• 225. 用队列实现栈

理论基础

栈和队列是两种基本的数据结构，同为容器类型。两者根本的区别在于：

stack:后进先出

queue:先进先出

stack和queue是没有查询具体某一个位置的元素的操作的。但是他们的排列是按顺序的

对于stack我们可以使用python内置的list实现，因为list是属于线性数组，在末尾插入和删除一个元素所使用的时间都是O(1),这非常符合stack的要求。

stack的实现代码（使用python内置的list），实现起来是非常的简单，就是list的一些常用操作
 

#栈的实现
stack = []
stack.append()
stack.pop()
stack[-1]
len(stack)
#队列的实现
q = queue()
q.append()
len(q)
q.popleft() #删除即将出队的元素

文章讲解：代码随想录

232.用栈实现队列

class MyQueue(object):

    def __init__(self):
        self.stack = []

    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.stack.append(x)
    def pop(self):
        """
        :rtype: int
        """
        remove_element = self.stack[0]
        self.stack.pop(0)
        return remove_element
    def peek(self):
        """
        :rtype: int
        """
        return self.stack[0]
    def empty(self):
        """
        :rtype: bool
        """
        if len(self.stack) == 0:
            return True
        else:
            return False

好像我抄近道了..

class MyQueue(object):

    def __init__(self):
        self.stackin = []
        self.stackout = []
        
    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.stackin.append(x)
    def pop(self):
        """
        :rtype: int
        """
        if self.empty():
            return None
        
        if self.stackout:
            return self.stackout.pop()
        else:
            for i in range(len(self.stackin)):
                element = self.stackin.pop()
                self.stackout.append(element)
            return self.stackout.pop()

    def peek(self):
        """
        :rtype: int
        """
        result = self.pop()
        self.stackout.append(result)
        return result

    def empty(self):
        """
        :rtype: bool
        """
        return not (self.stackin or self.stackout)

主要思路就是创建两个栈，一个出栈，一个入栈。

题目链接/文章讲解/视频讲解：代码随想录

二刷：

未ac。一个队列相当于两个栈，要记住

class MyQueue:

    def __init__(self):
        self.stack_in = []
        self.stack_out = []

    def push(self, x: int) -> None:
        return self.stack_in.append(x)

    def pop(self) -> int:
        if self.empty():
            return None
        if self.stack_out:
            return self.stack_out.pop()
        else:
            while len(self.stack_in)!=0:
                self.stack_out.append(self.stack_in.pop())
            return self.stack_out.pop()
    def peek(self) -> int:
        ans = self.pop()
        self.stack_out.append(ans)
        return ans
        

    def empty(self) -> bool:
        if len(self.stack_in)==0 and len(self.stack_out) == 0:
            return True
        else:
            return False

三刷

三刷：

var MyQueue = function() {
    this.stackIn = []
    this.stackOut = []
};

/** 
 * @param {number} x
 * @return {void}
 */
MyQueue.prototype.push = function(x) {
    this.stackIn.push(x)
};

/**
 * @return {number}
 */
MyQueue.prototype.pop = function() {
    //将栈1中的所有元素放到栈2，然后pop出栈2的元素
    const size = this.stackOut.length
    if(size){
        return this.stackOut.pop()
    }
    while(this.stackIn.length){
        this.stackOut.push(this.stackIn.pop())
    }
    return this.stackOut.pop()
};

/**
 * @return {number}
 */
MyQueue.prototype.peek = function() {
    let result = this.pop()
    this.stackOut.push(result)
    return result

};

/**
 * @return {boolean}
 */
MyQueue.prototype.empty = function() {
    return !this.stackIn.length && !this.stackOut.length
};

/** 
 * Your MyQueue object will be instantiated and called as such:
 * var obj = new MyQueue()
 * obj.push(x)
 * var param_2 = obj.pop()
 * var param_3 = obj.peek()
 * var param_4 = obj.empty()
 */

Array.length 属性返回数组中元素的个数，因此 this.stackIn.length 将是一个非负整数值。在 JavaScript 中，在布尔类型的上下文中，任何非零的数值被视为 true，而 0 被视为 false。例如，x && y 表示 x 和 y 两个表达式都为 true 时，整个表达式的值为 true。如果 x 为 false，则整个表达式的值为 false，不会再计算 y 的值。

三刷：

var MyQueue = function() {
    this.stackIn = []
    this.stackOut = []
};

/** 
 * @param {number} x
 * @return {void}
 */
MyQueue.prototype.push = function(x) {
    this.stackIn.push(x)
};

/**
 * @return {number}
 */
MyQueue.prototype.pop = function() {
    //将栈1中的所有元素放到栈2，然后pop出栈2的元素
    const size = this.stackOut.length
    if(size){
        return this.stackOut.pop()
    }
    while(this.stackIn.length){
        this.stackOut.push(this.stackIn.pop())
    }
    return this.stackOut.pop()
};

/**
 * @return {number}
 */
MyQueue.prototype.peek = function() {
    let result = this.pop()
    this.stackOut.push(result)
    return result

};

/**
 * @return {boolean}
 */
MyQueue.prototype.empty = function() {
    return !this.stackIn.length && !this.stackOut.length
};

/** 
 * Your MyQueue object will be instantiated and called as such:
 * var obj = new MyQueue()
 * obj.push(x)
 * var param_2 = obj.pop()
 * var param_3 = obj.peek()
 * var param_4 = obj.empty()
 */

Array.length 属性返回数组中元素的个数，因此 this.stackIn.length 将是一个非负整数值。在 JavaScript 中，在布尔类型的上下文中，任何非零的数值被视为 true，而 0 被视为 false。例如，x && y 表示 x 和 y 两个表达式都为 true 时，整个表达式的值为 true。如果 x 为 false，则整个表达式的值为 false，不会再计算 y 的值。

225. 用队列实现栈

class MyStack(object):

    def __init__(self):
        self.que = deque()

    def push(self, x):
        """
        :type x: int
        :rtype: None
        """
        self.que.append(x)
    def pop(self):
        """
        :rtype: int
        """
        for i in range(len(self.que)-1):
            temp = self.que.popleft()
            self.que.append(temp)
        return self.que.popleft()    
    
    def top(self):
        """
        :rtype: int
        """
        result = self.pop()
        self.que.append(result)
        return result

    def empty(self):
        """
        :rtype: bool
        """
        if len(self.que) == 0:
            return True
        else:
            return False

题目链接/文章讲解/视频讲解：代码随想录

二刷：

未ac

三刷

var MyStack = function() {
    // 先进先出，栈先进后出
    this.que = []
    
};

/** 
 * @param {number} x
 * @return {void}
 */
MyStack.prototype.push = function(x) {
    this.que.push(x)
    
};

/**
 * @return {number}
 */
MyStack.prototype.pop = function() {

    // pop出后出的，所以队列应该一直出来到最后一个数
    for(let i = 0;i<this.que.length-1;i++){
        this.que.push(this.que.shift())
    }
    return this.que.shift()
};

/**
 * @return {number}
 */
MyStack.prototype.top = function() {
    let x = this.pop()
    this.que.push(x)
    return x
    
};

/**
 * @return {boolean}
 */
MyStack.prototype.empty = function() {
    return !this.que.length
    
};