A notação Big O é um conceito matemático normalmente empregado para medir o custo de um algoritmo. É uma forma simples de classificar a complexidade computacional de um algoritmo.

No geral, significa encontrar uma função que relacione o tamanho da entrada de um algoritmo com o número de passos necessários à sua execução (complexidade temporal) ou quantidade de espaço de armazenamento que ele emprega (complexidade espacial).

Comumente a função que descreve a performance de um algoritmo se refere ao seu limite superior, que determina o pior caso (de entrada de dados) do algoritmo.

Em ciência da computação, a notação Big O é empregada para classificar algoritmos de acordo com seu tempo de execução / número de passos (custo) ou requisitos de espaço, conforme a entrada de dados aumenta.

Em outras palavras,  usamos essa notação para indicar quanto tempo algo demorará para executar, ou o espaço que ocupará na memória, dado uma quantidade N de dados a serem manipulados.

Qual a importância de saber isso? Vai te permitir desenvolver software muito melhor porque você irá entender como é possível melhorar a performance do programa, tornando-o mais eficiente e escalável, sem complexidade adicional.

Se um projeto precisa usar um algoritmo específico, é importante entender o quão rápido ou lento ele é em comparação com outras alternativas.

Definição Formal de Big O

A seguir temos uma definição formal da notação Big O, retirada da Wikipedia:

“A notação Big O é uma notação matemática que descreve comportamento limite de uma função quando o argumento tende a um valor em particular ou ao infinito.”

Trata-se de uma notação membro de uma família de notações inventadas por Paul Bachmann, Edmund Landau e outros, chamadas em conjunto de Notação Bachmann-Landau ou ainda Notação Assintótica.

Curiosidade: A letra ‘O’ vem da palavra em alemão Ordnung, com o significado de Ordem (de aproximação).

O Big O se foca no cenário de pior caso no qual o algoritmo consome o maior tempo (ou recursos) para executar. Isso significa que o algoritmo nunca irá demorar MAIS que esse cenário – mas pode demorar MENOS em determinadas circunstâncias.

Perceba que essa notação serve para calcular o tempo máximo que irá demorar a execução do algoritmo (em termos de custo), mas o tempo real pode ser menor. Por exemplo, uma busca linear em um array pode encontrar o item na primeira posição pesquisada, como se fosse O(1) (melhor resultado).

Assim, o Big O sempre se refere ao pior resultado possível.

Note que o Big O serve para algoritmos escritos em qualquer linguagem de programação e sempre é calculado da mesma forma.

Observação importante: essa notação NÃO nos informa a velocidade de um algoritmo em segundos, pois existem muitos fatores que podem influenciar essa velocidade, como por exemplo o hardware empregado para executar o algoritmo. Usamos o Big O para comparar algoritmos entre si.

Funções e Complexidade

Na notação Big O, a letra “n” representa o tamanho da entrada, enquanto a função “g(n) = n”, associada ao “O()” nos informa a complexidade do algoritmo em relação ao tamanho dessa entrada.

Sendo assim, podemos ter algoritmos classificados de acordo com seu nível de complexidade, como segue:

• Complexidade Constante: O(1)
  Não importa a quantidade total de dados acessados, o tempo de acesso é sempre 1, ou seja, sempre o mesmo custo para acessar qualquer um dos dados no conjunto. Exemplo: acesso a um elemento de um array.
• Complexidade Linear: O(n)
  O acesso a um elemento demora o tempo equivalente à quantidade de dados da coleção. Exemplo: busca linear de um dado em uma lista ou array não ordenado – o algoritmo, no pior caso, tem de procurar em até n elementos, caso o dado buscado ser o último ou inexistente.
• Complexidade Logarítmica O(log n) 
  Sua performance aumenta drasticamente conforme a quantidade de elementos aumenta. Exemplo: árvores de busca balanceada ou algoritmos de busca binária em arrays. Sua performance se aproxima comumente do O(1).
  Geralmente os dados precisam estar classificados (ordenados) de alguma forma.
• Complexidade Linearítmica: O(n log n)
  É uma combinação das complexidades linear e logarítmica. Algoritmos que usam estratégias do tipo dividir e conquistar são linearítmicos, como os algoritmos de classificação Merge Sort e Heap Sort.
