INT_MIN的用法：

INT_MIN是C/C++ 中的一个宏常量 ，在  <limits.h>  （C++ 中也可使用  <climits>  ）头文件中定义，代表  int  类型能表示的最小整数值 。其用法主要体现在以下方面：

1.初始化变量

在需要找出数据集合（如数组、链表等）中的最大值场景里，常将用于记录最大值的变量初始化为  INT_MIN  。例如：

#include <iostream>
#include <limits.h>
int main() {
    int arr[] = {10, 5, 20, 8};
    int maxVal = INT_MIN;
    for (int num : arr) {
        if (num > maxVal) {
            maxVal = num;
        }
    }
    cout << "数组中的最大值是: " << maxVal << endl; 
    return 0;
} 

这样初始化能保证在遍历第一个元素时，无论其值是多少，都可更新  maxVal  ，进而正确找出集合中的最大值。

2.边界条件判断

在编写算法或程序时，可用于设置边界条件。比如在判断一个整数运算结果是否合法时，可将结果与  INT_MIN  比较。假设编写一个函数计算两个  int  类型数相加，为防止溢出，可进行如下判断：

#include <iostream>
#include <limits.h>
int add(int a, int b) {
    if (b > 0 && a > INT_MAX - b) { // 防止正溢出
        // 处理溢出情况，如返回特定值或抛出异常
        cerr << "加法运算发生正溢出" << endl;
        return INT_MAX; 
    }
    if (b < 0 && a < INT_MIN - b) { // 防止负溢出
        cerr << "加法运算发生负溢出" <<endl;
        return INT_MIN; 
    }
    return a + b;
}
int main() {
    int num1 = 1000000000;
    int num2 = 2000000000;
    int result = add(num1, num2);
    cout << "计算结果: " << result << endl; 
    return 0;
} 

3. 检测溢出

在进行整数运算时，通过与  INT_MIN  比较来检测是否发生下溢。例如：

#include <iostream>
#include <limits.h>
int main() {
    int num = INT_MIN;
    int sub = num - 1;
    if (sub > num) { // 正常减法结果应更小，若出现变大则发生下溢
        std::cerr << "发生下溢" << std::endl;
    }
    return 0;
} 

515. 在每个树行中找最大值

给定一棵二叉树的根节点 root ，请找出该二叉树中每一层的最大值。

示例1：

输入: root = [1,3,2,5,3,null,9]
输出: [1,3,9]

示例2：

输入: root = [1,2,3]
输出: [1,3]

class Solution {
public:
    vector<int> largestValues(TreeNode* root) {
        queue<TreeNode*>que;
        if(root!=NULL) que.push(root);
        vector<int>result;
        while(!que.empty()){
            int size=que.size();
            int maxValue=INT_MIN;
            for(int i=0;i<size;i++){
                TreeNode*node=que.front();
                que.pop();
                maxValue=node->val>maxValue?node->val:maxValue;
                if(node->left) que.push(node->left);
                if(node->right) que.push(node->right);
            }
            result.push_back(maxValue);
        }
        return result;
    }
};