每日六题-剑指offer(四)

剑指offer之每日六题

1.顺时针打印矩阵
2.包含min函数的栈
3.栈的压入,弹出序列
4.从上到下打印二叉树
5.二叉搜索树的后序遍历序列
6.二叉树中和为某一值的路径

1.顺时针打印矩阵

/**
变量的声明清晰一点对解题的思路很有帮助(捂脸),随便给个名字容易绕进去
**/
class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        vector<int> vec;
        int left=0,top=0,button=matrix.size()-1,right=matrix[0].size()-1;
        if(button<0||right<0) return vec; 
        while(left<=right&&top<=button){
            for(int i=left;i<=right;i++) vec.push_back(matrix[top][i]);
            for(int i=top+1;i<=button;i++) vec.push_back(matrix[i][right]);
            if(top!=button)
                for(int i=right-1;i>=left;i--) vec.push_back(matrix[button][i]);
            if(left!=right)
                for(int i=button-1;i>top;i--) vec.push_back(matrix[i][left]);
            left++;
            top++;
            right--;
            button--;
        }
        return vec;
    }
};

2.包含min函数的栈

/**
借助一个辅助栈s2来更新较小的数据,剩下的操作看代码应该很容易看懂
**/
class Solution {
public:
    stack<int> s1,s2;
    void push(int value) {
        if(s2.empty()) s2.push(value);
        s1.push(value);
        if(!s2.empty()&&s1.top()<=s2.top()){
            s2.push(value);
        }
    }
    void pop() {
        if(s1.top()==s2.top()) s2.pop();
        s1.pop();
    }
    int top() {
        return s1.top();
    }
    int min() {
        return s2.top();
    }
};

3.栈的压入,弹出序列

/**
怎么说,模拟的思想,将pushV序列入栈,遇到和popV从0开始的元素相等的就pop,popV的下标加一
如果最后模拟的栈为空,则返回true
**/
class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        if(pushV.empty()||popV.empty()) return false;
        stack<int> s;
        int j=0;
        for(int i=0;i<pushV.size();++i){
            s.push(pushV[i]);
            while(!s.empty()&&s.top()==popV[j]){
                s.pop();
                ++j;
            }
        }
        return s.empty();
    }
};

4.从上往下打印二叉树

/**
层次遍历你懂的
**/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        vector<int> vec;
        if(root==NULL) return vec;
        queue<TreeNode*> q;
        q.push(root);
        while(!q.empty()){
            TreeNode* t=q.front();
            q.pop();
            vec.push_back(t->val);
            if(t->left!=NULL) q.push(t->left);
            if(t->right!=NULL) q.push(t->right);
        }
        return vec;
    }
};

5.二叉搜索树的后序遍历

/**
以后遇到树的遍历的问题了一定要联想到左右子树!分解成左右子树之后发现挺简单的
二叉搜索树的左子树比根节点小,右子树都比根节点大,所以递归判断是否满足这个条件
**/
class Solution {
public:
    bool getThis(vector<int>& v,int left,int right){
        if(left>=right) return true;
        int i=right;
        while(i>left&&v[i-1]>v[right]) i--;
        for(int j = i - 1; j >= left; --j) if(v[j] > v[right]) return false;
        return getThis(v, left, i - 1) && (getThis(v, i, right - 1));
    }
    bool VerifySquenceOfBST(vector<int> vec) {
        if(vec.empty()) return false;
        if(vec.size()==1) return true;
        return getThis(vec,0,vec.size()-1);
    }
};

6.二叉树中和为某一值的路径

/**
如果根节点为空,就返回空数组,如果不为空,则用vector不定长数组来保存路径,当和为最终值时将其存到另一个二维数组中,遍历左右节点,回溯,用栈来应该可以实现非递归,但没写嘿嘿
**/
class Solution {
public:
    vector<int> vec;
    vector<vector<int>> ans;
    void dfs(TreeNode* root,int temp){
        vec.push_back(root->val);
        if(temp-root->val==0&&!root->left&&!root->right)
            ans.push_back(vec);
        if(root->left) dfs(root->left,temp-root->val);
        if(root->right) dfs(root->right,temp-root->val);
        vec.pop_back();

    }
    vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
        if(root==NULL) return ans;
        dfs(root,expectNumber);
        return ans;
    }
};