• Complexidade quadrática O(n²)
  Complexidade na qual o custo computacional cresce de acordo com o quadrado da quantidade de elementos de entrada. Exemplo de algoritmo: Algoritmos de classificação como Bubble Sort, Insertion Sort ou Selection Sort. 
• Complexidade polinomial (n^c)
  A quantidade de operações é proporcional à potência c do tamanho da entrada (engrada elevada a um valor c).
  Exemplo: Encontrar o determinante de uma matriz usando Decomposição LU.
  Um caso especial de complexidade polinomial é a complexidade quadrática, na qual c = 2.
• Complexidade fatorial O(n!).
  Uma das piores complexidades em termos de custo. O tempo necessário para execução do algoritmo cresce astronomicamente conforme aumenta a quantidade de dados de entrada.
  Exemplo: Encontrar o determinante de uma matriz usando o Teorema de Laplace

Alterar a complexidade de um algoritmo, por exemplo de linear para logarítmica, pode fazer com que a aplicação tenha uma performance milhões ou até bilhões de vezes maior.

O gráfico a seguir mostra uma comparação entre diversos níveis de complexidade, relacionando o número de operações necessárias para realizar uma tarefa de acordo com a quantidade de elementos de um conjunto de dados:

Crescimento da Complexidade de Algoritmos.
Fonte: https://www.bigocheatsheet.com/

Comparação de algoritmos com Big O distintos

Imagine que um algoritmo de busca linear de O(n) demore 1 ms (um milissegundo) para realizar uma operação, ao passo que um algoritmo de busca binária d O(log n) também demora 1 ms para realizar a operação.

Quantas operações serão necessárias para realizar n operações com cada algoritmo? A tabela a seguir mostra alguns valores calculados:

Perceba que o algoritmo de busca linear tem um aumento de custo computacional muito mais elevado do que o algoritmo de busca binária considerado.

Para conjuntos com poucos elementos a diferença entre eles é pequena, porém conforme aumentamos a quantidade de dados de entrada os algoritmos começam a se comportar de forma muito diversa.

No exemplo, para conjuntos pequenos de dados praticamente não há diferença entre usar um algoritmo ou outro, mas para conjuntos grandes o emprego do algoritmo de complexidade O(log n) é imprescindível.

Em suma, o tempo de execução para cada algoritmo não cresce na mesma proporção. Por isso é importante saber o Big O de cada algoritmo – assim é possível escolher o melhor a usar em cada caso.

A tabela a seguir mostra alguns algoritmos populares de ordenação de arrays (vetores), com suas complexidades de tempo e espaço na notação Big-O:

Outras Notações de Complexidade Algorítmica

Além do Big O, existem outras notações que podem ser empregadas para determinar o custo computacional de algoritmos, geralmente se focando em fatores distintos. Algumas delas são:

• Notação Omega (Ω()): descreve o limite inferior da complexidade
• Notação Theta (Θ()): descreve o limite exato da complexidade
• Notação Little O (o()): descreve o limite superior, porém excluindo o limite exato.

Resumo

• Conhecendo o Big O de um algoritmo, saberemos qual a performance e eficiência de acordo com o volume de informações que entram.
• Quando comparamos algoritmos distintos que resolvem o mesmo problema, por meio do Big O podemos determinar qual deles é o mais eficiente.
• De forma bem simplificada, o Big O nos diz quantas operações um algoritmo precisa realizar para completar sua tarefa.

Referências

• Erickson, J. Algorithms. 1ª edição, 2019. Disponível para download em http://jeffe.cs.illinois.edu/teaching/algorithms/
• Sedgewick, R.; Wayne, K. Algorithms. 4 edição, 2011. Editora Addison-Wesley Professional.
• Cormen, T.H.; Leiserson, C.E.; Rivest, R.L. Introduction to Algorithms. 3ª edição, 2009. Editora MIT Press.

O post O que é Notação Big O em programação e análise de algoritmos apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Anteriormente nós estudamos o funcionamento e aplicações das pilhas em estruturas de dados. Vamos ver agora como implementar uma estrutura de pilha na linguagem Java, usando um array como base.

