Estruturas de Dados

Estruturas de dados e algoritmos são temas fundamentais da

ciência da computação, sendo que são utilizados nas mais
diversas áreas e com os mais diferentes propósitos.

Um algoritmo precisa representar e armazenar dados. Isso se

dá por intermédio das estruturas de dados.

Dados organizados (dispostos) de forma coerente caracterizam

uma estrutura de dados.
 Estruturas de Dados
Estruturas de Dados

Simples (variáveis simples):

●

Armazenam apenas 1 valor por vez.

São de tipos primitivos :
Inteiro, real, lógico e caracter (int, boolean, char, short, ...)

●Compostas (variáveis compostas):

Agrupamento de várias informações, ao mesmo tempo, dentro
de uma mesma variável.
Podem ser construídos com base nos tipos primitivos.
 Estruturas de Dados

Estruturas de Dados Compostas :

São usadas quando a utilização de variáveis simples, de

tipos de dados promitivos, não é suficiente para representar
os dados em um programa.

Podem ser:

- Homogêneas (de um mesmo tipo de dado) e

- Heterogêneas (tipos diferentes).

 Estruturas de Dados

Estruturas de Dados Compostas Homogêneas

- Uma estrutura de dados composta homogênea consiste em

uma única variável que pode armazenar vários valores (por
isso composta) do mesmo tipo de dado (por isso
homogênea).

Também conhecidas como :

Vetores, tabelas, matrizes, arrays...

 Estruturas de Dados

Estruturas de Dados Compostas Homogêneas

Suas principais características são:

● Contém vários valores (número definido);

● Todos valores são do mesmo tipo de dado;

● Possui um único nome (identificador da variável);

● Cada valor do conjunto é acessível independentemente,

de acordo com o seu índice (ou posição na estrutura de

dados).
 Estruturas de Dados

Estruturas de Dados Compostas Homogêneas

- Unidimensionais (Vetores, arrays, etc..)

- Multidimensionais (Matrizes..)
 Estruturas de Dados
Variáveis Compostas Homogêneas Unidimensionais
(Vetores ou Arrays)

Conjunto de dados referenciados por um mesmo nome e que

necessitam de somente um índice para que seus elementos
sejam endereçados.
A referência ao conteúdo é feita através de um índice.
Variável: Nota

1 2 3 4
 Estruturas de Dados
Variáveis Compostas Homogêneas Unidimensionais
(Vetores ou Arrays)

Consistem em:
● Identificador – nome da variável

● Valores - conteúdos armazenados

● Índices - posições da variável onde se encontram os

valores correspondentes.
 Estruturas de Dados
Suponha uma estrutura que armazene a idade de 5 pessoas.

Nome do identificador desta estrutura = idades

Nome do Vetor : idades

Valores ----------------->
5 10 15 3 20
Indices ------------------> 1 2 3 4 5

Os valores correspondem aos conteúdos informados pelo usuário,

ou seja, são as idades lidas e armazenadas.
Os índices correspondem as posições que identificam os valores
armazenados independentemente dos outros valores, sendo
através deles manipulados especificamente um ou mais valores
que sejam necessários.
 Estruturas de Dados
Declaração no Português estruturado

Variável simples :
<identificador> : <tipo de dado>

Exemplo : matricula : numerico

Variáveis Compostas (Vetores) :

<identificador> : conjunto [<inicial>..<final>] de <tipo de dado>

Exemplo : matriculas : conjunto[0..20] de numerico

<identificador> nome dado ao vetor

<tipo de dado> tipo de dado armazenado no vetor
<inicial>..<final> valor inicial e final do índice do vetor
 Estruturas de Dados

Exemplo de Algoritmo com variável simples:

// Objetivo: armazenar 5 notas de 5 alunos diferentes

Programa Notas
var
aluno2,aluno3,aluno4,aluno5 : numerico
inicio
escreva("Informe a nota do 1º aluno: ");
leia (aluno1)
escreva("Informe a nota do 2º aluno: ")
leia (aluno2)
escreva("Informe a nota do 3º aluno: ")
leia (aluno3)
escreva("Informe a nota do 4º aluno: ")
leia (aluno4)
escreva("Informe a nota do 5º aluno: ")
leia (aluno5)
fim
 Estruturas de Dados

Exemplo de Algoritmo com vetor:

// Objetivo: armazenar 5 notas de 5 alunos diferentes

