ForHosting KIT · Outils pour développeurs

Calculateur de nœuds d'arbre de récursion

Comptez les nœuds d'un arbre de récursion de type diviser pour régner : deux sous-problèmes de moitié à partir de 16 donnent 5 niveaux de 1, 2, 4, 8 et 16 nœuds, 31 au total dont 16 feuilles. Vérifiez vos exercices sans dessiner l'arbre. Gratuit dans votre navigateur.

  • Gratuit
  • Fonctionne dans votre navigateur
  • Sans inscription
  • Vos données restent sur votre appareil
Utilisez-le depuis WebAPIE-mailTelegramApp bientôt
Si vous saisissez
Facteur de branchement
2
Rapport de réduction
2
Taille de l'entrée
16
Vous obtenez
Nombre de niveaux
5
Hauteur de l'arbre
4
Total des nœuds
31
Nœuds feuilles
16

Les récurrences de type diviser pour régner de la forme T de n égale a fois T de n sur b plus le travail non récursif apparaissent dans tout cours d'algorithmes lorsque le tri fusion, les partitions spatiales binaires ou la récursion multiway sont dessinés en arbres. Les étudiants ont besoin d'un décompte fiable du nombre de nœuds à chaque niveau et de la profondeur atteinte avant que les sous-problèmes n'atteignent le cas de base. Ce calculateur de nœuds d'arbre de récursion accepte le facteur de branchement a, le rapport de réduction b et la taille d'entrée racine n, parcourt l'arbre jusqu'à ce que la taille du sous-problème soit au plus un, et renvoie le nombre de niveaux, la hauteur, les totaux de nœuds et de feuilles, la séquence de nœuds par niveau, les tailles de sous-problème et deux distributions fractionnaires du travail. L'une suppose un coût unitaire par nœud ; l'autre suppose un travail proportionnel à la taille du sous-problème, comme dans le schéma classique du tri fusion où chaque niveau complet effectue encore un travail linéaire en n.

Ce qu'un arbre de récursion compte et comment les niveaux sont définis

Un arbre de récursion est l'image de chaque sous-problème créé par un algorithme de type diviser pour régner dont le temps satisfait T de n égale a fois T de n sur b plus f de n. La racine représente l'instance d'origine de taille n. Chaque nœud interne a exactement a enfants, chacun résolvant un problème dont la taille est la taille du parent divisée par b.

Les niveaux sont numérotés à partir de zéro à la racine. Au niveau i il y a a puissance i nœuds, et chacun de ces nœuds a une taille de sous-problème n divisée par b puissance i, pourvu que les tailles restent réelles et positives. La marche continue tant que la taille courante est strictement supérieure à un ; le premier niveau dont la taille est inférieure ou égale à un est conservé comme niveau de feuilles des cas de base, puis la marche s'arrête.

Cette convention correspond à la condition d'arrêt des manuels pour résoudre directement les entrées de taille constante. La hauteur de l'arbre est le nombre de niveaux moins un, le nombre d'arêtes sur un chemin de la racine à une feuille. Les nœuds feuilles valent a élevé à la hauteur lorsque les tailles atteignent un sur une puissance exacte, et plus généralement le nombre de nœuds du dernier niveau enregistré.

Les nœuds internes sont le total moins les feuilles. Pour un facteur de branchement un, l'arbre est une seule épine de longueur égale au nombre de divisions successives jusqu'à ce que la taille soit au plus un. Pour un facteur supérieur à un, la forme fermée du total de nœuds sur L niveaux est a puissance L moins un, le tout sur a moins un ; ce point d'accès le recalcule en sommant la série géométrique afin que tailles fractionnaires et cas de base précoces restent cohérents avec la marche.

Quand compter les nœuds de l'arbre aide

