Leetcode 剑指 Offer 27~29

最新推荐文章于 2022-09-08 12:00:25 发布

G0rgeoustray

最新推荐文章于 2022-09-08 12:00:25 发布

阅读量104

点赞数

分类专栏： Leetcode 文章标签： leetcode c++

本文链接：https://blog.csdn.net/G0rgeoustray/article/details/119307254

版权

Leetcode 专栏收录该内容

80 篇文章 2 订阅

订阅专栏

27. 二叉树的镜像

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    TreeNode* mirrorTree(TreeNode* root) {
        if (root)
            mirrorTreeCore(root);
        return root;
    }

    void mirrorTreeCore(TreeNode* p) {
        swap(p->left, p->right);
        if (p->left)
            mirrorTreeCore(p->left);
        if (p->right)
            mirrorTreeCore(p->right);
    }
};

28. 对称的二叉树

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */
class Solution {
public:
    bool isSymmetric(TreeNode* root) {
        return isSymmetricCore(root, root);
    }

    bool isSymmetricCore(TreeNode* a, TreeNode* b) {
        if (!a && !b)
            return true;
        if (a && b) {
            if (a->val != b->val)
                return false;
            return isSymmetricCore(a->left, b->right)
                && isSymmetricCore(a->right, b->left);
        }
        return false;
    }
};

29. 顺时针打印矩阵

class Solution {
public:
    // 前进方向，分别表示右下左上
    vector<vector<int> > direction{
        {0, 1},
        {1, 0},
        {0, -1},
        {-1, 0},
    };

    vector<int> spiralOrder(vector<vector<int>>& matrix) {
        if (matrix.empty() || matrix[0].empty())
            return vector<int>();
        int m = matrix.size(), n = matrix[0].size(), steps = m * n;
        vector<int> ans;
        vector<vector<bool>> visited(m, vector<bool>(n, false));
        int y = 0, x = 0, dir = 0;
        for (int i = 0; i < steps; ++i)
            spiralOrderCore(matrix, ans, visited, m, n, y, x, dir);
        return ans;
    }

    void spiralOrderCore(vector<vector<int>>& matrix, vector<int>& ans,
            vector<vector<bool>>& visited, const int m, const int n,
            int& y, int& x, int& dir) {
        visited[y][x] = true;
        ans.push_back(matrix[y][x]);
        // 探索是否需要更改前进方向
        int newY = y + direction[dir][0];
        int newX = x + direction[dir][1];
        if (newY < 0 || newY >= m || newX < 0 || newX >= n || visited[newY][newX])
            dir = (dir + 1) % 4;
        // 前进一格
        y += direction[dir][0];
        x += direction[dir][1];
    }
};