LeetCode-数据结构(五)

第九天-栈和队列

20-有效的括号

所有数据结构书上几乎都会提到的栈的经典应用

1. 首先遇到左括号([{都入栈
2. 遇到右括号)]}则将其与栈顶括号进行匹配，匹配则栈顶元素弹出，继续考察下一个字符

class Solution {
public:
    bool isValid(string s) {
        stack<char> st;
        for(int i=0;i<s.size();i++)
        {
            char it = s[i];
            if(it=='('||it=='['||it=='{')//遇到左符号则入栈
                st.push(it);
            else
            {
                if(!st.empty())//栈非空——防止存在“}]”类似情况
                {
                    char top = st.top();//取栈顶元素比较
                    if(top=='('&&it==')'&&!st.empty())
                        st.pop();
                    else if(top=='['&&it==']'&&!st.empty())
                        st.pop();
                    else if(top=='{'&&it=='}'&&!st.empty())
                        st.pop();
                    else
                        return false;
                }
                else
                    return false;
            }
        }
        if(!st.empty())//最后需要注意判断栈是否非空 例子“(()”
            return false;
        return true;
    }
};

232-用栈实现队列

经典题目，利用双栈模拟队列
栈是FILO的线性结构，而队列是FIFO的线性结构，题目明确说了利用两个栈，那么我们自然可以想到如果要出队列的时候，将一个栈的数据压入另一个栈中，那么本应该在最下层的元素就跑到栈顶了

|3| | |
|2| | |
|1| | |
|_| |_| 双栈模拟队列
当要出队列时
| | |1|
| | |2|
| | |3|
|_| |_|从第一个栈中将元素压入第二个栈，则先入的元素则在栈顶，符合FIFO

我们只需要实现上述模拟的过程即可

class MyQueue {
public:
    stack<int> s1;
    stack<int> s2;
    MyQueue() {

    }
    
    void push(int x) {
        s1.push(x);//元素入队列则是进入第一个栈内
    }
    
    int pop() {//出队列操作，则需要将第一个栈中元素全部压入第二个栈中
        if(s2.empty())
        {
            while(!s1.empty())
            {
                s2.push(s1.top());
                s1.pop();
            }
        }
        int top = s2.top();//这里先保存栈顶元素再进行pop
        s2.pop();
        return top;
    }
    
    int peek() {//类似pop但是不需要出队
        if(s2.empty())
        {
            while(!s1.empty())
            {
                s2.push(s1.top());
                s1.pop();
            }
        }
        return s2.top();
    }
    
    bool empty() {//两个栈都空时，队列才空
        if(s1.empty()&&s2.empty())
            return true;
        else
            return false;
    }
};

第十天-树的遍历

144-二叉树的前序遍历

94-二叉树的中序遍历

145-二叉树的后序遍历

1. 递归解法

前、中、后序遍历是树最基本的遍历方法，也是练习DFS递归的好题目

前序遍历：根左右
中序遍历：左根右
后序遍历：左右根

很明显这是一个递归的定义，以前序遍历为例，首先我们访问根节点——注意这里的访问指任何对于根节点的操作，然后我们访问其左子树，右子树，对于其左子树同样执行该操作，很容易我们想到利用递归解法，比较简单不过多解释，前中后序遍历的不同在于执行访问的时机不同

class Solution {
public:
    vector<int> ans;
    void preOrder(TreeNode * root)
    {
        if(root==nullptr)
            return;
        ans.push_back(root->val);//这就是所谓的“访问”操作
        preOrder(root->left);
        preOrder(root->right);
    }
    vector<int> preorderTraversal(TreeNode* root) {
        preOrder(root);
        return ans;
    }
};

2. 非递归解法

这里重点讲解非递归解法，在《数据结构》和《编译原理》中我们知道系统借助栈实现的递归，所以这里的非递归解法，就是利用栈来模拟递归。

首先要模拟根结点的访问，具体在该题中就是将当前结点的val存储到ans数组中；然后是模拟先左子树再右子树，但是进入右子树后又需要从左子树开始遍历，所以在基础的外层循环外，里面还需要一个走左子树的循环将左子树结点压栈

具体代码如下：

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        if(!root)
            return {};
        stack<TreeNode*> s;
        vector<int> ans;
        while(!s.empty()||root!=nullptr)
        {
            while(root!=nullptr)
            {
                ans.push_back(root->val);//“访问”
                s.push(root);
                root = root->left;//将左子树压栈
            }
            root = s.top();
            s.pop();//结点出栈
            root = root->right;//右子树压栈——再开始新一轮根左右
        }
        return ans;
    }
};