Les cours d'algorithmes et les plateformes de tutorat utilisent un calculateur de nœuds d'arbre de récursion pour que les apprenants vérifient profondeur et largeur pour des a, b et n arbitraires sans dessiner des centaines de nœuds à la main. Les générateurs d'examens ont besoin d'un oracle déterministe qui marque comme fausse une prétendue comptée de feuilles ou de niveaux au lieu d'accepter des approximations asymptotiques vagues.

Les outils de préparation aux entretiens et les visualiseurs de complexité associent les tableaux par niveau à des graphiques pour que les candidats voient pourquoi un diviser pour régner équilibré dépense souvent le même travail à chaque niveau lorsque a égale b. Les carnets d'ingénierie qui prototypent des splitters multiway ou des graphes de tâches parallèles peuvent valider le fan-out avant d'écrire des ordonnanceurs de production. Une validation échouée ne consomme pas le solde.

Devoirs et tutorat d'algorithmes

Permettez aux étudiants d'envoyer a, b et n pour T(n)=a T(n/b)+f(n) et de vérifier le nombre de niveaux, les feuilles et la suite géométrique de nœuds face aux figures du manuel.

Notation automatique d'examens et LMS

Évaluez les items d'arbre de récursion avec un oracle déterministe du total de nœuds et de la hauteur au lieu d'accepter des approximations asymptotiques comme réponses exactes.

Combien de nœuds compte l'arbre de récursion du tri fusion ?

Pour une entrée de 16 coupée en deux moitiés à chaque appel, on obtient 5 niveaux de 1, 2, 4, 8 et 16 nœuds. Cela fait 31 nœuds au total, dont 16 feuilles et 15 nœuds internes.

Quand l'arbre s'arrête-t-il de grandir ?

Au premier niveau où la taille du sous-problème descend à 1 ou moins. Ce niveau contient les cas de base. La hauteur vaut le nombre de niveaux moins un : 5 niveaux donnent une hauteur de 4.

Que montrent les deux répartitions du travail ?

L'une suppose que chaque nœud coûte autant, si bien que l'essentiel du travail se trouve dans les feuilles. L'autre suppose un travail proportionnel à la taille, comme dans le tri fusion, où chacun des 5 niveaux fait un cinquième du travail.

Et si chaque appel ne crée qu'un seul sous-problème ?

L'arbre devient alors une simple chaîne, aussi longue que le nombre de divisions nécessaires pour ramener la taille à 1. Le rapport de réduction doit toujours dépasser un, sinon les sous-problèmes ne rapetisseraient jamais.

Tout sur cette page est disponible par programmation. Cette section s'adresse aux équipes qui veulent l'intégrer à leurs systèmes ; les autres peuvent simplement utiliser l'outil ci-dessus.

POSThttps://api.kit.forhosting.com/dev/recursion-tree-nodes

Authentification par jeton Bearer : un seul POST met la tâche en file d’attente, et le résultat vous parvient par webhook ou lien signé.

curl -X POST https://api.kit.forhosting.com/dev/recursion-tree-nodes \
  -H "Authorization: Bearer $KIT_KEY" \
  -H "Content-Type: application/json" \
  -d '{"branching_factor":2,"shrink_ratio":2,"input_size":16}'
{
  "branching_factor": 2,
  "shrink_ratio": 2,
  "input_size": 16
}
{
  "task_id": "tsk_a1b2c3d4e5f6a1b2c3d4e5f6",
  "type": "dev.recursion_tree_nodes",
  "status": "queued",
  "_links": {
    "result": "/tasks/tsk_…/result"
  }
}

L’API est asynchrone : chaque appel renvoie un task_id immédiatement, puis vous interrogez l’état à raison d’une requête par seconde.

par requête$0.002

Le prix est publié, sans tokens ni crédits. Une tâche qui échoue n’est pas facturée.

HTTPCodeSignification
401unauthorizedClé API absente ou invalide : vérifiez l’en-tête Authorization.
402insufficient_balanceSolde insuffisant : rechargez votre compte pour lancer cette tâche.
404unknown_typeType de tâche inconnu : vérifiez le champ type de votre requête.
429rate_limitedTrop de requêtes : ralentissez la cadence, puis réessayez.