Lembrando que também é possível implementar pilhas usando listas ligadas, assunto que abordaremos mais à frente em nosso curso de Estruturas de Dados.

Criando a Pilha

Primeiramente criaremos uma classe de nome Pilha para representar as pilhas no programa principal:

/*
Implementando operações com pilhas em Java
Criando a Classe Pilha
Implementamos as funções isEmpty, peek, push e pop
*/
public class Pilha {
   static final int MAX = 1000;
   int top;
   int a[] = new int[MAX]; // Define tamanho máximo da pilha   

   // Construtor
   Pilha() {
      top = -1;
   }

   // Métodos da pilha
   boolean isEmpty() {
     return (top < 0);
   }
   boolean push(int x) {
      if (top >= (MAX-1)) {
         System.out.println("Estouro de Pilha!");
         return false;
      }
      else {
         a[++top] = x;
         return true;
      }
   }
   int pop() {
      if (top < 0) {
         System.out.println("Pilha Vazia!");
         return 0;
      }
      else {
         int x = a[top--];
         return x;
      }
   }
   int peek() {
      if (top < 0) {
         System.out.println("Pilha Vazia!");
         return 0;
      }
      else {
         return a[top];
      }
   }
}

Usando a pilha

Para usar a nossa classe Pilha vamos instanciá-la no programa principal e realizar algumas operações push e pop para inserir e retirar itens na pilha:

// Código do main
import java.util.Scanner;
public class PilhaJava {

   public static void main(String args[]) {
      Scanner entrada = new Scanner(System.in);
      System.out.println("Entre com um número:");
      int valor = entrada.nextInt();

      Pilha novaPilha = new Pilha();

      novaPilha.push(valor);
      novaPilha.push(70);
      novaPilha.push(88);
      System.out.println("Item de valor " + novaPilha.pop() + " retirado da pilha");
      System.out.println("Item restante: " + novaPilha.peek());
      System.out.println("Item de valor " + novaPilha.pop() + " retirado da pilha");
      System.out.println("Item restante: " + novaPilha.peek()); 
   }
}

Resultado:

É isso aí! No próximo tutorial veremos como criar e utilizar pilhas em linguagem C.

Até lá!

O post Como implementar uma pilha em Java usando Arrays apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Um Registro é uma estrutura que fornece um formato especializado para armazenar informações em memória.

Ele inclui as informações sobre uma entidade específica, podendo, por exemplo, corresponder às informações pertinentes a um cliente em um arquivo de clientes ou a um automóvel em um arquivo de controle de uma concessionária, entre outros.

Um registro é dividido em unidades de dados chamadas de Campos. Cada campo é utilizado para armazenar um dado específico, de um tipo determinado. Por exemplo, em um registro de clientes podemos ter um campo para armazenar o nome do cliente, outro para seu sobrenome, e um outro campo para armazenar seu CPF.

Representando os registros

Os registros podem ser representados de formas distintas, dependendo da linguagem de programação adotada para a criação do algoritmo no qual eles serão empregados. Em linguagem C, por exemplo, os registros podem ser representados por estruturas (structures), ao passo que em C++ e Java, por objetos de uma classe.

Os membros de dados dentro desses objetos equivalem aos campos no registro.

Exemplo de um registro

Tomemos como exemplo os dados de um cliente de uma loja qualquer. Para representar esses dados na memória do computador, e posteriormente armazená-los em disco, podemos lançar mão do uso de um registro.

Abaixo podemos ver alguns campos de exemplo que constituem o registro de um cliente:

O registro é identificado por um nome, como por exemplo “Cliente”, e seus membros (campos) podem ser acessados por meio do uso do operador ponto (.). Por exemplo, para acessar o CPF do cliente poderíamos utilizar a seguinte declaração:

Cliente.CPF

Além disso, um campo qualquer pode conter um outro registro, caso seja um campo de dados composto. Em nosso exemplo, o campo Rua poderia ser subdividido em mais campos, como Nome_Rua e Número_Rua, para diferenciar esses dois dados.

O conceito de Chave

Geralmente um dos campos de um registro é denominado Chave, ou ainda Campo-Chave. Usamos esse campo em particular para nos auxiliar na procura de um conjunto específico de dados dentro de um arquivo de dados (ou seja, na busca de um registro).