Programa Notas
var
aluno:conjunto[1..5] de numerico
i, nota : numerico
inicio
para i de 1 até 5 passo 1 faça
escreva("Informe a nota do aluno: ")
leia (nota)
aluno[i] <-- nota
fimpara
*
para i de 1 até 5 passo 1 faça
escreva(aluno[i])
fimpara
fim
 Estruturas de Dados
Declaração em Java

Vetores ou Arrays

<tipo do dado> <identificador>[ ] = new <tipo do dado>[<quantidade>];

obs: Os Arrays em java sempre iniciam do índice 0

Exemplos:

int notas[ ] = new int[10]

// cria um array de nome notas, com 10 elementos do tipo int e seu índice varia de 0 a 9

String nomes[ ] = new String[100]

// cria um array nomes, de 100 elementos do tipo String e seu índice varia de 0 a 99

double valor[ ] = new double[20]

// cria um array valor, de 20 elementos do tipo double e seu índice varia de 0 a 19

int i [ ] = {1,2,3,4,5};
// cria um array i, de 5 elementos do tipo int e seu índice varia de 0 a 4
 Estruturas de Dados
Manipulação de Vetores em Java

Atribuição:

N[0] = “João“;
notas[3] = 5;
valor[10] = 20.50;

Estrutura básica de Atribuição

int MeuVetor[] = new int [4];

for (int i=0; i < 4; i++) {

valor = Integer.parseInt(JOptionPane.showInputDialog("Valor:"));
MeuVetor[i] = valor;
}
 Estruturas de Dados
Manipulação de Vetores em Java

Estrutura básica de Recuperação

int MeuVetor[] = new int [4];

for (int i=0; i < 4; i++) {

JOptionPane.showMessageDialog(null,MeuVetor[i]);

}
 Estruturas de Dados
Manipulação de Vetores em Java

public class Exemplo {

public static void main(String[] args) {

int notas[] = {5,3,8,7,9,10,4,5,6,7};
notas[4] = 8;
notas[5] = notas[5] - 1;
for (int i=0; i<10; i++) {
System.out.println(notas[i]);
}
}
}
 Estruturas de Dados
Operações com Vetores

Pesquisa
- Sequencial
- Binária

Ordenação
 Estruturas de Dados
Passando vetores como parâmetros em procedimentos

●Assim como as variáveis simples, os vetores também podem

ser manipulados em procedimentos(métodos).

● Procedimentos podem receber e retornar vetores ou

elementos de vetores através de parâmetros.
 Estruturas de Dados
Passando vetores como parâmetros em procedimentos

public class Exemplo {

public static void main(String[] args) {

int notas[] = {-5,3,-8,7,9,10,4,-5,6,7};
zera_negativos(notas);
}
}
public static int[] zera_negativos (int v[]) {
for (int i=0;i<10;i++){
if (v[i] < 0) v[i] = 0;
}
}

}
 Estruturas de Dados
Pesquisa Sequencial

Localizar um determidado dado a partir do 1º elemento do

vetor, através de comparações sucessivas.
Termina quando encontra o dado ou quando chega ao fim
do vetor.
 Estruturas de Dados
Algoritmo Pesquisa_Sequencial
var
i,pos,tam,dado : numerico
achou : boolean
vet : conjunto[1..tam] de numerico
inicio
vet = {1,3,7,5,4,8,9,6.2,0}
achou <-- falso;
pos <-- 0;
tam <-- 10;
Escreva ("Entre com o dado a ser pesquisado:")
Leia dado
para i de 1 até tam passo 1 faça
se (dado = vet[i]) então
achou <-- verdadeiro
pos <-- i
fim-se
fim-para
se (achou) então
Escreva ("Achou o dado na posicao:" + pos)
senão
Escreva ("Não Achou")
fim-se
fim
* Ineficiente – varre todo o vetor mesmo depois de já ter achado
 Estruturas de Dados
Algoritmo Pesquisa_Sequencial
var
i,tam,dado : numerico
achou : boolean
vet : conjunto[1..tam] de numerico
inicio
vet = {1,3,7,5,4,8,9,6.2,0}
achou <-- falso;
tam <-- 10;
i <-- 0;
Escreva ("Entre com o dado a ser pesquisado:")
Leia dado
enquanto (i <= tam) e (achou == false) faça
i <-- i + 1
se (dado = vet[i]) então
achou <-- verdadeiro
fim-se
fim-enquanto
se (achou) então
Escreva ("Achou o dado na posicao:" + i)
senão
Escreva ("Não Achou")
fim-se
fim

