算法训练营 Day 13

progressiveboy

已于 2024-05-23 23:01:33 修改

阅读量126

点赞数 2

文章标签：算法

于 2024-05-23 21:43:11 首次发布

本文链接：https://blog.csdn.net/NEWSBOYNEWSBOY/article/details/139158431

版权

1、层序遍历

迭代法：

#include <iostream>
#include <queue>

using namespace std;

typedef struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    explicit TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} //explicit防止隐式类型转换
} *Node;

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode *root) {
        queue<TreeNode *> que;
        if (root != nullptr) que.push(root);
        vector<vector<int>> result; //二维结果数组
        while (!que.empty()) {
            int size = que.size(); //当前层元素的数量
            vector<int> vec; //一维结果数组
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; ++i) { //这里也可以用whlie(size--)
                TreeNode *node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left); //空节点不入队列
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};

int main() {
    Node root = new TreeNode(3);
    Node A = new TreeNode(9);
    Node B = new TreeNode(20);
    Node C = new TreeNode(15);
    Node D = new TreeNode(7);

    root->left = A;
    root->right = B;
    B->left = C;
    B->right = D;

    Solution solution;
    for (const auto &row: solution.levelOrder(root)) {
        for (auto ele: row) {
            cout << ele << " ";
        }
        cout << endl;
    }
    cout << endl;

    delete root; //释放内存，必不可少
    delete A;
    delete B;
    delete C;
    delete D;
}

递归法（其他部分代码一样）：

class Solution {
public:
    void order(TreeNode* cur, vector<vector<int>>& result, int depth) {
        if (cur == nullptr) return; //结束条件
        if (result.size() == depth) result.emplace_back(); //等价于push_back({})，即添加一个空的vector数组，目的是构建一维结果数组
        result[depth].push_back(cur->val); //result[depth]是一维结果数组
        order(cur->left, result, depth + 1);
        order(cur->right, result, depth + 1);
    }

    vector<vector<int>> levelOrder(TreeNode* root) {
        vector<vector<int>> result; //二维结果数组
        int depth = 0;
        order(root, result, depth);
        return result;
    }
};

2、翻转二叉树

前序遍历递归法：

TreeNode* invertTree(TreeNode* root) { 
    if (root == nullptr) return root;
    swap(root->left, root->right);  // 中
    invertTree(root->left);         // 左
    invertTree(root->right);        // 右
    return root;
}

后序遍历递归法：

TreeNode* invertTree(TreeNode* root) { 
    if (root == nullptr) return root;
    invertTree(root->left);         // 左
    invertTree(root->right);        // 右
    swap(root->left, root->right);  // 中    
    return root;
}

中序遍历递归法：

TreeNode* invertTree(TreeNode* root) { 
    if (root == nullptr) return root;
    invertTree(root->left);         // 左
    swap(root->left, root->right);  // 中      
    invertTree(root->left);        // 右 注意这里还是root->left
    return root;
}

前序遍历迭代法（利用栈去实现）：

TreeNode* invertTree(TreeNode* root) {
    if (root == nullptr) return root;
    stack<TreeNode*> st;
    st.push(root);
    while(!st.empty()) {
        TreeNode* node = st.top();              
        st.pop();
        swap(node->left, node->right);          // 中
        if(node->right) st.push(node->right);   // 右
        if(node->left) st.push(node->left);     // 左
    }
    return root;
}

前序遍历迭代法（统一写法）：

TreeNode* invertTree(TreeNode* root) {
    stack<TreeNode*> st;
    if (root != nullptr) st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        if (node != nullptr) {
            st.pop();
            if (node->right) st.push(node->right);  // 右
            if (node->left) st.push(node->left);    // 左
            st.push(node);                          // 中
            st.push(nullptr);
        } else {
            st.pop();
            node = st.top();
            st.pop();
            swap(node->left, node->right);          // 节点处理逻辑
        }
    }
    return root;
}

层序遍历（利用队列实现）：

TreeNode* invertTree(TreeNode* root) {
    queue<TreeNode*> que;
    if (root != nullptr) que.push(root);
    while (!que.empty()) {
        int size = que.size();
        for (int i = 0; i < size; ++i) {
            TreeNode* node = que.front();
            que.pop();
            swap(node->left, node->right); // 节点处理
            if (node->left) que.push(node->left);
            if (node->right) que.push(node->right);
        }
    }
    return root;
}

3、对称二叉树

递归法：

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        // 首先排除空节点的情况
        if (left == nullptr && right != nullptr) return false;
        else if (left != nullptr && right == nullptr) return false;
        else if (left == nullptr && right == nullptr) return true;
        // 排除了空节点，再排除数值不相同的情况
        else if (left->val != right->val) return false;

        // 此时就是：左右节点都不为空，且数值相同的情况
        // 此时才做递归，做下一层的判断
        bool outside = compare(left->left, right->right);   // 左子树：左、 右子树：右
        bool inside = compare(left->right, right->left);    // 左子树：右、 右子树：左
        bool isSame = outside && inside;                    // 左子树：中、 右子树：中 （逻辑处理）
        return isSame;
    }
    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) return true;
        return compare(root->left, root->right);
    }
};

递归简化写法：

class Solution {
public:
    bool compare(TreeNode* left, TreeNode* right) {
        if (left == nullptr && right != nullptr) return false;
        else if (left != nullptr && right == nullptr) return false;
        else if (left == nullptr && right == nullptr) return true;
        else if (left->val != right->val) return false;
        else return compare(left->left, right->right) && compare(left->right, right->left);
    }

    bool isSymmetric(TreeNode* root) {
        if (root == nullptr) return true;
        return compare(root->left, root->right);
    }
};

迭代法（使用队列）：

class Solution {
public:
    bool isSymmetric(TreeNode *root) {
        if (root == nullptr) return true;
        queue<TreeNode *> que; // 结果队列
        que.push(root->left);   // 将左子树头结点加入队列
        que.push(root->right);  // 将右子树头结点加入队列

        while (!que.empty()) {  // 接下来就要判断这两个树是否相互翻转
            TreeNode *leftNode = que.front();
            que.pop();
            TreeNode *rightNode = que.front();
            que.pop();
            if (leftNode == nullptr && rightNode == nullptr) {  // 左节点为空、右节点为空，此时说明是对称的
                continue; // 因为leftNode和rightNode并不仅仅指根节点的左右孩子，所以这里不能直接return true
            }

            // 左右一个节点不为空，或者都不为空但数值不相同，返回false
            if (!leftNode || !rightNode || (leftNode->val != rightNode->val)) {
                return false;
            }
            que.push(leftNode->left);   // 加入左节点左孩子
            que.push(rightNode->right); // 加入右节点右孩子
            que.push(leftNode->right);  // 加入左节点右孩子
            que.push(rightNode->left);  // 加入右节点左孩子
        }
        return true;
    }
};

迭代法（使用栈）：

class Solution {
public:
    bool isSymmetric(TreeNode *root) {
        if (root == nullptr) return true;
        stack<TreeNode *> st; // 结果栈
        st.push(root->left);
        st.push(root->right);
        while (!st.empty()) {
            TreeNode *leftNode = st.top();
            st.pop();
            TreeNode *rightNode = st.top();
            st.pop();
            if (!leftNode && !rightNode) {
                continue;
            }
            if (!leftNode || !rightNode || (leftNode->val != rightNode->val)) {
                return false;
            }
            st.push(leftNode->left);
            st.push(rightNode->right);
            st.push(leftNode->right);
            st.push(rightNode->left);
        }
        return true;
    }
};