实习冲刺第二十天

543.二叉树的直径

给你一棵二叉树的根节点，返回该树的 直径 。

二叉树的 直径 是指树中任意两个节点之间最长路径的 长度 。这条路径可能经过也可能不经过根节点 root 。

两节点之间路径的 长度 由它们之间边数表示。

示例 1：

输入：root = [1,2,3,4,5]
输出：3
解释：3 ，取路径 [4,2,1,3] 或 [5,2,1,3] 的长度。

思路详解：这里我们不再采用上几期的方法对二叉树进行正序操作，这里我们先遍历到二叉树的叶子节点然后在递归回退的时候记录左子树和右子树的高度，将他们相加并逐次比较每次相加的值，直到取到最大值返回即可，

代码详解：

class Solution {
public:
    int deepth=0;//记录深度
    int diameterOfBinaryTree(TreeNode* root) {
       depth(root);
       return deepth;
    }
    int depth(TreeNode*root)
    {
        if(root==nullptr)
        {
            return 0;//如果根节点为空返回0
        }
        int left=depth(root->left);//走到左子树的最底端
        int right=depth(root->right);//走到右子树的最底端
        deepth=max(deepth,left+right);//求得左右子树相加的最大值
        return max(left,right)+1;//最后走过的路径需要+1
    }
};

面经：

1. c++的异常处理机制是怎样的，什么情况下使用异常处理，优缺点是什么

C++的异常处理机制提供了一种处理程序运行中发生的错误或异常情况的方法。这种机制通过以下几个关键字来实现：try、catch、throw。

当程序可能出现错误，并且这种错误无法通过正常的流程处理时或当需要区分不同类型的错误，并且针对每种错误采取不同的处理措施时我们需要进行异常处理。

1. try 块：将可能抛出异常的代码放在 try 块中。如果在 try 块中的代码执行时发生异常，它会被抛出。

2. throw 表达式：当发生错误时，使用 throw 关键字来抛出一个异常。异常可以是任何类型的对象。

3. catch 子句：紧跟在 try 块后面的是一系列的 catch 子句，每个 catch 子句都是一个异常处理程序，用来处理特定类型的异常。

异常处理例子：

#include<iostream>
#include<vector>
using namespace std;
 
int main()
{
	vector<int> vec;
	try
	{
		vec.at(4);//数组越界操作
	}
		catch (exception& e)//所有异常的基类，这里是子类引用父类
	{
		cout << 2 << endl;
		cout << e.what() << endl;
	}
 
}

 当然我们也可以定义自己的异常

#include<iostream>
#include<vector>
#include<string>
using namespace std;
class MyExcetion
{
private:
	string msg;
public:
	MyExcetion(string str):msg(str){}
	MyExcetion(const MyExcetion& other)
	{
		this->msg = other.msg;
		cout << "拷贝构造" << endl;
	}
	void what()
	{
		cout << msg << endl;
	}
};
int fun(int a, int b)
{
	if (b == 0)
	{
		MyExcetion m("---异常，除数不能为0---");
		throw m;
	}
	return a / b;
}
 
int main()
{
	try
	{
		fun(1, 0);
	}
	catch (MyExcetion& e)
	{
		e.what();
	}
	cout << "虽有异常但未终止";
}
//运行结果：
//拷贝构造
//---异常，除数不能为0---
//虽有异常但未终止

优点：

异常传递：异常可以跨多个函数调用层次传递到能够处理它的地方。

类型安全：可以指定异常的类型，catch 块可以针对不同类型的异常提供不同的处理方式。

缺点：

性能开销：抛出和捕获异常可能会带来一定的性能损失，尤其是在性能要求很高的场合。

滥用可能导致代码混乱：如果过度使用异常处理，可能会导致代码逻辑不清晰，难以维护。