FACULDADE BATISTA MINEIRA - CST Banco de Dados Prof

FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
Uma estrutura de dados é um modo particular de armazenamento e organização de dados em
um computador de modo que possam ser usados eficientemente.
Diferentes tipos de estrutura de dados são adequados a diferentes tipos de aplicação e algumas
são altamente especializadas, destinando-se a algumas tarefas específicas.
Estruturas de dados e algoritmos são temas fundamentais da ciência da computação, sendo
utilizados nas mais diversas áreas do conhecimento e com os mais diferentes propósitos de
aplicação. Sabe-se que algoritmos manipulam dados. Quando estes dados estão organizados
(dispostos) de forma coerente, caracterizam uma forma, uma estrutura de dados. A
organização e os métodos para manipular essa estrutura é que lhe conferem singularidade.
A escolha de uma estrutura de dados apropriada pode tornar um problema complicado em um
de solução relativamente simples. O estudo das estruturas de dados está em constante
desenvolvimento (assim como o de algoritmos), mas, apesar disso, existem certas estruturas
clássicas que se comportam como padrões.
As estruturas de dados são chamadas tipos de dados compostos que se dividem em
homogêneos (vetores e matrizes) e heterogêneos (registros).


As estruturas homogêneas são conjuntos de dados formados pelo mesmo tipo de dado primitivo.
As estruturas heterogêneas são conjuntos de dados formados por tipos de dados primitivos
diferentes (campos do registro) em uma mesma estrutura.
I - Estruturas homogêneas
um array, também conhecido como vetor (para arrays uni-dimensionais) ou matriz (para
arrays bi-dimensionais), é uma das mais simples estruturas de dados.
Os arrays mantêm uma série de elementos de dados, geralmente do mesmo tamanho e tipo de
dados. Elementos individuais são acessados por sua posição no array. A posição é dada por um
índice, também chamado de subscrição. O índice geralmente utiliza uma sequência de números
inteiros, mas o índex pode ter qualquer valor ordinal.
Os arrays podem ser considerados como as estruturas de dados mais simples. Têm a vantagem
de que os seus elementos são acessíveis de forma rápida, mas têm uma notável limitação: são
de tamanho fixo.
A) Vetores
Declaramos vetores de maneira muito semelhante à declaração de variáveis normais. A única
diferença é que depois do nome da variável deve ser informada a quantidade de elementos do
vetor. Para declarar um vetor chamado vetor, com cinco elementos inteiros, escrevemos:
int vetor[5];
Note que a quantidade de elementos de um vetor não pode ser alterada depois que o vetor for
declarado. Para criar vetores de tamanho dinâmico, podemos usar ponteiros, que serão
abordados mais adiante.
Da mesma maneira que podemos inicializar uma variável junto com sua declaração, podemos
usar as chaves ({}) para inicializar um array.
int vetor[5] = {17, 42, 9, 33, 12};
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
1
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
Para fazer referência a um valor a um elemento de um vetor, usamos a notação vetor[índice],
que serve tanto para obter quanto para definir o valor de um elemento específico, dada sua
posição. Note que os elementos são numerados a começar do zero, e, portanto, se o número de
elementos é N, o índice ou posição do último elemento será N − 1.
vetor[0] = 3;
int x = vetor[2];
int y = vetor[5]; // ERRO!
Repare em que a última linha contém um erro: ela referencia um elemento do vetor que não
existe. No entanto, o compilador não se recusará a compilar esse código; dará apenas um
aviso. Se essa linha for executada, a variável y receberá um valor que não tem nada a ver com
o vetor.
O código abaixo é de um programa que declara uma vetor de inteiros de 5 ocorrências, popula
e exibe.
public class Vet01
{
public static void main(String args[])
{
int vetor[];
vetor = new int[10];
//
for (int i = 0; i < vetor.length; i++)
{
vetor[i] = i;
System.out.println("vetor["+i+"] = "+i);
}
}
}
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
2
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
B) Strings
import javax.swing.JOptionPane;
public class Ex
{
public static String le_frase(String msg,int piso,int teto)
{
String entrada="";
//
while ((entrada.length() < piso) || (entrada.length() > teto))
{
entrada = JOptionPane.showInputDialog(msg+"\n[ mínimo "+piso+" máximo
"+teto+" ]");
// Se pressione "cancel"
if ( entrada == null )
entrada = "";
}
//
return entrada.trim();
}
public static String vertical(String entrada)
{
String ret="";
int x =0;
//
for (x = 0; x < entrada.length(); x++)
{
ret += entrada.charAt(x)+"\n";
}
//
return ret;
}
public static String invertida(String entrada)
{
String ret="";
int x =0;
//
for (x = entrada.length()-1; x >= 0; x--)
{
ret += entrada.charAt(x);
}
//
return ret;
}
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
3
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
public static String vogais(String entrada)
{
String ret = "";
String vogais = "AaÁáÃãÂâEeÉéÊêIiÍíÎîOoÓóÔôUuÚúÛû";
int x
= 0;
int y
= 0;
//
for (x = 0; x < entrada.length(); x++)
{
for (y = 0; y < vogais.length(); y++)
{
if ( entrada.charAt(x) == vogais.charAt(y))
ret += entrada.charAt(x);
}
}
//
return ret;
}
public static String consoantes(String entrada)
{
String ret
= "";
String vogais = "AaÁáÃãÂâEeÉéÊêIiÍíÎîOoÓóÔôUuÚúÛû";
int x
= 0;
int y
= 0;
boolean consoante = false;
//
for (x = 0; x < entrada.length(); x++)
{
consoante = true;
for (y = 0; y < vogais.length(); y++)
{
if ( entrada.charAt(x) == vogais.charAt(y))
{
consoante = false;
break;
}
}
//
if ( consoante )
ret += entrada.charAt(x);
}
//
return ret;
}
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
4
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
public static void main(String args[])
{
String frase = "" , aux="";
int metade = 0;
//
frase = le_frase("Digite uma frase",5,25);
//
JOptionPane.showMessageDialog(null,"Frase
=
["+frase+"]","Tratamento
de
Strings",JOptionPane.WARNING_MESSAGE);
//
JOptionPane.showMessageDialog(null,"Quantidade de caracteres = "+frase.length(),"Tratamento de
Strings",JOptionPane.WARNING_MESSAGE);
//
aux = vertical(frase);
JOptionPane.showMessageDialog(null,aux,"Frase na vertical",JOptionPane.WARNING_MESSAGE);
//
aux = invertida(frase);
JOptionPane.showMessageDialog(null,aux,"Frase invertida",JOptionPane.WARNING_MESSAGE);
//
aux = vogais(frase);
JOptionPane.showMessageDialog(null,aux,"Somente as vogais",JOptionPane.WARNING_MESSAGE);
//
aux = consoantes(frase);
JOptionPane.showMessageDialog(null,aux,"Somente
as
consoantes",JOptionPane.WARNING_MESSAGE);
//
aux = frase.toUpperCase();
JOptionPane.showMessageDialog(null,aux,"Maiúsculas",JOptionPane.WARNING_MESSAGE);
//
aux = frase.toLowerCase();
JOptionPane.showMessageDialog(null,aux,"Maiúsculas",JOptionPane.WARNING_MESSAGE);
//
metade = (int) frase.length() / 2;
//
aux = frase.substring(0, metade);
JOptionPane.showMessageDialog(null,aux,"1a metade",JOptionPane.WARNING_MESSAGE);
//
aux = frase.substring(metade);
JOptionPane.showMessageDialog(null,aux,"2a metade",JOptionPane.WARNING_MESSAGE);
//
System.exit(0);
}
}
Saída do programa:
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
5
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
6
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
7
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
C) Matrizes
São matrizes linha-coluna, onde o primeiro índice indica a linha e o segundo a coluna. Esse tipo
de matriz é considerado o caso mais simples de matrizes multidimensionais.
import javax.swing.JOptionPane;
import java.text.*;
public class Mat01
{
public static void main(String args[])
{
int mat[][];
int linhas = 0,colunas=0;
double x = 0;
String aux = "";
//
DecimalFormat Mk3 = new DecimalFormat("000");
DecimalFormat Mk2 = new DecimalFormat("00");
//
while ( linhas < 5 )
{
x = Math.random()*20;
linhas = (int) x;
}
//
while ( colunas < 5 )
{
x
= Math.random()*8;
colunas = (int) x;
}
//
mat = new int[linhas][colunas];
//
for (int l = 0; l < mat.length; l++)
{
for (int c = 0; c < mat[l].length; c++)
{
x = Math.random()*1000;
mat[l][c] = (int) x;
aux += "mat["+Mk2.format(l)+"]["+Mk2.format(c)+"] = "+Mk3.format(mat[l][c])+" ";
}
aux += "\n";
}
JOptionPane.showMessageDialog(null,aux,"Matriz",JOptionPane.INFORMATION_MESSAGE);
System.exit(0);
}
}
Esse exemplo calcula a determinante de uma matriz de ordem 2 e através dele podemos ver
como deve ser feita a declaração de uma matriz bidimensional.
mat = new int[linhas][colunas];
Que a forma geral é:
tipo nome_matriz[numero_linhas][numero_colunas];
Observe na formula que calcula a determinante que os valores são acessados através de seus
índices (linhas e colunas).
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
8
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
A seguir são apresentadas as saídas do programa:
D) Matrizes multidimensionais
A linguagem Java permite também utilizar matriz de três ou mais dimensões, porém não é
frequentemente usada, pois requer uma quantidade grande de memória e os acessos aos seus
elementos são mais lentos.
Declaração de matrizes multidimensionais:
Tipo nome [tamanho1][tamanho2][tamanho3]....[tamanho n]
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
9
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
import javax.swing.JOptionPane;
import java.text.*;
public class BolhaMat
{
static int le_int(String msg, int piso, int teto)
{
int x;
String aux;
boolean repete;
x
= 0;
repete = true;
while ( repete )
{
aux = JOptionPane.showInputDialog(msg+" entre "+piso+" e "+teto);
try
{
x = Integer.parseInt(aux);
if (( x < piso ) || ( x > teto)) throw new NumberFormatException();
else
repete = false;
}
catch (NumberFormatException nfe) {
JOptionPane.showMessageDialog(null,"Valor incorreto. Digite novamente.",
"Erro",JOptionPane.ERROR_MESSAGE);
}
}
return x;
}
static void popula(int m[][])
{
for (int l=0;l<m.length;l++)
{
for (int c=0;c<m[l].length;c++)
{
m[l][c] = le_int("Digite o valor da linha "+(l+1)+" e da coluna "+(c+1),-100,100);
}
}
}
public static void exibe(int m[][],String tit)
{
DecimalFormat Mk = new DecimalFormat("000 ");
String msg="",aux="";
System.out.println("\n"+tit);
for (int l=0;l<m.length;l++)
{
for (int c=0;c<m[l].length;c++)
{
aux = Mk.format(m[l][c]);
System.out.print(aux);
msg = msg+aux;
}
System.out.print("\n");
msg = msg+"\n";
}
JOptionPane.showMessageDialog(null,msg,tit,JOptionPane.PLAIN_MESSAGE);
System.out.println(); }
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
10
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
public static void ordena(int mat[][])
{
int tam;
tam = qtd_ocorrencias(mat);
int vet[] = new int [tam];
//
popula_vet(vet,mat);
//
bolha(vet);
//
popula_mat(mat,vet);
}
public static int qtd_ocorrencias(int mat[][])
{
int t=0;
for (int l=0;l<mat.length;l++)
{
for (int c=0;c<mat[l].length;c++)
{
t++;
}
}
return t;
}
public static void popula_vet(int v[],int m[][])
{
int i=0;
for (int l=0;l<m.length;l++)
{
for (int c=0;c<m[l].length;c++)
{
i = ((l*m[l].length)+c);
v[i] = m[l][c];
}
}
}
public static void popula_mat(int m[][],int v[])
{
int i=0;
for (int l=0;l<m.length;l++)
{
for (int c=0;c<m[l].length;c++)
{
i
= ((l*m[l].length)+c);
m[l][c] = v[i];
}
}
}
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
11
FACULDADE BATISTA MINEIRA - CST Banco de Dados
Estruturas de Dados - Tipos de Dados Compostos
public static void bolha(int vet[])
{
int limite = vet.length-1;
int bolha = 0;
int atual = 0;
int proximo = 0;
int temp = 0;
//
for (bolha = limite; bolha >= 0; bolha-- )
{
for (atual=0,proximo=1; atual < bolha; atual++,proximo++)
{
if (vet[atual] > vet[proximo])
{
temp
= vet[atual];
vet[atual] = vet[proximo];
vet[proximo] = temp;
}
}
}
}
public static void main(String args[])
{
int linhas = 0;
int colunas = 0;
System.out.println("(C) 2005 Prof. Rogerio Rocha");
// Define a qtd de linhas
linhas = le_int("Digite a qtd de linhas",2,10);
// Define a qtd de colunas
colunas = le_int("Digite a qtd de colunas",2,10);
// Define a matriz
int mat[][] = new int[linhas][colunas];
// Popula a matriz
popula(mat);
// Exibe a matriz
exibe(mat,"Desordenada");
// Ordena a matriz pelo metodo da bolha
ordena(mat);
// Exibe a matriz
exibe(mat,"Ordenada");
//
System.exit(0);
}
}
Prof. Rogério Rocha
[email protected] – http://www.rozero.host22.com
12