【4.1】图搜索算法-BFS和DFS解奇偶树

一、题目

二、解题思路

        看到这道题的条件，我们最容易想到的就是使用BFS（广度优先搜索）来解决，也就是一层一层地遍历二叉树。在遍历每一层时，我们需要满足以下两个条件：

1. 偶数层的节点值必须是奇数，并且从左到右递增。
2. 奇数层的节点值必须是偶数，并且从左到右递减。

        只要有一个条件不满足，就返回`false`。对于二叉树的BFS遍历，我们之前已经介绍过很多次了，如下图所示：

BFS算法代码如下：

#include <iostream>
#include <queue>

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

void BFS(TreeNode* node) {
    // 使用一个队列
    std::queue<TreeNode*> queue;
    queue.push(node);

    while (!queue.empty()) {
        // 出队
        TreeNode* curNode = queue.front();
        queue.pop();

        // 访问当前节点
        std::cout << curNode->val << std::endl;

        // 左右子节点只要有一个不为空就把他加入到队列中
        if (curNode->left != nullptr)
            queue.push(curNode->left);
        if (curNode->right != nullptr)
            queue.push(curNode->right);
    }
}

三、代码实现

        参照上面代码修改一下就能解决该题目：

#include <iostream>
#include <queue>
#include <climits>
#include <vector>

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

TreeNode* buildTree(const std::vector<int>& nodes, int index) {
    if (index >= nodes.size() || nodes[index] == INT_MIN) {
        return nullptr;
    }
    TreeNode* root = new TreeNode(nodes[index]);
    root->left = buildTree(nodes, 2 * index + 1);
    root->right = buildTree(nodes, 2 * index + 2);
    return root;
}

bool isEvenOddTree(TreeNode* root) {
    std::queue<TreeNode*> queue;
    // 把根节点加入到队列中
    queue.push(root);
    bool even = true; // 默认根节点是偶数层

    while (!queue.empty()) {
        // 每一层节点的个数
        int levelCount = queue.size();
        // 每层节点的前一个节点值
        int prevVal = even ? INT_MIN : INT_MAX;

        // 遍历当前层的所有节点
        while (levelCount-- > 0) {
            TreeNode* curNode = queue.front();
            queue.pop();

            // 偶数层上的节点都是奇数，并且是递增的，如果不满足条件直接返回false
            if (even && (curNode->val % 2 == 0 || curNode->val <= prevVal))
                return false;
            // 奇数层上的节点都是偶数，并且是递减的
            if (!even && (curNode->val % 2 == 1 || curNode->val >= prevVal))
                return false;

            // 更新前一个节点
            prevVal = curNode->val;

            // 如果左右子节点不为空，就把他加入到队列中
            if (curNode->left != nullptr)
                queue.push(curNode->left);
            if (curNode->right != nullptr)
                queue.push(curNode->right);
        }

        // 奇偶交换
        even = !even;
    }

    return true;
}

void deleteTree(TreeNode* root) {
    if (root == nullptr) return;
    deleteTree(root->left);
    deleteTree(root->right);
    delete root;
}

int main() {
    // 输入：root = [1,10,4,3,null,7,9,12,8,6,null,null,2]
    std::vector<int> nodes = {1, 10, 4, 3, INT_MIN, 7, 9, 12, 8, 6, INT_MIN, INT_MIN, 2};
    TreeNode* root = buildTree(nodes, 0);

    if (isEvenOddTree(root)) {
        std::cout << "The tree satisfies the even-odd tree condition." << std::endl;
    } else {
        std::cout << "The tree does not satisfy the even-odd tree condition." << std::endl;
    }

    // 释放内存
    deleteTree(root);

    return 0;
}

        除了使用BFS（广度优先搜索），我们还可以使用DFS（深度优先搜索）来解决这个问题。这里使用的DFS是二叉树的前序遍历。我们使用一个`list`集合来存储每层的节点，注意，每层只存储一个节点。

        当前节点所在的层数如果是第一次访问，我们就将其加入到集合`list`中。否则，就需要与集合中同层的节点值进行比较。具体是递增还是递减，这需要根据所在的层数来决定。代码如下：

#include <iostream>
#include <vector>
#include <climits>

struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
    TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
};

TreeNode* buildTree(const std::vector<int>& nodes, int index) {
    if (index >= nodes.size() || nodes[index] == INT_MIN) {
        return nullptr;
    }
    TreeNode* root = new TreeNode(nodes[index]);
    root->left = buildTree(nodes, 2 * index + 1);
    root->right = buildTree(nodes, 2 * index + 2);
    return root;
}

bool dfs(TreeNode* root, std::vector<int>& mList, int level) {
    if (root == nullptr)
        return true;

    // 偶数层的值都是奇数，奇数层的值都是偶数，如果不满足直接返回false
    if (root->val % 2 == level % 2)
        return false;

    // 这里是判断当前层是不是第一次遍历，也可以这样理解，就是当前节点
    // 是不是这一层的第一个节点，如果不是第一个节点，我们需要和前面的
    // 比较，如果是第一个节点，就没法和前面一个节点比较，直接存储到
    // 集合list中。
    if (mList.size() > level) {
        // 根据当前节点是奇数层还是偶数层，来判断是递增还是递减
        if ((level % 2 == 1 && mList[level] <= root->val) ||
            ((level % 2 == 0) && mList[level] >= root->val))
            return false;
        mList[level] = root->val;
    } else {
        mList.push_back(root->val);
    }

    // 继续访问他的左右两个子节点
    return dfs(root->left, mList, level + 1) && dfs(root->right, mList, level + 1);
}

bool isEvenOddTree(TreeNode* root) {
    // list集合，每层只存储一个节点
    std::vector<int> mList;
    return dfs(root, mList, 0);
}

void deleteTree(TreeNode* root) {
    if (root == nullptr) return;
    deleteTree(root->left);
    deleteTree(root->right);
    delete root;
}

int main() {
    // 输入：root = [5,4,2,3,3,7]
    std::vector<int> nodes = {5, 4, 2, 3, 3, 7};
    TreeNode* root = buildTree(nodes, 0);

    if (isEvenOddTree(root)) {
        std::cout << "The tree satisfies the even-odd tree condition." << std::endl;
    } else {
        std::cout << "The tree does not satisfy the even-odd tree condition." << std::endl;
    }

    // 释放内存
    deleteTree(root);

    return 0;
}