[Leetcode -637. El promedio de capa del árbol binario -671. El segundo nodo más pequeño del árbol binario]

Leetcode -637 Nivel promedio del árbol binario

Pregunta : Dada la raíz del nodo raíz de un árbol binario no vacío, devuelve el valor promedio de los nodos en cada nivel en forma de matriz. Se aceptan respuestas dentro de 10^(- 5) de la respuesta real.

Ejemplo 1:

Entrada: raíz = [3, 9, 20, nulo, nulo, 15, 7]
Salida: [3.00000, 14.50000, 11.00000]
Explicación: El valor promedio de la capa 0 es 3 y el valor promedio de la capa 1 es 14,5, el valor medio para la capa 2 es 11.
Entonces se devuelve [3, 14.5, 11].

Ejemplo 2:

Entrada: raíz = [3, 9, 20, 15, 7]
Salida: [3.00000, 14.50000, 11.00000]

Consejo:
el número de nodos del árbol está en el rango [1, 104]

• 2^31 <= Valor.nodo <= 2^31 - 1

Idea : Es necesario crear un total de tres matrices. La matriz SumVal registra la suma de los nodos en cada capa; la matriz CountLevels registra el número de nodos en cada capa; la matriz ret registra el valor promedio de cada capa, que se calcula usando las dos primeras matrices y luego colocándolas en la matriz ret, finalmente devueltas;

		void dfs(struct TreeNode* root, double* SumVal, int* CountLevels, int level, int* posSumSize, int* posCountSize)
		{
		    if (root == NULL)
		        return;
		
		    // level 是记录当前节点所在的层数
		    if (level < *posSumSize)
		    {
		        SumVal[level] += (double)root->val;
		        CountLevels[level] += 1;
		    }
		
		    //每次递归到新的一层，就会将最左边的节点的值累加到下标为 posSumSize 位置的 SumVal 数组中
		    //并将 CountLevels 数组中下标为 posCountSize 的位置置1
		    else
		    {
		        SumVal[(*posSumSize)++] = (double)root->val;
		        CountLevels[(*posCountSize)++] = 1;
		    }
		    
		    //递归其左子树和右子树，层数加一
		    dfs(root->left, SumVal, CountLevels, level + 1, posSumSize, posCountSize);
		    dfs(root->right, SumVal, CountLevels, level + 1, posSumSize, posCountSize);
		
		}
		
		double* averageOfLevels(struct TreeNode* root, int* returnSize)
		{
		    //SumVal 数组存放每一层的节点和；CountLevels 数组存放每一层的节点数
		    double* SumVal = (double*)malloc(sizeof(double) * 10000);
		    int* CountLevels = (int*)malloc(sizeof(int) * 10000);
		
		    //posSumSize 和 posCountSize 分别记录两个数组的长度
		    int posSumSize = 0, posCountSize = 0;
		
		    //深度优先搜索
		    dfs(root, SumVal, CountLevels, 0, &posSumSize, &posCountSize);
		
		    //返回数组的长度
		    *returnSize = posSumSize;
		
		    //ret 数组存放每一层的平均值
		    double* ret = (double*)malloc(sizeof(double) * posSumSize);
		    for (int i = 0; i < posSumSize; i++)
		    {
		        ret[i] = SumVal[i] / CountLevels[i];
		    }
		
		    return ret;
		}

Leetcode -671. El segundo nodo más pequeño del árbol binario.

Pregunta : Dado un árbol binario especial no vacío, cada nodo es un número positivo y el número de nodos secundarios de cada nodo solo puede ser 2 o 0. Si un nodo tiene dos nodos secundarios, entonces el valor del nodo es igual al menor de los dos nodos secundarios.

Más formalmente, root.val = min(root.left.val, root.right.val) siempre se cumple.
Dado un árbol binario de este tipo, debe generar el segundo valor más pequeño entre todos los nodos.
Si el segundo valor más pequeño no existe, genera -1.

Ejemplo 1:

Entrada: raíz = [2, 2, 5, nulo, nulo, 5, 7]
Salida: 5
Explicación: El valor más pequeño es 2 y el segundo valor más pequeño es 5.

Ejemplo 2:

Entrada: raíz = [2, 2, 2]
Salida: - 1
Explicación: El valor más pequeño es 2, pero no existe un segundo valor más pequeño.

Consejo:
El número de nodos en el árbol está en el rango [1, 25]
1 <= Node.val <= 2^31 - 1.
Para cada nodo en el árbol root.val == min(root.left.val , raíz.derecha.val)

Idea : debido a que cada nodo del árbol satisface root.val == min(root.left.val, root.right.val), el nodo raíz es el nodo más pequeño y necesitamos encontrar nodos más grandes que el nodo raíz. El nodo más pequeño es el segundo nodo más pequeño del árbol;

		void dfs(struct TreeNode* root, int* ret, int rootval)
		{
		    if (root == NULL)
		        return;
		
		    //如果 ret 已被更改，且当前节点的值大于当前 ret 的值，就返回
		    //因为 ret 要找的是比根节点大的值中最小的值
		    if (*ret != -1 && root->val >= *ret)
		        return;
		
		    // rootval 是根节点的值，根节点就是最小的值，找出比它大的数中最小的那个即可
		    // 如果节点的值比当前 ret 大，会在上面直接返回
		    if (root->val > rootval)
		        *ret = root->val;
		
		    //递归其左子树和右子树
		    dfs(root->left, ret, rootval);
		    dfs(root->right, ret, rootval);
		}
		
		int findSecondMinimumValue(struct TreeNode* root)
		{
		    //返回值初始化为 -1
		    int ret = -1;
		    dfs(root, &ret, root->val);
		    return ret;
		}