Après avoir travaillé dur pendant tant d'années, avec le recul, ce ne sont presque que de longs revers et des souffrances. Pour la plupart des gens, la navigation en douceur n'est qu'occasionnelle, et la frustration, l'insupportable, l'anxiété et la confusion sont le thème principal. Nous prenons la scène que nous n'avons pas choisie, jouons le scénario que nous n'avons pas choisi. Continuer!
Table des matières
1. Parcours pré-ordonné de l'arbre binaire
2. Parcours dans l'ordre d'un arbre binaire
3. Parcours post-ordre de l'arbre binaire
4. Trouver le parcours d'ordre de niveau de l'arbre binaire
5. Imprimer l'arbre binaire en ordre zigzag
6. La profondeur maximale de l'arbre binaire
7. Le chemin qui totalise une certaine valeur dans l'arbre binaire (1)
8. Arbre de recherche binaire et liste doublement liée
10. Fusionner des arbres binaires
11. Image miroir de l'arbre binaire
12. Déterminez s'il s'agit d'un arbre de recherche binaire
13. Déterminer s'il s'agit d'un arbre binaire complet
14. Déterminer s'il s'agit d'un arbre binaire équilibré
15. L'ancêtre commun le plus proche de l'arbre de recherche binaire
16. Trouver l'ancêtre commun le plus proche de deux nœuds dans un arbre binaire
17. Reconstruire l'arbre binaire
1. Parcours pré-ordonné de l'arbre binaire
Lien vers le sujet : Traversée de précommande de l'arbre binaire
Idée : appelez la fonction de parcours de préordre pour stocker le résultat dans la collection, puis passez-le dans le tableau, et parcours de préordre : nœud racine, sous-arbre gauche, sous-arbre droit.
VersionJava :
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* public TreeNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param root TreeNode类
* @return int整型一维数组
*/
public void preOrder(TreeNode root, List<Integer> lst){
if(root == null){
return ;
}
lst.add(root.val) ;
preOrder(root.left, lst) ;
preOrder(root.right, lst) ;
}
public int[] preorderTraversal (TreeNode root) {
// write code here
List<Integer> lst = new ArrayList<>() ;
preOrder(root, lst) ;
int [] ans = new int [lst.size()] ;
int i = 0;
for(int num : lst){
ans[i++] = num ;
}
return ans ;
}
}
2. Parcours dans l'ordre d'un arbre binaire
Lien vers le sujet : Traversée dans l'ordre d'un arbre binaire_Niuke题霸_Niuke.com
Idée : C'est la même chose que l'idée de préordre, sauf que le sous-arbre de gauche est le premier, puis le nœud racine et enfin le sous-arbre de droite.
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* public TreeNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param root TreeNode类
* @return int整型一维数组
*/
public int[] inorderTraversal (TreeNode root) {
// write code here
List<Integer> lst = new ArrayList<>() ;
inOrder(root, lst) ;
int i = 0 ;
int [] ans = new int [lst.size()] ;
for(int num : lst){
ans[i++] = num ;
}
return ans ;
}
public void inOrder(TreeNode root, List<Integer> lst){
if(root == null){
return ;
}
inOrder(root.left, lst) ;
lst.add(root.val) ;
inOrder(root.right, lst) ;
}
}
3. Parcours post-ordre de l'arbre binaire
Lien vers le sujet : Parcours post-ordre d'un arbre binaire_Niuke题霸_Niuke.com
Idée : d'abord le sous-arbre gauche, puis le sous-arbre droit et enfin le nœud racine.
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* public TreeNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param root TreeNode类
* @return int整型一维数组
*/
public int[] postorderTraversal (TreeNode root) {
// write code here
List<Integer> lst = new ArrayList<>() ;
postOrder(root, lst) ;
int i = 0 ;
int [] ans = new int [lst.size()] ;
for(int num : lst){
ans[i++] = num ;
}
return ans ;
}
public void postOrder(TreeNode root, List<Integer> arraylist){
if(root == null){
return ;
}
postOrder(root.left,arraylist) ;
postOrder(root.right,arraylist) ;
arraylist.add(root.val) ;
}
}4. Trouver le parcours d'ordre de niveau de l'arbre binaire
Lien vers le sujet : Trouver le parcours d'ordre de niveau d'un arbre binaire
Idée : en s'appuyant sur la fonctionnalité premier entré, premier sorti de la file d'attente, tous les éléments de chaque couche sont retirés de la file d'attente et stockés dans la collection, et tous les éléments de la couche suivante sont mis en file d'attente.
VersionJava :
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类
* @return int整型ArrayList<ArrayList<>>
*/
public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
// write code here
ArrayList<ArrayList<Integer>> lst = new ArrayList<>() ;
Queue<TreeNode> queue = new LinkedList<>() ;
if(root == null){
return lst ;
}
queue.add(root) ;
while(!queue.isEmpty()){
int s = queue.size() ;
ArrayList<Integer> list = new ArrayList<>() ;
for(int i=0; i<s; i++){
TreeNode node = queue.poll() ;
list.add(node.val) ;
if(node.left != null){
queue.offer(node.left) ;
}
if(node.right != null){
queue.offer(node.right) ;
}
}
lst.add(list) ;
}
return lst ;
}
}5. Imprimer l'arbre binaire en ordre zigzag
Lien vers le sujet : Imprimer l'arbre binaire dans l'ordre en zigzag
Idée : à l'aide de files d'attente, chaque couche entre dans la file d'attente et toutes sont retirées de la file d'attente dans la collection. S'il s'agit d'une couche paire, les éléments de la collection sont inversés.
VersionJava :
import java.util.*;
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
public ArrayList<ArrayList<Integer> > Print(TreeNode pRoot) {
ArrayList<ArrayList<Integer>> lst = new ArrayList<>() ;
Queue<TreeNode> queue = new LinkedList<>() ;
if(pRoot == null){
return lst ;
}
queue.offer(pRoot) ;
int level = 1 ;
while(!queue.isEmpty()){
int size = queue.size() ;
ArrayList<Integer> list = new ArrayList<>() ;
for(int i=0; i<size; i++){
TreeNode node = queue.poll() ;
list.add(node.val) ;
if(node.left !=null){
queue.add(node.left) ;
}
if(node.right != null){
queue.add(node.right) ;
}
}
if(level%2==0){
Collections.reverse(list) ;
}
level ++ ;
lst.add(list) ;
}
return lst ;
}
}6. La profondeur maximale de l'arbre binaire
Lien vers le sujet : La profondeur maximale d'un arbre binaire
Idée : à l'aide des files d'attente, de la traversée des couches, chaque couche entre dans la file d'attente, enregistre le nombre de couches, puis sort de la file d'attente.
VersionJava :
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类
* @return int整型
*/
public int maxDepth (TreeNode root) {
// write code here
Queue<TreeNode> queue = new LinkedList<>();
if(root == null){
return 0 ;
}
int level = 0;
queue.offer(root) ;
while(!queue.isEmpty()){
level ++ ;
int size = queue.size() ;
for(int i=0; i<size; i++){
TreeNode node = queue.poll() ;
if(node.left != null){
queue.offer(node.left) ;
}
if(node.right != null){
queue.offer(node.right) ;
}
}
}
return level ;
}
}7. Le chemin qui totalise une certaine valeur dans l'arbre binaire (1)
Lien vers le sujet : Le chemin d'une certaine valeur dans un arbre binaire (1)
Idée : Implémentation récursive, chaque fois parcourez de manière récursive les sous-arbres gauche et droit et accumulez la valeur du nœud actuel, si la condition est remplie, retournez vrai
VersionJava :
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类
* @param sum int整型
* @return bool布尔型
*/
public boolean hasPathSum (TreeNode root, int sum) {
// write code here
if(root == null){
return false ;
}
int s = 0 ;
return preOrder(root, sum, s) ;
}
public boolean preOrder(TreeNode root, int sum, int s){
if(root == null){
return false ;
}
s += root.val ;
if(root.left == null && root.right == null && s==sum){
return true ;
}
return preOrder(root.left, sum, s) || preOrder(root.right, sum, s) ;
}
}8. Arbre de recherche binaire et liste doublement liée
Lien vers le sujet : arbre de recherche binaire et liste
doublement liée
VersionJava :
/**
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
TreeNode root = null ;
TreeNode pre = null ;
public TreeNode Convert(TreeNode pRootOfTree) {
//二叉搜索树，也是二叉排序树，左子树小于根节点，右子树大于根节点
//如果中序遍历，则可以由小到大获取元素
if(pRootOfTree == null){
return null ;
}
Convert(pRootOfTree.left) ;
if(pre == null){
pre = pRootOfTree ;
root = pre ;
}else{
//修改双向指针，并更新当前节点为前驱节点
pre.right = pRootOfTree ;
pRootOfTree.left = pre ;
pre = pRootOfTree ;
}
Convert(pRootOfTree.right) ;
return root ;
}
}9. Arbre binaire symétrique
Lien vers le sujet : Arbre binaire symétrique_Niuke Topic_Niuke.com
Idée : juger de manière itérative si le sous-arbre gauche et le sous-arbre droit des deux arbres sont cohérents.
VersionJava :
/*
public class TreeNode {
int val = 0;
TreeNode left = null;
TreeNode right = null;
public TreeNode(int val) {
this.val = val;
}
}
*/
public class Solution {
boolean isSymmetrical(TreeNode pRoot) {
return f(pRoot, pRoot) ;
}
boolean f(TreeNode root1, TreeNode root2){
if(root1==null && root2 == null){
return true ;
}
if(root1 == null || root2 == null){
return false ;
}
if(root1.val != root2.val){
return false ;
}
return f(root1.left, root2.right) && f(root1.right, root2.left) ;
}
}
10. Fusionner des arbres binaires
Lien vers le sujet : Fusionner des arbres binaires_Niuke Topic_Niuke.com
Idée : fusionner l'arbre binaire de manière récursive, le fusionner dans le sous-arbre de gauche et enfin renvoyer le sous-arbre de gauche.
VersionJava :
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param t1 TreeNode类
* @param t2 TreeNode类
* @return TreeNode类
*/
public TreeNode mergeTrees (TreeNode t1, TreeNode t2) {
// write code here
if(t1 == null){
return t2 ;
}
if(t2 == null){
return t1 ;
}
t1.val = t1.val + t2.val ;
if(t2.left != null){
t1.left = mergeTrees(t1.left, t2.left) ;
}
if(t2.right != null){
t1.right = mergeTrees(t1.right, t2.right) ;
}
return t1 ;
}
}11. Image miroir de l'arbre binaire
Lien vers le sujet : Image miroir de Binary Tree_Niuke题霸_Niuke.com
Idée : Traversez récursivement les sous-arbres gauche et droit, échangez simplement les sous-arbres gauche et droit à chaque fois.
VersionJava :
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* public TreeNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param pRoot TreeNode类
* @return TreeNode类
*/
public TreeNode Mirror (TreeNode pRoot) {
// write code here
if(pRoot == null){
return null ;
}
TreeNode tmp = pRoot.left ;
tmp = pRoot.left ;
pRoot.left = pRoot.right ;
pRoot.right = tmp ;
Mirror(pRoot.left) ;
Mirror(pRoot.right) ;
return pRoot ;
}
}12. Déterminez s'il s'agit d'un arbre de recherche binaire
Lien vers le sujet : Déterminer s'il s'agit d'un arbre de recherche binaire
Idée : parcours dans l'ordre, stocker la valeur, puis juger si les éléments augmentent à leur tour.
VersionJava :
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* public TreeNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param root TreeNode类
* @return bool布尔型
*/
public boolean isValidBST (TreeNode root) {
// write code here
ArrayList<Integer> list = new ArrayList<>() ;
inOrder(root, list) ;
for(int i=1; i<list.size(); i++){
if(list.get(i-1) >= list.get(i)){
return false ;
}
}
return true ;
}
public void inOrder(TreeNode root, ArrayList<Integer> list){
if(root == null){
return ;
}
inOrder(root.left, list) ;
list.add(root.val) ;
inOrder(root.right, list) ;
}
}
13. Déterminer s'il s'agit d'un arbre binaire complet
Lien vers le sujet : Juger s'il s'agit d'un arbre binaire complet
Idée : Selon le principe du premier entré, premier sorti de la file d'attente, si le nœud courant est vide, tous les nœuds suivants doivent être vides.
VersionJava :
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* public TreeNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param root TreeNode类
* @return bool布尔型
*/
public boolean isCompleteTree (TreeNode root) {
// write code here
//当前节点为空，后面的节点必须全为空
Queue<TreeNode> queue = new LinkedList<>() ;
if(root == null){
return true ;
}
queue.add(root) ;
boolean flag = false ;
while(!queue.isEmpty()){
TreeNode node = queue.poll() ;
if(node == null){
flag = true ;
}else{
if(flag){
return false ;
}
queue.add(node.left) ;
queue.add(node.right) ;
}
}
return true ;
}
}
14. Déterminer s'il s'agit d'un arbre binaire équilibré
Lien vers le sujet : Juger si un arbre binaire est équilibré
Idée : Calculez la profondeur de l'arbre binaire et jugez si la différence entre les profondeurs des sous-arbres gauche et droit est supérieure à 1.
VersionJava :
public class Solution {
public boolean IsBalanced_Solution(TreeNode root) {
if(root == null){
return true ;
}
int left = depth(root.left) ;
int right = depth(root.right) ;
if(Math.abs(left - right) > 1){
return false ;
}
return IsBalanced_Solution(root.left) && IsBalanced_Solution(root.right) ;
}
public int depth(TreeNode root){
if(root == null){
return 0 ;
}
int left = depth(root.left) ;
int right = depth(root.right) ;
return Math.max(left, right) + 1 ;
}
}15. L'ancêtre commun le plus proche de l'arbre de recherche binaire
Lien vers le sujet : L'ancêtre commun le plus proche d'un arbre de recherche binaire
Idée : L'arbre de recherche binaire satisfait la nature ordonnée du parcours inorder, du parcours récursif et trouve l'ancêtre commun le plus proche.
VersionJava :
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* public TreeNode(int val) {
* this.val = val;
* }
* }
*/
public class Solution {
/**
* 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
*
*
* @param root TreeNode类
* @param p int整型
* @param q int整型
* @return int整型
*/
public int lowestCommonAncestor (TreeNode root, int p, int q) {
// write code here
return find(root, p, q).val ;
}
public TreeNode find(TreeNode root, int p, int q) {
if ((p <= root.val && q >= root.val) || (p >= root.val && q <= root.val)) {
return root ;
} else if (p <= root.val && q <= root.val) {
return find(root.left, p, q) ;
}else{
return find(root.right, p, q) ;
}
}
}
16. Trouver l'ancêtre commun le plus proche de deux nœuds dans un arbre binaire
Lien vers le sujet : Trouver l'ancêtre commun le plus proche de deux nœuds dans un arbre binaire
Idée : Rechercher de manière récursive à partir des sous-arbres gauche et droit à tour de rôle, revenir s'il est trouvé et revenir au nœud racine s'il n'est pas trouvé.
VersionJava :
import java.util.*;
/*
* public class TreeNode {
* int val = 0;
* TreeNode left = null;
* TreeNode right = null;
* }
*/
public class Solution {
/**
*
* @param root TreeNode类
* @param o1 int整型
* @param o2 int整型
* @return int整型
*/
public int lowestCommonAncestor (TreeNode root, int o1, int o2) {
// write code here
return find(root, o1, o2).val ;
}
public TreeNode find(TreeNode root, int o1, int o2) {
if (root == null || root.val == o1 || root.val == o2) {
return root ;
}
TreeNode left = find(root.left, o1, o2) ;
TreeNode right = find(root.right, o1, o2) ;
if(left == null){
return right ;
}
if(right == null){
return left ;
}
return root ;
}
}17. Reconstruire l'arbre binaire
Lien vers le sujet : Reconstruire un arbre binaire_Niuke Topic_Niuke.com
Idée : Trouvez le nœud racine et construisez de manière récursive les sous-arbres gauche et droit.
VersionJava :
import java.util.*;
/**
* Definition for binary tree
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode(int x) { val = x; }
* }
*/
public class Solution {
public TreeNode reConstructBinaryTree(int [] pre,int [] vin) {
//二叉树的先序用来找到根节点，二叉树的中序遍历用来找到左右子树
if(pre.length == 0 || vin.length == 0){
return null ;
}
TreeNode root = new TreeNode(pre[0]) ;
for(int i=0; i<vin.length;i++){
if(pre[0] == vin[i]){
root.left = reConstructBinaryTree(Arrays.copyOfRange(pre,1,i+1),Arrays.copyOfRange(vin, 0, i)) ;
root.right = reConstructBinaryTree(Arrays.copyOfRange(pre,i+1,pre.length), Arrays.copyOfRange(vin,i+1,vin.length)) ;
break ;
}
}
return root ;
}
}Un voyage de mille lieues commence par un seul pas, et le voyage des coups d'automne arrivera bientôt.