0Pricing
TypeScript Academy · Aula

Definindo Tipos de Estruturas em Árvore

Modele nós de árvore aninhados com tipos recursivos.

Definindo Tipos de Estruturas em Árvore é uma aula grátis de TypeScript Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de TypeScript Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de TypeScript Academy inclui 4 aulas no total.

Um Tipo de Nó de Árvore

Árvores generalizam listas: cada nó tem um valor e um array de nós filhos do mesmo tipo. Este é um tipo recursivo com um array children.

type TreeNode<T> = {
  value: T;
  children: TreeNode<T>[];
};
const leaf: TreeNode<number> = { value: 1, children: [] };
console.log(leaf.value);

Criando uma Árvore Pequena

Um nó com filhos é apenas formado por objetos aninhados. O array vazio é o caso base natural para um leaf.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
const tree: TreeNode<string> = {
  value: "root",
  children: [
    { value: "a", children: [] },
    { value: "b", children: [] }
  ]
};
console.log(tree.children.length);

Aninhando em Mais Profundidade

Os filhos podem ter seus próprios filhos em qualquer profundidade, porque cada filho é, por si só, um TreeNode completo.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
const tree: TreeNode<number> = {
  value: 1,
  children: [
    { value: 2, children: [{ value: 4, children: [] }] },
    { value: 3, children: [] }
  ]
};
console.log(tree.children[0].children[0].value);

Somando Todos os Valores

Uma função recursiva visita cada nó e recorre aos seus filhos, acumulando um resultado em um percurso em profundidade.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function sum(node: TreeNode<number>): number {
  let total = node.value;
  for (const child of node.children) total += sum(child);
  return total;
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }, { value: 3, children: [] }] };
console.log(sum(t));

Contando Nós

A mesma estrutura de percurso conta os nós: um para o nó atual, mais as contagens de todas as subárvores.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function count<T>(node: TreeNode<T>): number {
  return 1 + node.children.reduce((acc, c) => acc + count(c), 0);
}
const t: TreeNode<string> = { value: "r", children: [{ value: "a", children: [] }] };
console.log(count(t));

Encontrando a profundidade máxima

A profundidade é um a mais que a profundidade máxima entre os filhos, ou um para uma folha sem filhos.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function depth<T>(node: TreeNode<T>): number {
  if (node.children.length === 0) return 1;
  return 1 + Math.max(...node.children.map(depth));
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [{ value: 3, children: [] }] }] };
console.log(depth(t));

Coletando todos os valores

Achate uma árvore em um vetor concatenando o valor atual com os filhos achatados.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function flatten<T>(node: TreeNode<T>): T[] {
  return [node.value, ...node.children.flatMap(flatten)];
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }, { value: 3, children: [] }] };
console.log(flatten(t));

Pesquisando na árvore

Uma pesquisa recursiva retorna o primeiro nó que corresponde a um predicado, explorando os filhos quando o nó atual não corresponde.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function find<T>(node: TreeNode<T>, pred: (v: T) => boolean): TreeNode<T> | null {
  if (pred(node.value)) return node;
  for (const c of node.children) {
    const hit = find(c, pred);
    if (hit) return hit;
  }
  return null;
}
const t: TreeNode<number> = { value: 1, children: [{ value: 5, children: [] }] };
console.log(find(t, v => v === 5)?.value);

Mapeando uma árvore

Transforme cada valor preservando a estrutura, mapeando recursivamente o valor e os filhos.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function mapTree<T, U>(node: TreeNode<T>, fn: (v: T) => U): TreeNode<U> {
  return { value: fn(node.value), children: node.children.map(c => mapTree(c, fn)) };
}
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }] };
console.log(mapTree(t, x => x * 100).value);

Árvores modelam dados reais

Sistemas de arquivos, árvores do DOM, organogramas e ASTs são todos árvores. Um único tipo recursivo representa todos eles com segurança total de tipos.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
type FileTree = TreeNode<string>;
const fs: FileTree = { value: "/", children: [{ value: "home", children: [] }] };
console.log(fs.value, fs.children[0].value);

Folhas e ramificações

Um nó é uma folha quando children está vazio e uma ramificação caso contrário. Essa distinção costuma orientar a lógica de travessia.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
function isLeaf<T>(node: TreeNode<T>): boolean {
  return node.children.length === 0;
}
console.log(isLeaf({ value: 1, children: [] }));

Verificação rápida: estruturas de árvore

Teste sua compreensão sobre a tipagem de estruturas de árvore.

Recapitulação: tipagem de estruturas de árvore

Você modelou árvores com TreeNode<T>, em que cada nó tem um valor e um vetor de nós filhos, e depois escreveu funções recursivas para somar, contar, pesquisar e mapear seus elementos.

type TreeNode<T> = { value: T; children: TreeNode<T>[] };
const t: TreeNode<number> = { value: 1, children: [{ value: 2, children: [] }] };
console.log(t.children[0].value);

Perguntas Frequentes

A aula “Definindo Tipos de Estruturas em Árvore” é grátis?

Sim — o texto completo de “Definindo Tipos de Estruturas em Árvore” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de TypeScript Academy, atualize para CoddyKit PRO. O curso de TypeScript Academy inclui 4 aulas no total.

O que vou aprender em “Definindo Tipos de Estruturas em Árvore”?

Modele nós de árvore aninhados com tipos recursivos. Você pratica TypeScript Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar TypeScript Academy?

Nenhuma experiência prévia é necessária. TypeScript Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Definindo Tipos de Estruturas em Árvore”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de TypeScript Academy?

Sim. Cada aula de TypeScript Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Definições de Tipos Recursivos
  2. Definindo Tipos de Estruturas em Árvore
  3. Tipos de Valores JSON
  4. Profundidade e Limites da Recursão
← Voltar para TypeScript Academy