💻
Micro-fundamentos - AEDs
  • Introdução
  • Algoritmos e Estruturas de Dados 1
    • Parte 1 - Começando com o básico
      • Criando nosso primeiro algoritmo
      • Estruturas de dados primitivas
      • Atribuição e declaração de variáveis
      • Leitura e escrita de dados
      • Estruturas condicionais e Operadores relacionais
      • Operadores aritméticos
      • Operadores lógicos
      • Estruturas de repetição
      • Funções e escopo
    • Parte 2 - Conceitos avançados
      • Introdução a ponteiros
      • Estruturas de dados não primitivas
      • Entendendo-recursão
      • Retornando argumentos de funções recursivas
      • Como a máquina interpreta seus códigos
    • Parte 3 - Conhecendo POO e seus Princípios
      • O que é Programação Orientada a Objetos?
      • Criando nossa primeira classe
      • Entendendo Encapsulação
      • Entendendo Herança
      • Entendendo Polimorfismo
  • Algoritmos e Estruturas de Dados 2
    • Parte 1 - Complexidade e Programação Competitiva
      • Complexidade e notação Big O
      • Complexidade em funções recursivas
      • Crescimento de funções - Notação Theta e Omega
      • Programação competitiva
    • Parte 3 - Algoritmos de pesquisa
      • Busca linear
    • Parte 4 - Ordenação Interna
      • Quicksort
    • Parte 5 - Tipos Abstratos de Dados (TAD)
    • Parte 6 - Estruturas Flexíveis e Estáticas
    • Parte 7 - Árvores e Tabela Hash
      • Árvore Binária
  • Algoritmos e Estruturas de Dados 3
    • CRUD
    • Intercalação balanceada
  • C
    • Argumentos-de-entrada
    • debug
      • Introducao-ao-gdb
      • Introducao-ao-valgrind
    • ponteiro
      • Ponteiros e Alocação de Memória em C
    • string
      • Strings em C
      • Leitura-de-Strings-em-C
  • Java
    • Nocoes-basicas
    • Argumentos-de-entrada
    • Debug em Java
      • java-debugger-tool
      • visual-studio-debugger
    • string
      • String-em-Java
    • Tratamento de Exceções em Java
      • try-catch-e-o-throws
  • COMO-CONTRIBUIR
Powered by GitBook
On this page
  • Você vai aprender
  • Pré-requisitos
  • Como fazer o cálculo
  • Passo-a-passo
  • Links úteis
  1. Algoritmos e Estruturas de Dados 2
  2. Parte 1 - Complexidade e Programação Competitiva

Complexidade em funções recursivas

Você vai aprender

  • Como calcular a complexidade de espaço e tempo para funções recursivas

Pré-requisitos

  • Conhecimento de Complexidade de Espaço e Tempo

  • Notações assintóticas

Como fazer o cálculo

Para calcular a complexidade de tempo e espaço de uma função recursiva, é necessário entender o número de chamadas recursivas que ocorrem e o tempo e espaço consumidos por cada chamada.

A complexidade de tempo de uma função recursiva é geralmente expressa em termos de notação assintótica, como O(n), Θ(n), ou O(log n). A complexidade de espaço é expressa de forma semelhante, indicando quanto espaço de memória é usado pela função recursiva.

Passo-a-passo

Para calcular a complexidade de tempo e espaço de uma função recursiva, é possível seguir os seguintes passos:

  • Identificar o número de chamadas recursivas: Analise a função recursiva para determinar quantas chamadas recursivas são feitas em termos de n, o tamanho da entrada.

  • Identificar o tempo e espaço consumidos por cada chamada recursiva: Analise o tempo e espaço consumidos por cada chamada recursiva em termos de n. Isso pode incluir o tempo e espaço necessários para executar a chamada recursiva, bem como para manter a pilha de chamadas recursivas.

  • Escreva a equação de recorrência: Com base no número de chamadas recursivas e no tempo e espaço consumidos por cada chamada recursiva, escreva uma equação de recorrência que descreva a complexidade de tempo ou espaço da função recursiva.

  • Resolva a equação de recorrência: Resolva a equação de recorrência para obter a complexidade de tempo ou espaço final da função recursiva.

Por exemplo, considere a seguinte função recursiva que calcula o fatorial de um número:

int fatorial(int n) {
  if (n == 0) return 1;
  return n * fatorial(n - 1);
}

A função fatorial faz uma única chamada recursiva com um argumento n - 1.

  • Cada chamada recursiva executa uma multiplicação e consome espaço para manter a pilha de chamadas.

  • A equação de recorrência para o tempo de execução é T(n) = T(n-1) + O(1), e a equação de recorrência para o espaço é S(n) = S(n-1) + O(1).

  • Resolvendo a equação de recorrência, podemos ver que a complexidade de tempo é O(n) e a complexidade de espaço é O(n) também. Isso ocorre porque a função fatorial faz n chamadas recursivas, e cada chamada recursiva consome uma quantidade constante de espaço e tempo.

Note que em funções recursivas mais complexas, o processo de análise pode ser mais complicado e pode ser necessário usar técnicas avançadas, como a substituição, o método mestre ou a árvore de recursão para calcular a complexidade de tempo e espaço de forma precisa.

Links úteis

  • Algoritmos: Teoria e Prática de Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest e Clifford Stein - este livro é um clássico na área de algoritmos e é usado em muitos cursos de graduação e pós-graduação em ciência da computação. O capítulo 4, "Divide and Conquer", discute em detalhes como calcular a complexidade de funções recursivas.

  • Coursera - Algoritmos, Parte I e Parte II - Estes cursos online gratuitos, ministrados pelos professores Robert Sedgewick e Kevin Wayne, cobrem vários tópicos em algoritmos, incluindo análise de algoritmos recursivos. Os cursos incluem vídeo-aulas, leituras recomendadas e exercícios para prática. (Parte I, Parte II)

  • Khan Academy - Algoritmos - A Khan Academy oferece um curso online gratuito sobre algoritmos que inclui uma seção sobre análise de algoritmos. Este curso inclui tutoriais em vídeo, exercícios e exemplos práticos de como calcular a complexidade de funções recursivas. (Link)

  • MIT OpenCourseWare - Introduction to Algorithms - Este curso online gratuito do MIT é baseado no livro de Cormen et al. mencionado acima e inclui palestras em vídeo, leituras recomendadas e exercícios práticos. O curso cobre em detalhes como calcular a complexidade de funções recursivas. (Link)

  • GeeksforGeeks - Complexity Analysis of Algorithms - O site GeeksforGeeks é um recurso popular para estudantes de ciência da computação e desenvolvedores de software. Ele inclui vários artigos e tutoriais sobre análise de algoritmos e cálculo de complexidade de funções recursivas. (Link)

PreviousComplexidade e notação Big ONextCrescimento de funções - Notação Theta e Omega

Last updated 2 years ago