* Eficiente – não continua a repetição após encontrar o elemento.

 Estruturas de Dados
Pesquisa Binária

● Mais otimizada
● O Vetor deve estar ordenado
●
Objetivo : diminuir o intervalo de busca
● Divide o vetor em partes menores para otimizar a pesquisa.
●
Compara o dado com o elemento central do vetor e caso
não encontre, diminui o intervalo de pesquisa a cada
iteração até encontrar. Se o dado for menor que o elemento
central, muda o intervalo para a primeira metade do vetor,
senão faz a busca na segunda metade.
 Estruturas de Dados
Algoritmo Pesquisa_Binária

var
inicio,fim,meio,dado : numerico
achou : boolean
vet : conjunto[1.. 10] de numerico
inicio
vet = {0,1,2,3,4,5,6,7,8,9}
achou <-- falso
inicio <-- 1
fim <-- 10
Escreva ("Entre com o dado a ser pesquisado:")
Leia dado
enquanto ((inicio <= fim) e (achou == falso)) faça
meio <-- (inicio + fim) /2
se (dado = vet[meio]) então
achou <-- verdadeiro
senão
se (dado > vet[meio]) então
inicio <-- meio + 1
senão
fim <-- meio - 1
fim-se
fim-se
fim-para
se (achou) então
Escreva ("Achou o dado na posicao:" + meio)
senão
Escreva ("Não Achou")
fim-se
fim
 Estruturas de Dados
Ordenação de Vetores

Fazer com que os elementos sejam colocados de forma

ordenada (crescente ou decrescente).

Algoritmo de ordenação simples:

- Consiste em selecionar o menor (ou maior) valor a cada
varredura do vetor e colocá-lo na posição correta.
- Fixa-se uma posição e compara-se o valor armazenado nesta
posição com o resto do vetor, trocando-as se necessário.
Terminadas as comparações, passa para a próxima posição e
repete o processo até o final do vetor.
 Estruturas de Dados
Algoritmo Ordena_Vetor

var
i,j,tam,aux : numerico
vet : conjunto[1..tam] de numerico
inicio
vet = {3,1,5,6,8,7,9,2,4,0}
para i de 1 até (tam - 1) faça
para j de (i + 1) até tam faça
se (vet[i] > vet[j]) então
aux <-- vet[i]
vet[i] <-- vet[j]
vet[j] <-- aux
fim-se
fim-para
fim-para
fim

i = Controla o elemento pivô

j = Controla os elementos a frente do pivô
 Estruturas de Dados
Algoritmo Ordena_Vetor_Otimizado

var
i,j,tam : numerico
menor, i_menor : numerico
vet : conjunto[1..tam] de numerico
inicio
vet = {3,1,5,6,8,7,9,2,4,0}
para i de 1 até (tam - 1) faça
menor <-- vet[i]
i_menor <-- i
para j de (i + 1) até tam faça
se (vet[j] < menor) então
menor <-- vet[j]
i_menor <-- j
fim-se
fim-para

vet[i_menor] <-- vet[i]

vet[i] <-- menor

fim-para
fim
 Estruturas de Dados
Variáveis Compostas Homogêneas Multidimensionais
(Matrizes, Tabelas ou Arrays multidimensionais)

Conjunto de dados referenciados por um mesmo nome e que

necessitam de índices para que seus elementos sejam
endereçados. São vetores de mais de 1 dimensão.
As mais utilizadas são as Estruturas Bidimensionais ( de 2
dimensões – linha e coluna) Colunas

Linhas 1

3
1 2 3 4
 Estruturas de Dados
Declaração no Português estruturado

Variáveis Compostas (Matrizes) :

<identificador> : conjunto [<ini1>..<fin1>,<ini2>..<fin2>]
de <tipo de dado>

Exemplo : matriculas : conjunto [0..5,0..3] de numerico

<identificador> nome dado a matriz

<tipo de dado> tipo de dado armazenado na matriz
<ini1>..<fin1> valor inicial e final do índice da linha da matriz
<ini2>..<fin2> valor inicial e final do índice da coluna da matriz
 Estruturas de Dados
Formas de Armazenamento

