剑指Offer（一）——栈

1、用两个栈来实现一个队列，完成队列的Push和Pop操作。

2、栈的压入、弹出序列

思路：

1、用两个栈来实现一个队列，完成队列的Push和Pop操作。

用两个栈来实现一个队列，完成队列的Push和Pop操作。队列中的元素为int类型。

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.stack1, self.stack2 = [], []
        
    def push(self, node):
        # write code here
        self.stack1.append(node)
        
    def pop(self):
        # return xx
        if self.stack2:
            return self.stack2.pop()
        if not self.stack1:
            return -1
        while self.stack1:
            self.stack2.append(self.stack1.pop())
        return self.stack2.pop()

2、栈的压入、弹出序列

输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。假设压入栈的所有数字均不相等。例如序列1,2,3,4,5是某栈的压入顺序，序列4,5,3,2,1是该压栈序列对应的一个弹出序列，但4,3,5,1,2就不可能是该压栈序列的弹出序列。（注意：这两个序列的长度是相等的）

思路：

new一个栈，将pushV逐步入栈，随时比较栈顶元素。

# -*- coding:utf-8 -*-
class Solution:
    def IsPopOrder(self, pushV, popV):
        # write code here
        stack = []
        index = 0
        for item in pushV:
            stack.append(item)
            while stack and stack[-1] == popV[index]:
                stack.pop()
                index += 1
        if stack==[]:
            return True
        else:
            return False

3、包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈中所含最小元素的min函数。（时间复杂度应为O(1)）

思路：

对于时间复杂度的要求，所以需要在栈的每一个过程中，都可以实时判断得出最小元素。所以下面第一个做法不对。

常见做法，添加一个辅助栈，存放最小元素。

此外，比较巧妙的做法还有每次在确认新入栈value值为最小值时，先将当前（即新min_val入栈前）的最小value入栈保存，再更新最小值，然后新value入栈。如做法2。

先将当前最小value保存的意义在于，pop时上一个value出去后可以及时更新当前最小值。

# -*- coding:utf-8 -*-
class Solution:
    def __init__(self):
        self.arr = []
    
    def push(self, node):
        # write code here
        self.arr.append(node)
        
    def pop(self):
        # write code here
        return self.arr.pop()
    def top(self):
        # write code here
        return self.arr[-1]
    
    def min(self):
        # write code here
        return min(self.arr)

c++解答

class Solution {
public:
    stack<int> s;
    int min_val = INT_MAX;
    void push(int value) {
        if (value < min_val){
            s.push(min_val);
            min_val=value;
        }
        s.push(value);
    }
    void pop() {
        if (s.top() == min_val){
            s.pop();
            min_val = s.top();
            s.pop();
        }
        else
            s.pop();
    }
    int top() {
        return s.top();
    }
    int min() {
        return min_val;
    }
};

同思路

python解答

import sys
max_value = sys.maxsize
min_value = - sys.maxsize - 1

全部解答

# -*- coding:utf-8 -*-
import sys

class Solution:
    def __init__(self):
        self.stack = []
        self.min_val = sys.maxsize
    
    def push(self, node):
        # write code here
        if node < self.min_val:
            self.stack.append(self.min_val)
            self.min_val = node
            self.stack.append(node)
        else:
            self.stack.append(node)
        
    def pop(self):
        # write code here
        if self.stack[-1]==self.min_val:
            self.stack.pop()
            self.min_val = self.stack[-1]
            self.stack.pop()
        else:
            self.stack.pop()
            

    def top(self):
        # write code here
        return self.stack[-1]
    
    def min(self):
        # write code here
        return self.min_val

4、二叉搜索树的后序遍历序列

输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则返回true,否则返回false。假设输入的数组的任意两个数字都互不相同。

二叉搜索树的中序遍历结果为从小到大的排列

# -*- coding:utf-8 -*-
class Solution:
    def VerifySquenceOfBST(self, sequence):
        # write code here
        if not sequence:
            return False
        root = sequence[-1]
        i = 0
        while i < len(sequence)-1:
            if sequence[i]>root:
                break
            i += 1
        for j in range(i,len(sequence)-1):
            if sequence[j]<root:
                return False
        left, right = True, True
        if i > 0:
            left = self.VerifySquenceOfBST(sequence[:i])
        if i > len(sequence)-1:
            right = self.VerifySquenceOfBST(sequence[i:len(sequence)-1])
        return left&right

5、按之字形顺序打印二叉树

请实现一个函数按照之字形打印二叉树，即第一行按照从左到右的顺序打印，第二层按照从右至左的顺序打印，第三行按照从左到右的顺序打印，其他行以此类推。

# -*- coding:utf-8 -*-
# class TreeNode:
#     def __init__(self, x):
#         self.val = x
#         self.left = None
#         self.right = None

class Solution:
    def Print(self, pRoot):
        ans = []
        if not pRoot:
            return ans
        
        def helper(node, level):
            if len(ans) == level:
                ans.append([])
            if level%2 == 0:
                ans[level].append(node.val)
            else:
                ans[level].insert(0, node.val)
            if node.left:
                helper(node.left, level+1)
            if node.right:
                helper(node.right, level+1)
        
        helper(pRoot,0) 
        return ans