Leetcode二叉树专题模板积累

最新推荐文章于 2025-09-29 19:03:10 发布

原创最新推荐文章于 2025-09-29 19:03:10 发布 · 277 阅读

0 ·

CC 4.0 BY-SA版权

Leetcode二叉树专题专栏收录该内容

33 篇文章

订阅专栏

本文详细介绍了BFS（广度优先搜索）算法及其在路径搜索问题中的应用，并给出了具体实现代码。此外，还深入探讨了BST（二叉搜索树）的构造及遍历方法，并通过实例展示了如何将有序数组转换为平衡的BST。

文章目录

1 BFS

适用场景：有固定初始树节点的路径搜索问题，当已知固定终点时可用双向BFS进行优化

void bfs(TreeNode* start, TreeNode* target) {
	// 1.初始化队列+记录
	queue<TreeNode*> q;
	set<TreeNode*> visited; // 避免走回头路

    q.push(start);
    visited.add(start);
    int step = 0;  // 记录步数

	while (!q.empty()) {
		int sz = q.size();
		// 2.从队列中取数据
		for (int i=0;i<sz;i++) {
			TreeNode* e_ptr = q.front();  q.pop();
			// 3.判断是否达到终点
			if (e_ptr == target) {  // e_ptr->left == nullptr 等
				return step;        // 按题目要求返回所需东西
			}
			// 4.没到终点则继续遍历
			//--4.1 二叉树
			if (e_ptr->left != nullptr) {
				q.push(e_ptr->left);
				vistied.add(e_ptr->left);
			}
			if (e_ptr->right != nullptr) {
				q.push(e_ptr->right);
				vistied.add(e_ptr->right);
			}
			//--4.2 N叉树
			for (TreeNode node : e_ptr) {
				if (node not in visited) {
					q.push(node);
					visited.add(node);
				}
			}
		}
		step++;
	}
}

2 BST二叉搜索树

2.1 BST的构造

输入：严格升序的数组nums

class Solution {
public:
    void recursive(vector<int>& nums, TreeNode* root, int left, int right) {
        if (left > right) return;
        int mid = (left + right) / 2;
        root->val = nums[mid];
        if (left < mid)
            root->left = new TreeNode(nums[(left + mid) / 2]);
        if (mid < right)
            root->right = new TreeNode(nums[(mid + right) / 2]);
        recursive(nums, root->left, left, mid - 1);
        recursive(nums, root->right, mid + 1, right);
    }
    TreeNode* sortedArrayToBST(vector<int>& nums) {
        if (nums.empty()) return nullptr;
        TreeNode* root = new TreeNode(0);
        recursive(nums, root, 0, nums.size() - 1);
        return root; 
    }
};

2.2 BST的遍历

class Solution {
public:
    TreeNode* BST(TreeNode* root, int key) {
        if (!root) return nullptr;
        if (key < root->val)
            root->left = BST(root->left, key);
        if (key > root->val)
            root->right = BST(root->right, key);
        if (key == root->val) {
            // 找到目标，做点什么
        }
        return root;
    }
};