C++学习笔记之数据结构_c++ 二叉树-CSDN博客

本文链接：https://blog.csdn.net/sincerelover/article/details/141230153

提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

一、二叉树

二叉树是一种常见的数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。二叉树具有广泛的应用，如表示树形结构、表达式解析、搜索算法等。

1.1 二叉树的遍历

1.1.1 深度优先搜索（DFS）

二叉树的遍历是指按照某种顺序访问树中的每一个节点，主要有以下几种方法：

前序遍历（Preorder Traversal）：先访问根节点，然后遍历左子树，最后遍历右子树。顺序为：根 -> 左 -> 右。

/*
执行流程
1.初始化：
	current 指向根节点。
2.访问根节点：
	将 current 节点的值添加到结果中。
3.处理左右子树：
	如果 current 的右子节点不为空，将其压入栈。
	如果 current 的左子节点不为空，将其压入栈。
4.继续遍历：
	从栈中弹出一个节点，并将其设为 current。
	重复步骤 2 和步骤 3，直到栈为空。
*/
class Solution {
   
   
public:
    vector<int> PreorderTraversal(TreeNode* root) {
   
   
        if (root == nullptr) return;
        
        std::stack<TreeNode*> stack;
        vector<int> res;
        TreeNode* current = root;
    	stack.push(root);
    	
        while (!stack.empty()) {
   
   
           	current = stack.top();
            stack.pop();
            res.push_back(current->val);  // 将节点值添加到结果中
            
			// 注意这里的顺序：先右后左，这样在栈中处理时，左子树会先于右子树处理
			if (current->right != nullptr) {
   
   
            	stack.push(current->right);  // 将右子节点压入栈
       		 	}
       		if (current->left != nullptr) {
   
   
            	stack.push(current->left);   // 将左子节点压入栈
        		}
        }
        return res;
    }
};

中序遍历（Inorder Traversal）：先遍历左子树，然后访问根节点，最后遍历右子树。顺序为：左 -> 根 -> 右。

/*
执行流程
1.初始化：current 指向根节点，栈为空。
2.遍历左子树：
   内层 while (current != nullptr) 循环将当前节点及其所有左子节点依次压入栈中。
   这一步并没有访问任何节点，只是将节点保存起来。
3.访问节点：
   当 current 变为 nullptr 时，表示已经到达左子树的尽头。
   从栈中弹出一个节点，这个节点是最左的未访问节点。
   访问该节点（打印节点值）。
4.遍历右子树：
   将 current 移动到刚访问节点的右子节点，重复上述过程
*/
class Solution {
   
   
public:
    vector<int> inorderTraversal(TreeNode* root) {
   
   
        std::stack<TreeNode*> stack;
        vector<int> res;
        TreeNode* current = root;
    
        while (current != nullptr || !stack.empty()) {
   
   
            while (current != nullptr) {
   
   
                stack.push(current);
                current = current->left;  // 将左子节点压入栈
            }
            current = stack.top();
            stack.pop();
            res.push_back(current->val);  // 将节点值添加到结果中
            current = current->right;  // 转向右子树
        }
        return res;
    }
};

后序遍历（Postorder Traversal）：先遍历左子树，然后遍历右子树，最后访问根节点。顺序为：左 -> 右 -> 根。

/*
这种方式是笔者偷师一位大佬的，属于投机取巧，主要是将前序遍历的修改逻辑并通过反转结果来得到后序遍历的结果
*/
class Solution {
   
   
public:
    vector<int> postorderTraversal(TreeNode* root) {
   
   
        if (root == nullptr) return;
        
        std::stack<TreeNode*> stack;
        vector<int> res;
        TreeNode* current = root;
    	stack.push(root);
    	
        while (!stack.empty()) {
   
   
           	current = stack.top();
            stack.pop();
            res.push_back(current->val);  // 将节点值添加到结果中
            
			// 注意这里的顺序：先右后左，这样在栈中处理时，左子树会先于右子树处理
			if (current->right != nullptr) {
   
   
            	stack.push(current->right);  // 将右子节点压入栈
       		 	}
       		if (current->left != nullptr) {
   
   
            	stack.push(current->left);   // 将左子节点压入栈
        		}
        }
        reverse(res.begin(), res.end());
        return res;
    }
};

除了上面的迭代法，我们也可以使用递归法。通过调换递归调用和处理当前节点的顺序，可以将前序遍历改写为前序遍历或后序遍历。

// 前序遍历
class Solution {
   
   
public:
    vector<int> preorderTraversal(TreeNode* root) {
   
   
        vector<int> res;
        preorderHelper(root, res);
        return res;
    }
    
    void preorderHelper(TreeNode* root, vector<int>& res) {
   
   
        if (root == nullptr) return;
        
        // 处理当前节点
        res.push_back(root->val);
        
        // 递归遍历左子树
        preorderHelper(root->left, res);
        
        // 递归遍历右子树
        preorderHelper(root->right, res);
    }
};

// 中序遍历
class Solution {
   
   
public:
    vector<int> inorderTraversal(TreeNode* root) {
   
   
        vector<int> res;
        inorderHelper(root, res);
        return res;
    }
    
    void inorderHelper(TreeNode* root, vector<int>& res) {
   
   
        if (root == nullptr) return;
        
        // 递归遍历左子树
        inorderHelper(root->left, res);
        
        // 处理当前节点
        res.push_back(root->val);
        
        // 递归遍历右子树
        inorderHelper(root->right, res);
    }
};

// 后序遍历
class Solution {
   
   
public:
    vector<int> postorderTraversal(TreeNode* root) {
   
   
        vector<int> res;
        postorderHelper(root, res);
        return res;
    }
    
    void postorderHelper(TreeNode* root, vector<int>& res) {
   
   
        if (root == nullptr) return;
        
        // 递归遍历左子树
        postorderHelper(root->left, res);
        
        // 递归遍历右子树
        postorderHelper(root->right, res);
        
        // 处理当前节点
        res.push_back(root->val);
    }
};

1.1.2 广度优先搜索（BFS）

与DFS不同，BFS是从一个起始节点开始，首先访问所有相邻的节点，然后逐层向外扩展，依次访问下一层的所有节点。通常使用队列（queue）来实现，常用于最短路径问题、社交网络分析、网络广播、寻找最小生成树等。这里以102.二叉树的层序遍历为例，采用队列的方法，其思路如下：

申请一个队列q用于暂存节点，定义一个二维数组用来存储遍历结果；
在循环中定义一个数组currentLevel来存储每一层的节点，并时刻检索当前队列长度；
遍历当前层的每一个节点，依次取出节点并存储到currentLevel，并将该节点的左右子节点也压入队列中；
当该层的所有节点均在队列弹出且存入了currentLevel，将currentLevel压入数组；
按照上面的逻辑重复压入各个层的currentLevel，返回结果。

117.填充每个节点的下一个右侧节点指针II的思路也是如此，不同之处在于需要定义一个包含 next 指针的 Node 类，以便将同一层的节点连接起来。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
   
   
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
   
   
        vector<vector<int>> result;
        if (root == nullptr) return result;

        queue<TreeNode*> q;
        q.push(root