✅Ejercicio diario: 100. El mismo árbol - LeetCode
El significado del título es que no solo la estructura de los dos árboles debe ser la misma, sino que también el valor de cada nodo debe ser el mismo. Si se cumplen las dos condiciones anteriores, ¡entonces está establecido!
Ideas para resolver problemas:
Considere desde tres aspectos:
1. Si tanto p como q están vacíos, deben ser iguales;
2. Si p está vacío y q no está vacío, o si p no está vacío y q está vacío, entonces debe ser diferente;
3. Si ambos no están vacíos, entonces se debe juzgar el nodo raíz. Si los nodos raíz no son iguales, entonces deben ser diferentes. Si son iguales, debemos comparar los valores de la izquierda y subárboles derechos con la estructura de los subárboles izquierdo y derecho;
código:
public boolean isSameTree(TreeNode p, TreeNode q) {
//如果p,q都为空，那么这2个树一定相同
if (p == null && q == null) {
return true;
}
//如果q为空，p不为空，那么一定不相同,或者p为空，q不为空，那么一定不相同
if (p != null && q == null||p == null && q != null) {
return false;
}
//如果p,q都不为空，那么要判断值，如果值不相同，那么一定不相同
if (p.val != q.val) {
return false;
}
//如果p,q都不为空，并且p,q的值相同，那么要判断p,q的左右子树的值，如果相同为真，反之；
return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}✅Práctica diaria: 572. Subárbol de otro árbol - LeetCode
Ideas para resolver problemas:
1. Si el nodo raíz está vacío, devuelve falso;
2. Si los nodos raíz son iguales, entonces necesitamos juzgar si los dos árboles son iguales, podemos usar el método isSameTree escrito anteriormente para juzgar, si son iguales, entonces subRoot es el subárbol de raíz;
3. Si los nodos raíz no son los mismos, necesitamos encontrar si hay un árbol con la misma subRaíz en el subárbol izquierdo o en el subárbol derecho;
código:
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
if(root == null||subRoot == null){
return false;
}
//判断2棵树是否相同
if(isSameTree(root,subRoot)){
return true;
}
//判断左子树是否有subRoot
if(isSubtree(root.left,subRoot)){
return true;
}
//判断右子树是否有subRoot
if(isSubtree(root.right,subRoot)){
return true;
}
return false;
}
public boolean isSameTree(TreeNode p, TreeNode q) {
//如果p,q都为空，那么这2个树一定相同
if (p == null && q == null) {
return true;
}
//如果q为空，p不为空，那么一定不相同
if (p != null && q == null) {
return false;
}
//如果p为空，q不为空，那么一定不相同
if (p == null && q != null) {
return false;
}
//如果p,q都不为空，那么要判断值，如果值不相同，那么一定不相同
if (p.val != q.val) {
return false;
}
//如果p,q都不为空，并且p,q的值相同，那么要判断p,q的左右子树的值，如果相同为真，反之；
return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
}✅Práctica diaria: 226. Voltear árbol binario - LeetCode
Ideas para resolver problemas:
Usando la idea de recursividad, si el nodo raíz no está vacío, intercambie recursivamente los valores de los subárboles izquierdo y derecho;
public TreeNode invertTree(TreeNode root) {
if (root == null) {
return null;
}
TreeNode tmp = root.left;
root.left = root.right;
root.right = tmp;
invertTree(root.left);
invertTree(root.right);
return root;
}✅Ejercicio diario: 110. Equilibrar un árbol binario - LeetCode
Ideas para resolver problemas:
El significado del título es que el valor absoluto de la diferencia de altura entre los subárboles izquierdo y derecho de cada nodo no puede exceder de 1, es decir, un árbol binario balanceado, que cumple con las necesidades del título;
código:
public boolean isBalanced(TreeNode root) {
if(root == null){
return true;
}
int leftH = getHeight(root.left);
int rightH =getHeight(root.right);
return Math.abs(leftH-rightH)<=1 && isBalanced(root.left) && isBalanced(root.right);
}
public int getHeight(TreeNode root) {
if (root == null) {
return 0;
}
int leftHeight = getHeight(root.left);
int rightHeight = getHeight(root.right);
return leftHeight > rightHeight ? leftHeight + 1 : rightHeight + 1;
}✅Práctica diaria: 101. Árbol binario simétrico - LeetCode
Ideas para resolver problemas:
1. Si el nodo raíz está vacío, es simétrico;
2. Si el nodo raíz no está vacío, el subárbol izquierdo del nodo raíz está vacío, el subárbol derecho del nodo raíz no está vacío o el subárbol izquierdo del nodo raíz no está vacío y el subárbol derecho de la raíz el nodo está vacío, entonces debe ser asimétrico;
3. Si el valor del subárbol izquierdo del nodo raíz no es igual al valor del subárbol derecho, entonces debe ser asimétrico;
4. Si no se cumple ninguna de las condiciones anteriores, debemos juzgar si el subárbol izquierdo del subárbol izquierdo es igual al subárbol derecho del subárbol derecho, y si el subárbol derecho del subárbol izquierdo es igual al subárbol izquierdo. del subárbol derecho Simétrico si es igual;
código:
public boolean isSymmetric(TreeNode root) {
if (root == null) {
return true;
}
return isSymmetricChild(root.left, root.right);
}
public boolean isSymmetricChild(TreeNode leftTree, TreeNode rightTree) {
if (leftTree == null && rightTree == null) {
return true;
}
if (leftTree != null && rightTree == null || leftTree == null && rightTree != null) {
return false;
}
if (leftTree.val != rightTree.val) {
return false;
}
return isSymmetricChild(leftTree.left, rightTree.right) && isSymmetricChild(leftTree.right, rightTree.left);
}✅Ejercicio diario: 102. Recorrido de orden de niveles del árbol binario - LeetCode
Ideas para resolver problemas:
El recorrido jerárquico es un recorrido de arriba a abajo y de izquierda a derecha. El recorrido jerárquico es más simple que otros recorridos, pero el código no es tan simple de implementar. Podemos usar colas para implementarlo y usar las características de las colas para lograr primero- entrar primero salir:
Primero juzgue el nodo raíz, si está vacío, regrese, si no está vacío, coloque el nodo raíz en la cola, use el ciclo while para juzgar si la cola actual está vacía, luego defina una variable para almacenar el valor del nodo raíz, y luego imprimir, imprimir Después de eso, juzgue los subárboles izquierdo y derecho del nodo raíz. Si no están vacíos, se unirán a la cola, y podemos obtener el orden jerárquico transversal ejecutándolos secuencialmente. El código:
public void levelOrder1(TreeNode root) {
if (root == null) {
return;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
TreeNode cur = queue.poll();
System.out.print(cur.val + " ");
if (cur.left != null) {
queue.offer(cur.left);
}
if (cur.right != null) {
queue.offer(cur.right);
}
}
}Este es un método sin valor de retorno, pero el valor de retorno de esta pregunta oj es List<List<Integer>>, por lo que tenemos que escribir esta pregunta de otra manera. La idea general es que necesitamos un ciclo de 2, use si la cola actual está vacía como la condición del primer bucle y el número de elementos en la cola actual como la condición del bucle secundario, codifique:
public List<List<Integer>> levelOrder(TreeNode root) {
List<List<Integer>> list = new ArrayList<>();
if (root == null) {
return list;
}
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
while (!queue.isEmpty()) {
int size = queue.size();//用来判断当前队列的大小
//System.out.print(cur.val);
List<Integer> tmp = new ArrayList<>();
while (size != 0) {
TreeNode cur = queue.poll();
tmp.add(cur.val);
size--;
if (cur.left != null) {
queue.offer(cur.left);
}
if (cur.right != null) {
queue.offer(cur.right);
}
}
list.add(tmp);//将每层的结果放到list中
}
return list;
}