二叉树简述+考试要点（C++）

二叉树的基本概念

二叉树是一种树形数据结构，每个节点最多有两个子节点，分别称为左子节点和右子节点。

特点：
- 每个节点最多有两个子节点。
- 左子树和右子树有顺序，不可颠倒。
- 空树（无节点）或由根节点和左右子树组成。
常见术语：
- 根节点：树的顶层节点。
- 叶子节点：没有子节点的节点。
- 深度：从根节点到某节点的路径长度。
- 高度：从某节点到叶子节点的最长路径。

二叉树的遍历方式（C++实现）

遍历是二叉树的核心操作，分为递归和非递归实现。

前序遍历（根-左-右）

递归实现：

cpp 复制代码

void preOrder(TreeNode* root) {
    if (root == nullptr) return;
    cout << root->val << " ";
    preOrder(root->left);
    preOrder(root->right);
}

非递归实现（使用栈）：

cpp 复制代码

void preOrderStack(TreeNode* root) {
    stack<TreeNode*> st;
    if (root) st.push(root);
    while (!st.empty()) {
        TreeNode* node = st.top();
        st.pop();
        cout << node->val << " ";
        if (node->right) st.push(node->right);
        if (node->left) st.push(node->left);
    }
}

中序遍历（左-根-右）

递归实现：

cpp 复制代码

void inOrder(TreeNode* root) {
    if (root == nullptr) return;
    inOrder(root->left);
    cout << root->val << " ";
    inOrder(root->right);
}

非递归实现：

cpp 复制代码

void inOrderStack(TreeNode* root) {
    stack<TreeNode*> st;
    TreeNode* curr = root;
    while (curr || !st.empty()) {
        while (curr) {
            st.push(curr);
            curr = curr->left;
        }
        curr = st.top();
        st.pop();
        cout << curr->val << " ";
        curr = curr->right;
    }
}

后序遍历（左-右-根）

递归实现：

cpp 复制代码

void postOrder(TreeNode* root) {
    if (root == nullptr) return;
    postOrder(root->left);
    postOrder(root->right);
    cout << root->val << " ";
}

非递归实现（双栈法）：

cpp 复制代码

void postOrderStack(TreeNode* root) {
    stack<TreeNode*> st1, st2;
    if (root) st1.push(root);
    while (!st1.empty()) {
        TreeNode* node = st1.top();
        st1.pop();
        st2.push(node);
        if (node->left) st1.push(node->left);
        if (node->right) st1.push(node->right);
    }
    while (!st2.empty()) {
        cout << st2.top()->val << " ";
        st2.pop();
    }
}

二叉树常见考点

求二叉树的最大深度

cpp 复制代码

int maxDepth(TreeNode* root) {
    if (root == nullptr) return 0;
    return 1 + max(maxDepth(root->left), maxDepth(root->right));
}

判断对称二叉树

cpp 复制代码

bool isSymmetric(TreeNode* root) {
    if (!root) return true;
    return helper(root->left, root->right);
}

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

二叉树的层序遍历（BFS）

cpp 复制代码

vector<vector<int>> levelOrder(TreeNode* root) {
    vector<vector<int>> res;
    if (!root) return res;
    queue<TreeNode*> q;
    q.push(root);
    while (!q.empty()) {
        int size = q.size();
        vector<int> level;
        for (int i = 0; i < size; ++i) {
            TreeNode* node = q.front();
            q.pop();
            level.push_back(node->val);
            if (node->left) q.push(node->left);
            if (node->right) q.push(node->right);
        }
        res.push_back(level);
    }
    return res;
}

重建二叉树（前序+中序）

cpp 复制代码

TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {
    unordered_map<int, int> inMap;
    for (int i = 0; i < inorder.size(); ++i) {
        inMap[inorder[i]] = i;
    }
    return helper(preorder, 0, preorder.size()-1, inorder, 0, inorder.size()-1, inMap);
}

TreeNode* helper(vector<int>& preorder, int preStart, int preEnd, 
                 vector<int>& inorder, int inStart, int inEnd, 
                 unordered_map<int, int>& inMap) {
    if (preStart > preEnd || inStart > inEnd) return nullptr;
    TreeNode* root = new TreeNode(preorder[preStart]);
    int inRoot = inMap[root->val];
    int numsLeft = inRoot - inStart;
    root->left = helper(preorder, preStart+1, preStart+numsLeft, 
                        inorder, inStart, inRoot-1, inMap);
    root->right = helper(preorder, preStart+numsLeft+1, preEnd, 
                         inorder, inRoot+1, inEnd, inMap);
    return root;
}

考试高频题型

递归应用：如遍历、深度计算、对称判断。
非递归实现：栈模拟递归过程（前中后序遍历）。
构造二叉树：根据前序/中序/后序序列重建。
特殊二叉树：二叉搜索树（BST）、平衡二叉树（AVL）的性质与操作。
路径问题：如求根到叶子节点的路径和。

掌握上述核心代码和逻辑，可覆盖多数二叉树相关考题。