1
Para a lista unicamente ligada L sem um nó líder, um algoritmo recursivo é projetado para produzir todos os valores dos nós em uma ordem positiva.
public class Solution1 {
public void printL(ListNode node) {
if (node == null) {
return;
}
System.out.println(node.val);
printL(node.next);
}
}
2
Para a lista unicamente ligada L sem um nó líder, um algoritmo recursivo é projetado para produzir todos os valores de nó em ordem reversa.
public class Solution2 {
public void printL(ListNode node) {
if (node == null) {
return;
}
printL(node.next);
System.out.println(node.val);
}
}
3
Para uma lista L unicamente ligada não vazia sem um nó principal, projete um algoritmo recursivo para retornar o endereço do maior nó (assumindo que tal nó seja único).
public class Solution3 {
public ListNode findMax(ListNode node) {
if (node.next == null) {
return node;
}
return node.val > findMax(node.next).val ? node : findMax(node.next);
}
}
4
Para uma lista L unida unicamente sem um nó principal, um algoritmo recursivo é projetado para retornar o endereço do primeiro nó cujo valor é x, ou nulo se não houver tal nó.
public class Solution4 {
public ListNode findNode(ListNode node, int target) {
if (node == null) {
return null;
}
if (node.val == target) {
return node;
}
return findNode(node.next, target);
}
}
5
Para a lista ligada individualmente L sem um nó líder, um algoritmo recursivo é projetado para excluir o primeiro nó cujo valor é x.
public class Solution5 {
/**
* 虽说是递归，本质还是双/三指针的向右滑动
* 设置一个dummy头结点很有必要
*/
public void deleteNode(ListNode head, int target) {
ListNode dummy = new ListNode(-1);
dummy.next = head;
delete(dummy, head, target);
}
private void delete(ListNode pre, ListNode node, int target) {
if (node == null) {
return;
}
if (node.val == target) {
pre.next = node.next;
return;
}
delete(node, node.next, target);
}
}
6
Assumindo que a árvore binária é armazenada em uma estrutura de armazenamento em cadeia binária e o valor do nó é do tipo int, um algoritmo recursivo é projetado para encontrar a soma de todos os nós folha na árvore bt.
public class Solution6 {
public int nodeSum(TreeNode node) {
if (node == null) {
return 0;
}
if (node.left == null && node.right == null) {
return node.val;
}
return nodeSum(node.left) + nodeSum(node.right);
}
}
7
Supondo que a árvore binária seja armazenada em uma estrutura de armazenamento de cadeia binária e o valor do nó seja do tipo int, um algoritmo recursivo é projetado para encontrar o número de nós na árvore binária bt cujo valor do nó é maior ou igual a k.
public class Solution7 {
public int countNode(TreeNode node, int k) {
if (node == null) {
return 0;
}
return (node.val >= k ? 1 : 0) + countNode(node.left, k) + countNode(node.right, k);
}
}
8
Assumindo que a árvore binária é armazenada em uma estrutura de armazenamento de cadeia binária e todos os valores de nó são diferentes, projete um nível de nó com um valor de algoritmo recursivo de x (com nível de nó 1) e retorne 0 se nenhum nó for encontrado .
public class Solution8 {
public int findLayerOfK(TreeNode node, int k, int level) {
if (node == null) {
return 0;
}
if (node.val == k) {
return level;
}
int t1 = findLayerOfK(node.left, k, level + 1);
int t2 = findLayerOfK(node.right, k, level + 1);
return t1 != 0 ? t1 : t2;
}
}
⭐️ Esta deve ser a solução Java mais bonita em toda a rede> _ <