Em nosso exemplo, poderíamos pesquisar um cliente específico a partir de seu número de CPF, armazenado em um campo homônimo, que pode ser considerado o campo-chave.

Exemplos

A seguir temos um exemplo de implementação desse registro de clientes em C, usando uma estrutura:

struct cliente
{
  char CPF[11];
  char nome[30];
  char sobrenome[50];
  char rua[60];
  int numero;
  char telefone[11];
};

Note que na linguagem, além de definirmos os nomes de cada campo, também precisamos definir o tipo de dados de cada um, para que sejam realizadas as alocações de memória adequadas quando o registro for devidamente criado em tempo de execução do programa.

Essas estruturas são usadas para definir os registros que são armazenados em arquivos, e, juntamente com outras técnicas de programação, como os ponteiros, permitem e simplificam a criação de estruturas de dados mais complexas, como por exemplo as pilhas, listas ligadas, filas e árvores, entre outras.

(Clique aqui para saber mais sobre estruturas em linguagem C).

Nos próximos artigos vamos explorar essas e outras estruturas de dados. Até!

O post Estruturas de Dados: o Registro apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma Pilha é uma estrutura de dados que serve como uma coleção de elementos,  e permite o acesso a somente um item de dados armazenado – o último item que foi inserido na estrutura (item do topo). Esse item pode ser lido ou removido.

Caso seja removido, teremos acesso ao item imediatamente anterior a ele que se torna automaticamente o último item da pilha (topo), e assim sucessivamente, até que a estrutura esteja vazia.

Uma pilha difere de um array, que é outra estrutura que permite o armazenamento de itens (dados) pois o acesso aos itens de uma pilha é restrito – somente um item pode ser lido ou removido por vez, na ordem inversa em que foram colocado na pilha, ao contrário de um array (vetor), onde podemos acessar qualquer elemento em qualquer posição diretamente, sem a necessidade de acessar itens anteriores primeiro (desde que conhecida a posição do elemento que se deseja acessar).

Podemos implementar pilhas de algumas formas, como por meio de arrays ou com o uso de ADTs (Abstract Data Types / Tipos de Dados Abstratos). Estudaremos ambas as formas nestas lições.

Aplicações das pilhas

As pilhas encontram inúmeras aplicações em programação e desenvolvimento de algoritmos, como por exemplo:

• Avaliação de Expressões e Parsing Sintático
• Algoritmos de Backtracking
• Gerenciamento de Memória em Tempo de Compilação
• Implementação de diversos algoritmos, como Grahan scan e SMAWK
• Operações como desfazer e refazer em aplicações
• Controle de navegação em browsers
• Endereçamento de instruções em microprocessadores
• Análise de expressões aritméticas

e muitas outras.

Como funciona um Pilha

Para entender como uma pilha funciona, faremos uma analogia com o mundo real.

Imagine uma pilha de pratos na cozinha. Se quisermos utilizar um prato, pegamos um do topo desta pilha (último prato). Se necessitarmos de outro, pegamos o próximo da pilha (que agora é o último), e assim por diante.

Quando um prato é lavado, após seu uso, pode ser recolocado novamente na pilha de pratos, sempre no topo. Esse prato recém-colocado na pilha passa a ser o último, e o primeiro que será retirado quando precisarmos usar um prato novamente.

Essa é a ideia geral de uma estrutura de dados do tipo pilha. Nela, os dados são inseridos na pilha (empilhados), e acessados em ordem inversa (o último a ser inserido é sempre o primeiro a ser utilizado). Colocar um elemento no topo de uma pilha é uma operação que recebe um nome especial: push. Já a remoção de um elemento do topo da pilha é uma operação denominada pop.

Por conta deste modo de operação, as pilhas são classificadas como estruturas de dados de armazenamento Last-In, First-Out – LIFO, “o último a entrar é o primeiro a sair”, pois o último item inserido na pilha é sempre o primeiro a ser removido (ou lido).

A figura a seguir ilustra uma pilha contendo valores numéricos, e seu topo assinalado:

Operações Push e Pop

Uma pilha permite o acesso somente ao último item de dados inserido. Ao ser removido esse item, é possível acessar o item anterior a ele, e assim por diante. Para tal, lançamos mão de algumas operações específicas, tanto para inserir quanto para retirar itens da pilha.

