剑指offer牛客网练习20200127

刺骨的言语ヽ痛彻心扉 2023-07-02 07:23 3阅读 0赞

1.包含min函数的栈

一开始自己没看懂思路，去看了讨论区意思是要两个栈，后来想明白了

要用多一个栈存储较小值

多一个栈的push条件：栈为空或者小于等于栈顶的元素

出栈条件：栈不为空且等于栈顶的元素

# -*- coding: utf-8 -*-
    """
    Created on Sun Dec 22 14:41:47 2019
    
    @author: Shiyi Chen
    """
    # -*- coding:utf-8 -*-
    class Solution:
        def __init__(self):
            self.arr=[]
            self.mini=[]
        def push(self, node):
            # write code here
            self.arr.append(node)
            if self.mini:
                mix=self.mini[-1]
                if node<=mix:
                    self.mini.append(node)
            else:
                self.mini.append(node)
        def pop(self):
            # write code here
            if self.arr:
                if self.arr[-1]==self.mini[-1]:
                    self.mini.pop()
                return self.arr.pop()
            else:
                return None
        def top(self):
            # write code here
            if self.arr:
                return self.arr[-1]
            else:
                return None
        def min(self):
            # write code here
            if self.mini:
                return self.mini[-1]
            else:
                return None

2.栈的压入、弹出序列

# -*- coding:utf-8 -*-
    class Solution:
        def IsPopOrder(self, pushV, popV):
            # write code here
            temp=[]
            result=True
            for i in range(0,len(pushV)):
                temp.append(pushV[i])
                if temp[-1]==popV[0]:
                    temp.pop()
                    popV.pop(0)
            for i in popV:
                if temp.pop()!=i:
                    result=False
            return result

基本思路就是在入栈的先搞一波，入栈的同时判断是否需要随时出栈，之后入栈完后再判断还存在的出栈的。

看了讨论区之后再次觉得自己是渣渣

3.二叉搜索树的后序遍历序列

我能说不是科班的我不知道二叉搜索树吗= =，去搜索了一下才知道

主要自己搞错了两个地方，一个是not sequence的判断，是为了判断是否【】这个用例返回false，二个是r我在最初的时候弄成了赋值初始化为-1，但是就导致了r=-1后面r!=0判断错误了，我觉得我很傻

# -*- coding:utf-8 -*-
    class Solution:
        def VerifySquenceOfBST(self, sequence):
            # write code here
            if not sequence:
                return False
            root=sequence.pop()
            r=len(sequence)
            for i in range(0,len(sequence)):
                if sequence[i]>root:
                    r=i
                    break
            result=True
            if r!=0:
                #左子树
                if root<max(sequence[:r]):
                    return False
                result=result and self.VerifySquenceOfBST(sequence[:r])
            if r!=len(sequence):
                #右子树
                if root>min(sequence[r:]):
                    return False
                result=result and self.VerifySquenceOfBST(sequence[r:])
            return result

链接：https://www.nowcoder.com/questionTerminal/a861533d45854474ac791d90e447bafd?f=discussion
    来源：牛客网
    
    /非递归 
    //非递归也是一个基于递归的思想：
    //左子树一定比右子树小，因此去掉根后，数字分为left，right两部分，right部分的
    //最后一个数字是右子树的根他也比左子树所有值大，因此我们可以每次只看有子树是否符合条件
    //即可，即使到达了左子树左子树也可以看出由左右子树组成的树还想右子树那样处理
     
    //对于左子树回到了原问题，对于右子树，左子树的所有值都比右子树的根小可以暂时把他看出右子树的左子树
    //只需看看右子树的右子树是否符合要求即可
    class Solution {
    public:
        bool VerifySquenceOfBST(vector<int> sequence) {
            int size = sequence.size();
            if(0==size)return false;
     
            int i = 0;
            while(--size)
            {
                while(sequence[i++]<sequence[size]);
                while(sequence[i++]>sequence[size]);
     
                if(i<size)return false;
                i=0;
            }
            return true;
        }
    };

上面那个牛掰

4.从上往下打印二叉树

借助队列

# -*- coding:utf-8 -*-
    # class TreeNode:
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    class Solution:
        # 返回从上到下每个节点值列表，例：[1,2,3]
        def PrintFromTopToBottom(self, root):
            # write code here
            if not root:
                return []
            rlist=[]
            result=[]
            result.append(root.val)
            if root.left:
                rlist.append(root.left)
            if root.right:
                rlist.append(root.right)
            while len(rlist)!=0:
                result.append(rlist[0].val)
                if rlist[0].left:
                    rlist.append(rlist[0].left)
                if rlist[0].right:
                    rlist.append(rlist[0].right)
                rlist.pop(0)
            return result

稍加修改

# -*- coding:utf-8 -*-
    # class TreeNode:
    #     def __init__(self, x):
    #         self.val = x
    #         self.left = None
    #         self.right = None
    class Solution:
        # 返回从上到下每个节点值列表，例：[1,2,3]
        def PrintFromTopToBottom(self, root):
            # write code here
            if not root:
                return []
            rlist=[]
            result=[]
            rlist.append(root)
            while len(rlist)!=0:
                result.append(rlist[0].val)
                if rlist[0].left:
                    rlist.append(rlist[0].left)
                if rlist[0].right:
                    rlist.append(rlist[0].right)
                rlist.pop(0)
            return result