Contrat d'entrée, champs de réponse et vues de répartition du travail

La chaîne recurrence reformule T de n en termes de a et b, et le champ formula résume la règle des niveaux et la forme fermée du total de nœuds. Les combinaisons pathologiques qui dépasseraient un plafond sûr de niveaux ou de nœuds sont rejetées avec un message clair pour que les clients ne se bloquent jamais sur un arbre qui explose. Exemple : facteur de branchement deux, rapport de réduction deux, taille d'entrée seize produit cinq niveaux avec les décomptes un, deux, quatre, huit, seize, trente et un nœuds au total et seize feuilles — l'arbre de récursion binaire parfait classique du tri fusion sur un tableau puissance de deux. Envoyez un corps JSON en POST avec trois nombres finis obligatoires : branching_factor, entier supérieur ou égal à un ; shrink_ratio, nombre fini strictement supérieur à un pour que les sous-problèmes se réduisent ; et input_size, nombre fini au moins égal à un pour la racine. Les chaînes numériques sont acceptées ; champs manquants, valeurs non finies, facteurs de branchement non entiers ou inférieurs à un, rapports de réduction non strictement supérieurs à un et tailles de racine inférieures à un échouent avec invalid_input et ne sont pas facturés. En cas de succès le corps renvoie les trois entrées et indique level_count, tree_height, total_nodes, leaf_nodes et internal_nodes. Le tableau nodes_per_level liste combien de nœuds se trouvent à chaque niveau depuis la racine. Le tableau subproblem_size_per_level liste la taille partagée par tous les nœuds de ce niveau, arrondie à douze décimales pour une égalité stable entre runtimes. Deux tableaux de fractions parallèles somment à un : node_fraction_per_level divise le nombre de nœuds de chaque niveau par le total général, modélisant un travail unitaire par appel récursif ; size_work_fraction_per_level pondère chaque niveau par nœuds fois taille du sous-problème, modélisant un travail non récursif proportionnel à la taille en ce nœud.

Où une API de nœuds d'arbre de récursion se justifie

Comme l'implémentation est pure parse de niveau A, chaque appel réussi coûte le prix de base publié $0.002 sans jetons de modèle ni réseau sortant.

Visualiseurs de complexité et entretiens

Alimentez nodes_per_level et size_work_fraction_per_level dans des graphiques pour que les candidats voient comment le travail se répartit entre les niveaux pour des arbres de style tri fusion.

Comment compter les nœuds d'un arbre de récursion diviser pour régner ?

Envoyez branching_factor a entier ≥ 1, shrink_ratio b > 1 et input_size n ≥ 1. L'API parcourt les niveaux avec a^i nœuds de taille n/b^i jusqu'à size ≤ 1 et renvoie les totaux plus les tableaux par niveau.

Quelle est la différence entre level_count et tree_height ?

level_count est le nombre de niveaux y compris la racine (au moins 1). tree_height est level_count moins 1, le nombre d'arêtes sur un chemin de la racine à une feuille.

Comment la distribution du travail est-elle calculée ?

node_fraction_per_level est le nombre de nœuds de chaque niveau sur total_nodes. size_work_fraction_per_level pondère chaque niveau par nœuds fois taille du sous-problème, aligné sur le travail non récursif Θ(size) par appel.

Quand le calculateur rejette-t-il l'entrée ?

Champs manquants ou non finis, branching_factor non entier ou inférieur à un, shrink_ratio ≤ 1, input_size < 1, ou arbres qui dépassent le plafond sûr de niveaux ou de nœuds échouent avec invalid_input et ne sont pas facturés.

Combien coûte le calculateur de nœuds d'arbre de récursion ?

L'outil navigateur est gratuit. Les requêtes API utilisent le solde prépayé KIT à $0.002 par appel réussi ; une entrée invalide n'est pas facturée.

Consulter la documentation complète du KIT →