《剑指offer》第四章 27-38

第四章 解决面试题的思路

1.画图让抽象问题形象化

剑指 Offer 27. 二叉树的镜像

请完成一个函数，输入一个二叉树，该函数输出它的镜像。

例如输入：
     4
   /   \
  2     7
 / \   / \
1   3 6   9
镜像输出：
     4
   /   \
  7     2
 / \   / \
9   6 3   1

先序遍历这棵树的每个节点，如果遍历到的节点有子节点，就交换它的两个子节点。

   TreeNode* mirrorTree(TreeNode* root) {
        if(!root) return nullptr;
        root->left = mirrorTree(root->left);
        root->right = mirrorTree(root->right);
        swap(root->left,root->right);
        return root;
    }

剑指 Offer 28. 对称的二叉树

请实现一个函数，用来判断一棵二叉树是不是对称的。如果一棵二叉树和它的镜像一样，那么它是对称的。

例如，二叉树 [1,2,2,3,4,4,3] 是对称的。
    1
   / \
  2   2
 / \ / \
3  4 4  3
但是下面这个 [1,2,2,null,3,null,3] 则不是镜像对称的:
    1
   / \
  2   2
   \   \
   3    3

    bool isSymmetric(TreeNode* root) {
        if(!root) return true;//如果根节点为空，直接返回true
        return isMirror(root->left,root->right);
    }
    bool isMirror(TreeNode * root1,TreeNode *root2){
        if(!root1 && !root2) return true;//需要判空
        if(!root1 || !root2 || root1->val != root2->val) return false;//如果两个节点只有一个为空，一个不为空 或者值不相等，return false
        return isMirror(root1->left,root2->right) && isMirror(root1->right,root2->left);//镜像对称是树A的左儿子 等于B树的右儿子
    }

剑指 Offer 29. 顺时针打印矩阵

输入一个矩阵，按照从外向里以顺时针的顺序依次打印出每一个数字。

输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,2,3,6,9,8,7,4,5]

简单但是有些麻烦的题，需要把每一行每一列的遍历情况考虑到。

    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if(matrix.empty()) return vector<int>{};
        int start = 0;
        int rows = matrix.size(),cols = matrix[0].size();
        vector<int> res;
        while(start*2 < rows && start*2 < cols){//循环继续条件，从左上角(0,0)开始，一圈一圈打印
            printMatrixInCircle(matrix, res, start);
            ++start;
        }
        return res;
    }
    void printMatrixInCircle(vector<vector<int>>& matrix, vector<int> &res, int start){//打印一圈
        int endX = matrix.size() - start -1;//打印这一圈的最大行数
        int endY = matrix[0].size() - start -1;//打印这一圈的最大列数
        for(int i = start; i <= endY; ++i){//第一步从左往右打印，必有
            res.emplace_back(matrix[start][i]);
        }
        if(endX > start){//第二步从上到下打印一列，存在第二步的前提是至少有两行，终止行号大于起始行号
            for(int i = start + 1; i <= endX; ++i){
                res.emplace_back(matrix[i][endY]);
            }
        }
        if(endX > start && endY > start){//第三步是从右到左打印一行，存在第三步的前提是终止列数大于起始列数，终止行数大于起始行数
            for(int i = endY-1; i >= start; --i){
                res.emplace_back(matrix[endX][i]);
            }

        }
        //第四步是从下到上打印一列：存在条件是至少有三行两列，即终止行号比起始行号至少大2
        if(endX > start+1 && endY > start){
            for(int i = endX-1; i > start; --i){
                res.emplace_back(matrix[i][start]);
            }
        }

    }

2.举例让抽象问题具体化

剑指 Offer 30. 包含min函数的栈

定义栈的数据结构，请在该类型中实现一个能够得到栈的最小元素的 min 函数在该栈中，调用 min、push 及 pop 的时间复杂度都是 O(1)。

MinStack minStack = new MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
minStack.min();   --> 返回 -3.
minStack.pop();
minStack.top();      --> 返回 0.
minStack.min();   --> 返回 -2.

来源：