day23二叉树最大结点

title: day23二叉树最大结点
author: 龙威旭
date: 2024-06-05 10:15:08
tags: 算法训练营
categories: 算法训练营

day23 二叉树最大结点

参加蓝总算法训练营第二十三天

我的解法

#include <iostream>
#include <climits> // For INT_MIN

// 定义二叉树节点结构体
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};

// 递归函数，用于找到二叉树中最大值的节点
int findMaxValue(TreeNode* root) {
    // 如果当前节点为空，返回一个极小值
    if (root == NULL) {
        return INT_MIN;
    }

    // 递归计算左子树的最大值
    int leftMax = findMaxValue(root->left);
    // 递归计算右子树的最大值
    int rightMax = findMaxValue(root->right);

    // 返回当前节点值、左子树最大值、右子树最大值三者中的最大值
    return std::max(root->val, std::max(leftMax, rightMax));
}

int main() {
    // 创建一个简单的二叉树
    TreeNode* root = new TreeNode(10);
    root->left = new TreeNode(5);
    root->right = new TreeNode(20);
    root->left->left = new TreeNode(3);
    root->left->right = new TreeNode(7);
    root->right->right = new TreeNode(25);

    // 找到二叉树中最大值的节点
    int maxValue = findMaxValue(root);
    std::cout << "The maximum value in the binary tree is: " << maxValue << std::endl;

    // 释放内存
    delete root->left->left;
    delete root->left->right;
    delete root->left;
    delete root->right->right;
    delete root->right;
    delete root;

    return 0;
}
/*
The maximum value in the binary tree is: 25
*/

大佬解法

1. 使⽤深度优先搜索算法遍历⼆叉树，记录最⼤值节点的值和对应的节点指针。

2. 通过递归调⽤实现深度优先搜索，并在遍历过程中更新最⼤值和最⼤值节点。

• 时间复杂度:O(n),n为节点数
• 空间复杂度:O(n)

思路

1. 初始化最⼤值变量为负⽆穷⼤，最⼤值节点指针为空。
2. 从根节点开始进⾏深度优先搜索：
   ◦ 如果当前节点的值⼤于最⼤值，则更新最⼤值和最⼤值节点指针。
   ◦ 递归调⽤遍历左⼦树。
   ◦ 递归调⽤遍历右⼦树。
3. 返回最⼤值节点指针。

基本实现C++

#include <iostream>
#include <limits>
using namespace std;

// 二叉树节点结构
struct TreeNode {
    int val;
    TreeNode* left;
    TreeNode* right;
};

// 深度优先搜索函数
void DFS(TreeNode* node, TreeNode* &maxNode, int& maxVal) {
    if (!node) return;
    // 寻找最大值节点
    if (node->val > maxVal) {
        maxVal = node->val;
        maxNode = node;
    }
    // 递归左右子树
    DFS(node->left, maxNode, maxVal);
    DFS(node->right, maxNode, maxVal);
}

// 找出二叉树中的最大值的节点
TreeNode* findMaxNode(TreeNode* root) {
    if (!root) return nullptr;
    TreeNode* maxNode = nullptr; // 最大值节点
    int maxVal = numeric_limits<int>::min(); // 初始化为最小值
    DFS(root, maxNode, maxVal);
    return maxNode;
}

基本实现C

#include <stdio.h>
#include <limits.h>

// 二叉树节点结构定义
struct TreeNode {
    int val; // 节点的值
    struct TreeNode* left; // 指向左子节点的指针
    struct TreeNode* right; // 指向右子节点的指针
};

// 深度优先搜索函数
// 参数：
// - node: 当前节点
// - maxNode: 指向最大值节点的指针
// - maxVal: 当前已找到的最大值
void DFS(struct TreeNode* node, struct TreeNode** maxNode, int* maxVal) {
    if (!node) return; // 如果节点为空，返回

    // 如果当前节点的值大于当前最大值，更新最大值和最大值节点
    if (node->val > *maxVal) {
        *maxVal = node->val;
        *maxNode = node;
    }

    // 递归处理左子树
    DFS(node->left, maxNode, maxVal);
    // 递归处理右子树
    DFS(node->right, maxNode, maxVal);
}

// 找出二叉树中的最大值节点
// 参数：
// - root: 二叉树的根节点
// 返回值：指向最大值节点的指针
struct TreeNode* findMaxNode(struct TreeNode* root) {
    if (!root) return NULL; // 如果根节点为空，返回NULL

    struct TreeNode* maxNode = NULL; // 用于存储最大值节点
    int maxVal = INT_MIN; // 将最大值初始化为最小整数值

    // 调用深度优先搜索函数
    DFS(root, &maxNode, &maxVal);

    // 返回最大值节点
    return maxNode;
}