剑指Offer——04天

顺时针打印矩阵

• 普通的模拟，和2017ACM青岛站的铜牌题特别像，但是我代码写的非常差，把循环写死...先粘上来吧，一会儿学一下评论区大佬们的写法

class Solution {
public:
    vector<int> printMatrix(vector<vector<int> > matrix) {
        int d = matrix.size();
        int r = matrix[0].size();
        int sum = d*r;
        int l=0;
        int u=0;
        int i,j;
        i=0;
        j=0;
        vector <int> p;
        int num=0;
        while(1)
        {
            while(1)
            {
                p.push_back(matrix[i][j]);
                num++;
                if(j==r-1) break;
                j++;
            }
            if(num==sum) break;
            r--;
            i++;
            while(1)
            {
                p.push_back(matrix[i][j]);
                num++;
                if(i==d-1) break;
                i++;
            }
            if(num==sum) break;
            d--;
            j--;
            while(1)
            {
                p.push_back(matrix[i][j]);
                num++;
                if(j==l) break;
                j--;
            }
            if(num==sum) break;
            l++;
            i--;
            while(1)
            {
                p.push_back(matrix[i][j]);
                num++;
                if(i==u+1) break;
                i--;
            }
            if(num==sum) break;
            u++;
            j++;
        }
        return p;
    }
};

包含min函数的栈

• 这道题没看懂题意，直接看的题解，发现果然是有巧计的，时间复杂度为O(1)
• 在这里定义了2个栈，一个是装数据，另一个装最小值，每一次压入当前栈的最小值为多少
• 数据栈     4 5 1 2 3
• 最小值栈 4 4 1 2 3

class Solution {
public:
    stack <int> data_stack,min_stack;
    void push(int value) {
        if(data_stack.empty()==true)
        {
            data_stack.push(value);
            min_stack.push(value);
        }
        else
        {
            data_stack.push(value);
            int num = min_stack.top();
            if(value<num)
            {
                min_stack.push(value);
            }
            else
            {
                min_stack.push(num);
            }
        }
    }
    void pop() {
        data_stack.pop();
        min_stack.pop();
    }
    int top() {
        return data_stack.top();
    }
    int min() {
        return min_stack.top();
    }
};

栈的压入、弹出序列

• 依旧看的题解...自己手动就看出来但是一到代码就不会编了
• 方法是建立一个栈，模拟操作，按照入栈顺序依次压栈，每次判断栈顶元素是否为出栈元素，如果是那么就弹出，最终栈为空时正确

class Solution {
public:
    bool IsPopOrder(vector<int> pushV,vector<int> popV) {
        stack <int> s;
        int n = pushV.size();
        int j=0;
        for(int i=0;i<n;i++)
        {
            s.push(pushV[i]);
            while(popV[j]==s.top()&&j<n)
            {
                s.pop();
                j++;
            }
        }
        if(s.empty()==true) return true;
        else return false;
    }
};

从上往下打印二叉树

• 借助队列，先将根节点入队，每次取队头元素，出队，并让它的左右子树的根节点入队，直至队列为空

/*
struct TreeNode {
    int val;
    struct TreeNode *left;
    struct TreeNode *right;
    TreeNode(int x) :
            val(x), left(NULL), right(NULL) {
    }
};*/
class Solution {
public:
    vector<int> PrintFromTopToBottom(TreeNode* root) {
        queue <TreeNode*> q;
        vector <int> v;
        if(root==NULL) return v;
        q.push(root);
        while(q.empty()!=true)
        {
            TreeNode * r = q.front();
            q.pop();
            v.push_back(r->val);
            if(r->left!=NULL) q.push(r->left);
            if(r->right!=NULL) q.push(r->right);
        }
        return v;
    }
};

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

• 没有用递归的方式去写，但是依旧过了，估计是数据少的原因吧，对于后序遍历为左右根，即小大中，所以以最后一个元素的值x为准
• 必然能将其划分成两段，前一段都小于x，后一段都大于x

class Solution {
public:
    bool VerifySquenceOfBST(vector<int> sequence) {
        int n = sequence.size();
        if(n==0) return false;
        int flag=0;
        int num = sequence[n-1];
        for(int i=0;i<n-1;i++)
        {
            if(flag==0)
            {
                if(sequence[i]<num)
                {
                    continue;
                }
                else
                {
                    flag=1;
                }
            }
            else if(flag==1)
            {
                if(sequence[i]<num)
                {
                    return false;
                }
            }
        }
        return true;
    }
};