• Uma estrutura de dados é um modo particular de armazenamento e organização de um conjunto de dados.


• Facilita e/ou acelera inserções, consultas, buscas, atualizações e deleções eficientes em um conjunto de informações.


• A estrutura propriamente dita não fornece a solução de um problema, mas sim o algoritmo que utiliza a estrutura.


• O uso da estrutura apropriada pode ser o determinante que uma solução atenda os limites de tempo do enuciado do problema.

• Para escolher a estrutura correta, deve-se conhecer as opções disponíveis e as suas característa.


• Nesta aula, serão apresentadas idéias básicas e as biblioteacas em C/C++, Java e Python das estruturas:
  • Array
  • Lista
  • Pilha
  • Fila
  • Dicionário
  • Conjunto

• Em alguns problemas, estruturas lineares não são a melhor forma de armazenar os dados do problema.


• Estruturas não lineares proporcionam buscas eficientes por elementos da coleção e o gerenciamento de pares chave $\rightarrow$ valor.


• São baseadas em estruturas de árvore, com o a ilustrada na figura ao lado.
• Os elementos de uma árvore são chamados de nó.
• Um nó sem pai é chamado de nó raiz e um nó sem filhos é chamado de nó folha.

Árvore em que cada nó tem até dois filhos e satisfaz uma das propriedades abaixo:

• Max Heap:
  • A chave do nó pai é sempre maior ou igual às dos nós filhos.
  • A maior chave é a do nó raíz.
• Min Heap:
  • A chave do nó pai é sempre menor ou igual às dos nós filhos.
  • A menor chave é a do nó raíz.

Sua construção requer na ordem de $n$ operações e a inserção e remoção de elementos custam na ordem de $log\,n$ operações.

São usadas para implementar filas com prioridade, isto é, uma fila em que a ordem de remoção dos elementos atende um critério de prioridade.

Operações básicas para a manipulação de uma fila com prioridade.

C/C++ - STL <priority_queue>:

          
// inclusão da biblioteca
#include <priority_queue>
using namespace std;

// declaração
priority_queue<int> a;

// inclusão de elementos
a.push(3);
a.push(2);

// acesso ao elemento da frente
int tmp = a.top();

// remoção do elemento da frente
a.pop();

// número de elementos
a.size();

// teste da fila está vazia
a.empty();
          
        

Operações básicas para a manipulação de uma fila com prioridade.

Java - PriorityQueue:

          
// inclusão da biblioteca
import java.util.*;

// declaração
PriorityQueue<Integer> a = new PriorityQueue<Integer>();

// inclusão de elementos
a.add(3);
a.add(2);

// acesso ao elemento da frente
int tmp = a.peek();
// remoção do elemento da frente
a.pool();

// número de elementos
a.size();

// teste da fila está vazia
a.empty();
          
        

Operações básicas para a manipulação de uma fila com prioridade.

Python - heapq:

          
# inclusão da biblioteca
import heapq

#declaração
a = []

# inclusão de elementos
heapq.heappush(a,3)
heapq.heappush(a,2)

# acesso ao elemento da frente
int tmp = heapq.nlargest(a)
# remoção do elemento da frente
heapq.heappop(a)

# número de elementos
len(a)

# teste da pilha está vazia
len(a) == 0
not a
          
        

• São usados para representar coleções de pares chave $\rightarrow$ valor.


• Neste caso as informações são recuperadas através da chave do elemento e não com base na sua posição na coleção.

Operações básicas para a manipulação de um dicionário.

C/C++ - STL <map>:

          
// inclusão da biblioteca
#include <map>
using namespace std;

// declaração
map<string,int> a;

// inclusão de elementos
a.insert( std::pair<string,int>("c", 3) );
a.insert( std::pair<string,int>("s", 2) );

// acesso a um elemento
int tmp = a["c"];

// alteração de valores
a["c"] = 5;

// número de elementos
a.size();

// remoção do segundo elemento
a.erase(a.begin()+1);
// remoção dos três primeiros elementos
a.erase(a.begin(),a.begin()+3);
          
        

Operações básicas para a manipulação de um dicionário.

Java - TreeMap:

          
// inclusão da biblioteca
import java.util.*;

// declaração
TreeMap<String,Integer> a = new TreeMap<String,Integer>();

// inclusão de elementos
a.put("c", 3);
a.put("s", 2);

// acesso a um elemento
int tmp = a.get("c");

// alteração de valores
a.replace("c", 5);

// número de elementos
a.size();

// remoção de um elemento
a.remove("c");
          
        

Operações básicas para a manipulação de um dicionário.

Python:

          
# declaração
a = {}

# inclusão de elementos
a["c"] = 3
a["s"] = 2

# acesso a um elemento
int tmp = a["c"]

# alteração de valores
a["c"] = 5

# número de elementos
len(a)

# remoção de um elemento
del a["c"]
          
        

• São usados para representar coleções que não contém repetições de elementos.


• A pertinência de um elemento no conjunto pode ser testada com um algoritmo que efetua na ordem de $n\,log\,n$ operações.


• Pode ser usado para calcular de forma eficiente operações de conjunto como união e interseção.

Operações básicas para a manipulação de um conjunto.

C/C++ - STL <set>:

          
// inclusão da biblioteca
#include <set>
#include <algorithm>
using namespace std;

// declaração
map<string> a;
map<string> b;

// inclusão de elementos
a.insert( "c" );
a.insert( "s" );

b.insert( "c" );
b.insert( "d" );

// união dos conjuntos
map<string> v;
std::set_union (a.begin(), a.end(), b.begin(), b.end(), v.begin());
          
        

Operações básicas para a manipulação de um conjunto.

Java - TreeSet:

          
// inclusão da biblioteca
import java.util.*;

// declaração
Set<String> a = new TreeSet<String>();
Set<String> b = new TreeSet<String>();

// inclusão de elementos
a.add("c");
a.add("s");

b.add("c");
b.add("d");

// união dos conjuntos
Set<String> v(a);
v.addAll(b);
          
        

Operações básicas para a manipulação de um conjunto.

Python:

          
# declaração
a = set(["c", "s"])
b = set(["c", "d"])

# união dos conjuntos
v = a.union(b)
          
        

Leitura:

• Capítulo 2, Seção 2.2 do livro texto Competitive Programming 1
  Halim, S. e Halim, F.

Exercícios:

• Lista de exercícios 04, de problemas Estruturas não-lineares.