Introduction à l'utilisation des requêtes de structure arborescente Java

En Java, la requête de structure arborescente implémente principalement des opérations de requête sur des données de structure arborescente spécifiques via des structures de données spécifiques et des algorithmes associés, obtenant ainsi des informations sur un ou plusieurs nœuds de l'arborescence.

1. Structures de données arborescentes couramment utilisées

En Java, les structures arborescentes couramment utilisées comprennent les arbres binaires, les arbres binaires équilibrés, les arbres rouge-noir, les arbres B, les arbres B+, etc.

Ici, nous prenons un arbre binaire comme exemple pour définir un simple nœud d'arbre binaire.

    classe publique TreeNode { 
        int val; 
        TreeNode gauche ; 
        TreeNode à droite ; 
        NoeudArbre(int x) { val = x; } 
    }

2. Algorithme de requête d'arborescence

Les algorithmes de requête de structure arborescente couramment utilisés incluent la recherche en profondeur d'abord (DFS) et la recherche en largeur d'abord (BFS).

Voici un exemple de code Java qui utilise l'implémentation récursive de la recherche en profondeur :

    public boolean DFS (TreeNode root, int target) { 
        if (root == null) return false ; 
        if (root.val == target) renvoie vrai ; 
        retourner DFS(root.left, cible) || DFS(root.right, cible); 
    }

Voici un exemple de code Java qui utilise une file d'attente pour implémenter une recherche en largeur :

    public boolean BFS (racine TreeNode, cible int) { 
        Queue<TreeNode> file d'attente = new LinkedList<>(); 
        queue.offer(racine); 
        while (!queue.isEmpty()) { 
            Noeud TreeNode = queue.poll(); 
            if (node.val == target) renvoie vrai ; 
            if (node.left != null) queue.offer(node.left); 
            if (node.right != null) queue.offer(node.right); 
        } 
        renvoie faux ; 
    }

3. Construire un arbre de requête

Dans le développement réel, nous devons généralement construire une arborescence de requêtes pour répondre à des exigences de requête spécifiques.

Ce qui suit est une méthode de construction d'arbre binaire basée sur ArrayList :

    public TreeNode constructTree(ArrayList<Integer> nums) { 
        if (nums == null || nums.size() == 0) renvoie null ; 
        Racine de TreeNode = new TreeNode(nums.get(0)); 
        Queue<TreeNode> queue = new LinkedList<>(); 
        queue.offer(racine); 
        for (int i = 1; i < nums.size(); i += 2) { 
            Noeud TreeNode = queue.poll(); 
            node.left = nums.get(i) != null ? new TreeNode(nums.get(i)) : null; 
            if (i + 1 < nums.size()) { 
                node.right = nums.get(i + 1) != null ? new TreeNode(nums.get(i + 1)) : null; 
            } 
            if (node.left != null) queue.offer(node.left); 
            if (node.right != null) queue.offer(node.right);
        } 
        renvoie la racine ; 
    }