As duas principais operações realizadas sobre uma pilha são as operações básicas push e pop.

A operação push é executada para adicionar um elemento ao topo de uma pilha.

A operação pop é executada para retirar um elemento do topo de uma pilha. O elemento retirado é sempre o último que foi adicionado com a operação push.

A figura a seguir ilustra a operação push em uma pilha, sendo executada duas vezes para permitir a inserção de dois novos valores em uma pilha já existente:

Operação push em uma pilha

Já a figura a seguir ilustra a operação pop sendo efetuada sobre a pilha, de modo a remover elementos. Note que se trata de uma operação exatamente inversa à operação push:

Operação pop em uma pilha

Mais sobre pilhas

As pilhas, no geral, são estruturas de dados de tamanho pequeno. Com apenas alguns itens de dados, uma pilha pode ser útil na realização de diversas tarefas computacionais.

Além das operações push e pop, existem algumas outras operações comuns implementadas em pilhas, como peek, isFull e isEmpty. A seguir temos uma breve descrição de cada uma:

• peek – Consiste na leitura do valor armazenado no topo da pilha, sem no entanto removê-lo. Às vezes chamada de top.
• isFull – Função utilizada para verificar se uma pilha está cheia (ou seja, se não é mais possível armazenar itens)
• isEmpty – Função que verifica se uma pilha está vazia – ou seja, se não é possível continuar a remover itens.

As pilhas podem ser implementadas de duas formas principais: usando arrays ou usando listas encadeadas (linked lists). Na próxima lição veremos como implementar uma pilha usando arrays em linguagem C, e posteriormente como implementar pilhas em Java.

Anterior: O que são Estruturas de Dados

Próximo: Como implementar uma pilha em linguagem C usando array.

O post Estruturas de Dados: O que são Pilhas apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma Estrutura de Dados consiste em uma organização de dados na memória de um computador ou em um dispositivo de armazenamento, de modo que esses dados possam ser utilizados de forma eficiente.

Estruturas de dados diversas encontram muitas aplicações em desenvolvimento de sistemas, sendo que algumas são altamente especializadas e utilizadas em tarefas específicas. Usando estruturas de dados adequadas, podemos administrar uma grande quantidade de dados de forma eficiente, com aplicações em bancos de dados ou serviços de busca e indexação de dados, e no desenvolvimento de algoritmos eficientes.

Figura 1: Estrutura de Dados básica – Array

Um Algoritmo é um conjunto de instruções detalhadas e ordenadas, cujo propósito é realizar uma tarefa ou operação específica.

Os algoritmos são utilizados para manipular dados nestas estruturas de várias formas, como por exemplo, inserindo dados, procurando itens específicos ou ainda ordenando seus elementos.

Neste tutorial vamos tratar exclusivamente da definição de Estrutura de Dados.

Operações básicas em Estruturas de Dados

No geral, em uma estrutura de dados precisamos saber como realizar um determinado conjunto de operações básicas, como por exemplo:

• Inserir um novo item
• Excluir um item existente
• Localizar (procurar) um elemento específico
• Varrer (percorrer) todos os itens constituintes da estrutura para visualização
• Classificar (ordenar), o que consiste em colocar os itens de dados em uma determinada ordem (numérica, alfabética, etc.)

Entre outras que estudaremos nas pŕoximas lições.

Estruturas de Dados principais

As principais estruturas de dados que estudaremos neste curso da Bóson Treinamentos em Tecnologia são as seguintes:

• Array (vetores e matrizes)
• Registro
• Union
• Lista encadeada
• Pilha
• Fila
• Fila de prioridades
• Árvore binária
• Tabela Hash
• Heap
• Grafo

As estruturas de dados podem implementar um ou mais tipos de dados abstratos (ADT / Abstract Data Types), os quais especificam operações que podem ser executadas em uma estrutura de dados, além da complexidade dessas operações.

A seguir, discutiremos o conceito de Registro, estrutura amplamente utilizada na construção de estruturas de dados.

Próximo: O Conceito de Registro em Estruturas de Dados

O post O que são Estruturas de Dados apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.