Aluno/Nota 1 2 3
1 Aluno1 5 7 8
2 Aluno2 9 5 6
3 Aluno3 8 7 9
4 Aluno4 4 5 8
 Estruturas de Dados
Exemplo de Algoritmo com Matriz:

// Objetivo: armazenar 3 notas para cada aluno sendo 4 alunos diferentes

Programa Notas
var
notas :conjunto[1..4,1..3] de numerico
int i,j;
inicio
para i de 1 até 4 faça
para j de 1 até 3 faça
leia (nota[i,j])
fimpara
fimpara
fim
 Estruturas de Dados
Exemplo de Algoritmo com Matriz:

// Objetivo: Escrever as 3 notas armazenadas (em uma tabela) de cada

aluno, sendo 4 alunos diferentes

Programa Notas
var
notas :conjunto[1..4,1..3] de numerico
int i,j;
inicio
para i de 1 até 4 faça
para j de 1 até 3 faça
escreva (nota[i,j])
fimpara
fimpara
fim
 Estruturas de Dados
Declaração em Java

O java não suporta arrays bidimensionais com linha coluna

São usados Array de Arrays

<tipo do dado> <identificador> [] [] = new <tipo do dado>[<ind1>] [<ind2>];

Exemplos: obs: Os Arrays em java sempre iniciam do índice 0

int notas[ ][ ] = new int[4] [3]

// cria um array de nome notas, com 4 X 3 elementos do tipo int com 2 índices, o primeiro
variando de 0 a 3 e o segundo de 0 a 2

int i [ ] [ ] = { {1,2,3} , {1,0,0} , {4,5,6} , {6,3,8} };

// cria um array i, com 4 X 3 elementos do tipo int com 2 índices, o primeiro variando de 0 a 3 e o
segundo de 0 a 2

double valor[ ][ ] = new double[20] [3]

String N[ ][ ] = new String[100] [2]

 Estruturas de Dados
Manipulação de Arrays de Arrays em Java

Atribuição:

N[0][2] = “João“;
notas[3][1] = 5;
valor[10][2] = 20.50;

Estrutura básica de Atribuição

int MeuVetor[][] = new int [4][3];
for (int i=0; i < 4; i++) {
for (int j=0; j < 3; j++) {
valor = Integer.parseInt(JOptionPane.showInputDialog("Valor:"));
MeuVetor[i][j] = valor;
}
}
 Estruturas de Dados
Manipulação de Array de Arrays em Java

Estrutura básica de Recuperação

int MeuVetor[][] = new int [4][3];

for (int i=0; i < 4; i++) {

for (int j=0; j < 3; j++) {

JOptionPane.showMessageDialog(null,MeuVetor[i][j]);

}
}
 Estruturas de Dados
Manipulação de Array de Arrays em Java

public class Exemplo {

public static void main(String[] args) {

int notas[][] = new int[4][3];
for (int i=0;i<4;i++) {
for (int j=0;j<3;j++) {
notas[i][j] = Integer.parseInt(JOptionPane.showInputDialog
("Entre com a nota " + (j+1) + " do aluno " + (i+1) + ":"));
}
}
for (int i=0;i<4;i++) {
for (int j=0;j<3;j++) {
JOptionPane.showMessageDialog(null,"A nota " + (j+1) +
" do aluno " + (i+1) + " é: " + notas[i][j]);
}
}

}
 Estruturas de Dados

Estruturas de Dados Compostas Heterogêneas

- Uma estrutura de dados composta heterogênea consiste

em uma única variável que pode armazenar vários
informações de tipos diferentes. (por isso homogênea).

Também conhecidas como :

Registros, Classes (em Orientação a Objetos)

 Estruturas de Dados
Declaração no Português estruturado

Registros :

tipo
<identificador> = registro
<lista de campos e seus tipos de dado>
fim-registro
var
<nome da variável> : <identificador>
 Estruturas de Dados
Declaração no Português estruturado

Exemplo de Registros :

tipo
Cad_Aluno = registro
NOME : Literal
NOTA1: numerico
NOTA2 : numerico
NOTA3 : numerico
NOTA4 : numerico
fim_registro
var
ALUNO : Cad_Aluno
 Estruturas de Dados
Leitura de Registros no Português estruturado

Programa Leitura
tipo
Cad_Aluno = registro
NOME : Literal
NOTA1: numerico
NOTA2 : numerico
NOTA3 : numerico
NOTA4 : numerico
fim_registro
var
ALUNO : Cad_Aluno
inicio
leia ALUNO.NOME
leia ALUNO.NOTA1
leia ALUNO.NOTA2
leia ALUNO.NOTA3
leia ALUNO.NOTA4
fim
 Estruturas de Dados
Escrita de Registros no Português estruturado

Programa Leitura
tipo
Cad_Aluno = registro
NOME : Literal
NOTA1: numerico
NOTA2 : numerico
NOTA3 : numerico
NOTA4 : numerico
fim_registro
var
ALUNO : Cad_Aluno
inicio
escreva ALUNO.NOME
escreva ALUNO.NOTA1
escreva ALUNO.NOTA2
escreva ALUNO.NOTA3
escreva ALUNO.NOTA4
fim
 Estruturas de Dados
Implementação de Registros em Java : Classes
class Cad_Aluno {
String nome;
double nota1, nota2, nota3, nota4;
}

public class Leitura_Aluno {

public static void main (String[] args) {
Cad_Aluno aluno = new Cad_Aluno();
aluno.nome = 'Marcos';
aluno.nota1 = '7.0'
aluno.nota2 = '5.0'
aluno.nota3 = '6.0'
aluno.nota4 = '8.0'

System.out.println(aluno.nome);
System.out.println(aluno.nota1);
System.out.println(aluno.nota2);
System.out.println(aluno.nota3);
System.out.println(aluno.nota4);
}
}
 Estruturas de Dados
Conjunto de Registros ou Array de Registros

Exemplo :

tipo
Cad_Aluno = registro
NOME : Literal
NOTA1: numerico
NOTA2 : numerico
NOTA3 : numerico
NOTA4 : numerico
fim_registro
var
vet_aluno : conjunto[1..10] de Cad_Aluno
 Estruturas de Dados
Leitura de Arrays de Registros no Português estruturado
Programa Leitura
tipo
Cad_Aluno = registro
NOME : Literal
NOTA1: numerico
NOTA2 : numerico
NOTA3 : numerico
NOTA4 : numerico
fim_registro
var
vet_ALUNO : conjunto [1..10] de Cad_Aluno
i : numerico
inicio
para i de 1 até 10 faça
leia vet_ALUNO[i].NOME
leia vet_ALUNO[i].NOTA1
leia vet_ALUNO[i].NOTA2
leia vet_ALUNO[i].NOTA3
leia vet_ALUNO[i].NOTA4
fim-para
fim
 Estruturas de Dados
Escrita em Arrays de Registros no Português estruturado
Programa Escrita
tipo
Cad_Aluno = registro
NOME : Literal
NOTA1: numerico
NOTA2 : numerico
NOTA3 : numerico
NOTA4 : numerico
fim_registro
var
vet_ALUNO : conjunto [1..10] de Cad_Aluno
i : numerico
inicio
para i de 1 até 10 faça
escreva vet_ALUNO[i].NOME
escreva vet_ALUNO[i].NOTA1
escreva vet_ALUNO[i].NOTA2
escreva vet_ALUNO[i].NOTA3
escreva vet_ALUNO[i].NOTA4
fim-para
fim
 Estruturas de Dados
Implementação de Arrays de Registros em Java : Classes
class Cad_Aluno {
String nome;
double nota1, nota2, nota3, nota4;
}

public class Grava_e_Le_Aluno {

public static void main (String[] args) {
Cad_Aluno aluno[] = new Cad_Aluno[10]; /*cria um Array com 10 objetos do tipo Cad_Aluno
for (int i=0; i<10; i++) {
aluno[i] = new Cad_Aluno();
aluno[i].nome = JoptionPane.showInputDialog(“Entre com o Nome:“);
aluno[i].nota1 = Double.parseDouble(JoptionPane.showInputDialog(“Nota1:“));
aluno[i].nota2 = Double.parseDouble(JoptionPane.showInputDialog(“Nota2:“));
aluno[i].nota3 = Double.parseDouble(JoptionPane.showInputDialog(“Nota3:“));
aluno[i].nota4 = Double.parseDouble(JoptionPane.showInputDialog(“Nota4:“));
}
for (int i=0; i<10; i++) {
System.out.println(aluno[i].nome);
System.out.println(aluno[i].nota1);
System.out.println(aluno[i].nota2);
System.out.println(aluno[i].nota3);
System.out.println(aluno[i].nota4);
}
}
}