INE5408 Estruturas de Dados

Apresentação em tema: "INE5408 Estruturas de Dados"— Transcrição da apresentação:

1 INE5408 Estruturas de Dados
Estruturas de Dados básicas utilizando Vetores - Listas

2 Lista - Definição Uma Lista é um conjunto de dados dispostos e / ou acessáveis em uma seqüência determinada. Este conjunto de dados pode possuir uma ordem intrínseca (Lista Ordenada) ou não; este conjunto de dados pode ocupar espaços de memória fisicamente consecutivos, espelhando a sua ordem, ou não; se os dados estiverem dispersos fisicamente, para que este conjunto seja uma lista, ele deve possuir operações e informações adicionais que permitam que seja tratado como tal (Lista Encadeada).

3 Vimos dois aspectos Em um projeto de software, dois aspectos devem ser considerados: de que forma estão organizados os dados, qual a sua estrutura; quais procedimentos atuam sobre estes dados, que operações podem ser realizadas sobre eles. Vamos ver agora estes aspectos para as listas.

4 Listas A Lista é uma estrutura de dados cujo funcionamento é inspirado no de uma lista “natural”. Uma lista pode ser ordenada ou não: quando for ordenada, pode o ser por alguma característica intrínseca dos dados (ex: ordem alfabética); pode também refletir a ordem cronológica (ordem de inserção) dos dados; em Smalltalk, a OrderedCollection é uma lista cronológica (add:), a SortedCollection é uma lista ordenada por um critério interno. 89 55 24 20 12 4 24 89 12 4 55 20

5 Listas usando Vetores Lista vazia
Vetores possuem um espaço limitado para o armazenamento de dados; necessitamos definir um espaço grande o suficiente para a lista; necessitamos de um indicador de qual elemento do vetor é o atual último elemento da lista. 24 4 5 -1 3 2 1 89 12 4 55 20 Lista cheia

6 Modelagem de Listas utilizando Programação Estruturada
Modelaremos a Estrutura de Dados Lista utilizando a técnica da Programação Estruturada, armazenando os dados em um Vetor (Array). Veremos somente algoritmos; veremos algoritmos tanto para uma lista cronológica quanto para uma lista ordenada. Procedimento Didático: modelagem da Lista e de seus algoritmos usando a técnica estruturada; exercícios.

7 Modelagem da Lista Aspecto Estrutural: Pseudo-código:
necessitamos de um vetor para armazenar as informações; necessitamos de um indicador da posição atual do último elemento da lista; necessitamos de uma constante que nos diga quando a lista está cheia e duas outras para codificar erros. Pseudo-código: constantes MAXLISTA = 100; tipo Lista { inteiro dados[MAXLISTA]; inteiro último; };

8 Modelagem da Lista Aspecto Funcional:
colocar e retirar dados da lista; testar se a lista está vazia ou cheia (dentre outros testes); inicializar a lista e garantir a ordem de seus elementos.

9 Modelagem da Lista Operações: adicionar e retirar dados da lista
Adiciona(dado) AdicionaNoInício(dado) AdicionaNaPosição(dado, posição) AdicionaEmOrdem(dado) Retira() RetiraDoInício() RetiraDaPosição(posição) RetiraEspecífico(dado)

10 Modelagem da Lista Operações: testar a lista ListaCheia ListaVazia
Posição(dado) Contém(dado) Igual(dado1, dado2) Maior(dado1, dado2) Menor(dado1, dado2)

11 Modelagem da Lista Operações: inicializar ou limpar a lista
InicializaLista DestróiLista

12 Algoritmo InicializaLista
FUNÇÃO inicializaLista() início aLista.último <- -1; fim; Observação: este e os próximos algoritmos pressupõem que foi definida uma variável global tipo Lista denominada aLista.

13 Algoritmo DestróiLista
FUNÇÃO destróiLista() início aLista.último <- -1; fim; Observação: este algoritmo parece redundante. Colocar a sua semântica em separado da inicialização, porém, é importante. Mais tarde veremos que, utilizando alocação dinâmica de memória, possuir um destrutor para aLista é muito importante.

14 Algoritmo ListaCheia Booleano FUNÇÃO listaCheia() início
SE (aLista.último = MAXLISTA - 1) ENTÃO RETORNE(Verdadeiro) SENÃO RETORNE(Falso); fim;

15 Algoritmo ListaVazia Booleano FUNÇÃO listaVazia() início
SE (aLista.último = -1) ENTÃO RETORNE(Verdadeiro) SENÃO RETORNE(Falso); fim;

16 Algoritmo Adiciona Procedimento: Parâmetros: testamos se há espaço;
incrementamos o último; adicionamos o novo dado. Parâmetros: o dado a ser inserido; Lista (global). 55 4 12 89 24 4 5 20

17 Algoritmo Adiciona ERROLISTACHEIA = -1; Constantes
ERROLISTAVAZIA = -2; ERROPOSIÇÃO = -3; Inteiro FUNÇÃO adiciona(inteiro dado) início SE (listaCheia) ENTÃO RETORNE(ERROLISTACHEIA) SENÃO aLista.último <- aLista.último + 1; aLista.dados[aLista.último] <- dado; RETORNE(aLista.último); FIM SE fim;

18 Algoritmo Retira Procedimento: testamos se há elementos;
decrementamos o último; devolvemos o último elemento. Parâmetros: Lista (global).

19 Algoritmo Retira Inteiro FUNÇÃO retira() início SE (listaVazia) ENTÃO
RETORNE(ERROLISTAVAZIA) SENÃO aLista.último <- aLista.último – 1; RETORNE(aLista.dados[aLista.último + 1]); FIM SE fim; Observação: note que aqui se aplicam as mesmas restrições das diversas variantes do algoritmo desempilha.

20 Algoritmo AdicionaNoInício
Procedimento: testamos se há espaço; incrementamos o último; empurramos tudo para trás; adicionamos o novo dado na primeira posição. Parâmetros: o dado a ser inserido; Lista (global). 20 24 4 5 89 24 89 12 12 4 55 4 55

21 Algoritmo AdicionaNoInício
Inteiro FUNÇÃO adicionaNoInício(inteiro dado) variáveis inteiro posição; //Variável auxiliar para “caminhar” início SE (listaCheia) ENTÃO RETORNE(ERROLISTACHEIA) SENÃO aLista.último <- aLista.último + 1; posição <- aLista.último; ENQUANTO (posição > 0) FAÇA //Empurrar tudo para trás aLista.dados[posição] < aLista.dados[posição - 1]; posição <- posição - 1; FIM ENQUANTO aLista.dados[0] <- dado; RETORNE(0); FIM SE fim;

22 Algoritmo AdicionaNoInício
Inteiro FUNÇÃO adicionaNoInício(inteiro dado) variáveis inteiro posição; //Variável auxiliar para “caminhar” início SE (listaCheia) ENTÃO RETORNE(ERROLISTACHEIA) SENÃO aLista.último <- aLista.último + 1; posição <- aLista.último; ENQUANTO (posição > 0) FAÇA //Empurrar tudo para trás aLista.dados[posição] < aLista.dados[posição - 1]; posição <- posição - 1; FIM ENQUANTO aLista.dados[0] <- dado; RETORNE(0); FIM SE fim;

23 Algoritmo AdicionaNoInício
Inteiro FUNÇÃO adicionaNoInício(inteiro dado) variáveis inteiro posição; //Variável auxiliar para “caminhar” início SE (listaCheia) ENTÃO RETORNE(ERROLISTACHEIA) SENÃO aLista.último <- aLista.último + 1; posição <- aLista.último; ENQUANTO (posição > 0) FAÇA //Empurrar tudo para trás aLista.dados[posição] < aLista.dados[posição - 1]; posição <- posição - 1; FIM ENQUANTO aLista.dados[0] <- dado; RETORNE(0); FIM SE fim;

24 Algoritmo AdicionaNoInício
Inteiro FUNÇÃO adicionaNoInício(inteiro dado) variáveis inteiro posição; //Variável auxiliar para “caminhar” início SE (listaCheia) ENTÃO RETORNE(ERROLISTACHEIA) SENÃO aLista.último <- aLista.último + 1; posição <- aLista.último; ENQUANTO (posição > 0) FAÇA //Empurrar tudo para trás aLista.dados[posição] < aLista.dados[posição - 1]; posição <- posição - 1; FIM ENQUANTO aLista.dados[0] <- dado; RETORNE(0); FIM SE fim;

25 Algoritmo RetiraDoInício
Procedimento: testamos se há elementos; decrementamos o último; salvamos o primeiro elemento; empurramos tudo para a frente. Parâmetros: Lista (global). 20 55 4 12 89 24 4 5 20 55 4 12 89 24

26 Algoritmo RetiraDoInício
Inteiro FUNÇÃO retiraDoInício() variáveis inteiro posição, valor; início SE (listaVazia) ENTÃO RETORNE(ERROLISTAVAZIA) SENÃO aLista.último <- aLista.último - 1; valor <- aLista.dados[0]; posição <- 0; ENQUANTO (posição <= aLista.último) FAÇA //Empurrar tudo para a frente aLista.dados[posição] < aLista.dados[posição + 1]; posição <- posição + 1; FIM ENQUANTO RETORNE(valor); FIM SE fim;

27 Algoritmo RetiraDoInício
Inteiro FUNÇÃO retiraDoInício() variáveis inteiro posição, valor; início SE (listaVazia) ENTÃO RETORNE(ERROLISTAVAZIA) SENÃO aLista.último <- aLista.último - 1; valor <- aLista.dados[0]; posição <- 0; ENQUANTO (posição <= aLista.último) FAÇA //Empurrar tudo para a frente aLista.dados[posição] < aLista.dados[posição + 1]; posição <- posição + 1; FIM ENQUANTO RETORNE(valor); FIM SE fim;

28 Algoritmo RetiraDoInício
Inteiro FUNÇÃO retiraDoInício() variáveis inteiro posição, valor; início SE (listaVazia) ENTÃO RETORNE(ERROLISTAVAZIA) SENÃO aLista.último <- aLista.último - 1; valor <- aLista.dados[0]; posição <- 0; ENQUANTO (posição <= aLista.último) FAÇA //Empurrar tudo para a frente aLista.dados[posição] < aLista.dados[posição + 1]; posição <- posição + 1; FIM ENQUANTO RETORNE(valor); FIM SE fim;

29 Algoritmo RetiraDoInício
Inteiro FUNÇÃO retiraDoInício() variáveis inteiro posição, valor; início SE (listaVazia) ENTÃO RETORNE(ERROLISTAVAZIA) SENÃO aLista.último <- aLista.último - 1; valor <- aLista.dados[0]; posição <- 0; ENQUANTO (posição <= aLista.último) FAÇA //Empurrar tudo para a frente aLista.dados[posição] < aLista.dados[posição + 1]; posição <- posição + 1; FIM ENQUANTO RETORNE(valor); FIM SE fim;

30 Algoritmo AdicionaNaPosição
Procedimento: testamos se há espaço e se a posição existe; incrementamos o último; empurramos tudo para trás a partir da posição; adicionamos o novo dado na posição informada. Parâmetros: o dado a ser inserido; a posição onde inserir; Lista (global).

31 Algoritmo AdicionaNaPosição
Inteiro FUNÇÃO adicionaNaPosição(inteiro dado, inteiro destino) variáveis inteiro posição; início SE (listaCheia) ENTÃO RETORNE(ERROLISTACHEIA) SENÃO SE (destino > aLista.último + 1 OU destino < 0) ENTÃO RETORNE(ERROPOSIÇÃO); FIM SE aLista.último <- aLista.último + 1; posição <- aLista.último; ENQUANTO (posição > destino) FAÇA //Empurrar tudo para trás aLista.dados[posição] <- aLista.dados[posição - 1]; posição <- posição - 1; FIM ENQUANTO aLista.dados[destino] <- dado; RETORNE(aonde); fim;

32 Algoritmo AdicionaNaPosição
Inteiro FUNÇÃO adicionaNaPosição(inteiro dado, inteiro destino) variáveis inteiro posição; início SE (listaCheia) ENTÃO RETORNE(ERROLISTACHEIA) SENÃO SE (destino > aLista.último + 1 OU destino < 0) ENTÃO RETORNE(ERROPOSIÇÃO); FIM SE aLista.último <- aLista.último + 1; posição <- aLista.último; ENQUANTO (posição > destino) FAÇA //Empurrar tudo para trás aLista.dados[posição] <- aLista.dados[posição - 1]; posição <- posição - 1; FIM ENQUANTO aLista.dados[destino] <- dado; RETORNE(aonde); fim;

33 Algoritmo AdicionaNaPosição
Inteiro FUNÇÃO adicionaNaPosição(inteiro dado, inteiro destino) variáveis inteiro posição; início SE (listaCheia) ENTÃO RETORNE(ERROLISTACHEIA) SENÃO SE (destino > aLista.último + 1 OU destino < 0) ENTÃO RETORNE(ERROPOSIÇÃO); FIM SE aLista.último <- aLista.último + 1; posição <- aLista.último; ENQUANTO (posição > destino) FAÇA //Empurrar tudo para trás aLista.dados[posição] <- aLista.dados[posição - 1]; posição <- posição - 1; FIM ENQUANTO aLista.dados[destino] <- dado; RETORNE(aonde); fim;

34 Algoritmo AdicionaNaPosição
Inteiro FUNÇÃO adicionaNaPosição(inteiro dado, inteiro destino) variáveis inteiro posição; início SE (listaCheia) ENTÃO RETORNE(ERROLISTACHEIA) SENÃO SE (destino > aLista.último + 1 OU destino < 0) ENTÃO RETORNE(ERROPOSIÇÃO); FIM SE aLista.último <- aLista.último + 1; posição <- aLista.último; ENQUANTO (posição > destino) FAÇA //Empurrar tudo para trás aLista.dados[posição] <- aLista.dados[posição - 1]; posição <- posição - 1; FIM ENQUANTO aLista.dados[destino] <- dado; RETORNE(aonde); fim;

35 Algoritmo RetiraDaPosição
Procedimento: testamos se há elementos e se a posição existe; decrementamos o último; salvamos elemento na posição; empurramos tudo para frente até posição. Parâmetros: o dado a ser inserido; a posição onde inserir; Lista (global).

36 Algoritmo RetiraDaPosição
Inteiro FUNÇÃO retiraDaPosição(inteiro fonte) variáveis inteiro posição, valor; início SE (fonte > aLista.último OU fonte < 0) ENTÃO RETORNE(ERROPOSIÇÃO) SENÃO SE (listaVazia) ENTÃO RETORNE(ERROLISTAVAZIA) aLista.último <- aLista.último - 1; valor <- aLista.dados[fonte]; posição <- fonte; ENQUANTO (posição <= aLista.último) FAÇA //Empurrar tudo para frente aLista.dados[posição] <- aLista.dados[posição + 1]; posição <- posição + 1; FIM ENQUANTO RETORNE(valor); FIM SE fim;

37 Algoritmo RetiraDaPosição
Inteiro FUNÇÃO retiraDaPosição(inteiro fonte) variáveis inteiro posição, valor; início SE (fonte > aLista.último OU fonte < 0) ENTÃO RETORNE(ERROPOSIÇÃO) SENÃO SE (listaVazia) ENTÃO RETORNE(ERROLISTAVAZIA) aLista.último <- aLista.último - 1; valor <- aLista.dados[fonte]; posição <- fonte; ENQUANTO (posição <= aLista.último) FAÇA //Empurrar tudo para frente aLista.dados[posição] <- aLista.dados[posição + 1]; posição <- posição + 1; FIM ENQUANTO RETORNE(valor); FIM SE fim;

38 Algoritmo RetiraDaPosição
Inteiro FUNÇÃO retiraDaPosição(inteiro fonte) variáveis inteiro posição, valor; início SE (fonte > aLista.último OU fonte < 0) ENTÃO RETORNE(ERROPOSIÇÃO) SENÃO SE (listaVazia) ENTÃO RETORNE(ERROLISTAVAZIA) aLista.último <- aLista.último - 1; valor <- aLista.dados[fonte]; posição <- fonte; ENQUANTO (posição <= aLista.último) FAÇA //Empurrar tudo para frente aLista.dados[posição] <- aLista.dados[posição + 1]; posição <- posição + 1; FIM ENQUANTO RETORNE(valor); FIM SE fim;

39 Algoritmo RetiraDaPosição
Inteiro FUNÇÃO retiraDaPosição(inteiro fonte) variáveis inteiro posição, valor; início SE (fonte > aLista.último OU fonte < 0) ENTÃO RETORNE(ERROPOSIÇÃO) SENÃO SE (listaVazia) ENTÃO RETORNE(ERROLISTAVAZIA) aLista.último <- aLista.último - 1; valor <- aLista.dados[fonte]; posição <- fonte; ENQUANTO (posição <= aLista.último) FAÇA //Empurrar tudo para frente aLista.dados[posição] <- aLista.dados[posição + 1]; posição <- posição + 1; FIM ENQUANTO RETORNE(valor); FIM SE fim;

40 Algoritmo RetiraDaPosição
Inteiro FUNÇÃO retiraDaPosição(inteiro fonte) variáveis inteiro posição, valor; início SE (fonte > aLista.último OU fonte < 0) ENTÃO RETORNE(ERROPOSIÇÃO) SENÃO SE (listaVazia) ENTÃO RETORNE(ERROLISTAVAZIA) aLista.último <- aLista.último - 1; valor <- aLista.dados[fonte]; posição <- fonte; ENQUANTO (posição <= aLista.último) FAÇA //Empurrar tudo para frente aLista.dados[posição] <- aLista.dados[posição + 1]; posição <- posição + 1; FIM ENQUANTO RETORNE(valor); FIM SE fim;

41 Algoritmo AdicionaEmOrdem
Procedimento: necessitamos de uma função para comparar os dados (maior); testamos se há espaço; procuramos pela posição onde inserir comparando dados; chamamos adicionaNaPosição. Parâmetros: o dado a ser inserido; Lista (global).

42 Algoritmo Maior Booleano FUNÇÃO maior(inteiro dado1, inteiro dado2) início SE (dado1 > dado2) ENTÃO RETORNE(Verdadeiro) SENÃO RETORNE(Falso); FIM SE fim; Observação: quando o dado a ser armazenado em uma lista for algo mais complexo do que um inteiro, a comparação de precedência não será mais tão simples (ex.: Empregado1 > Empregado2) e será resultado de um conjunto mais complexo de operações. Para deixar os algoritmos de operações sobre lista independentes do tipo de dado específico armazenado na lista, usamos uma função deste tipo.

43 Algoritmo AdicionaEmOrdem
Inteiro FUNÇÃO adicionaEmOrdem(inteiro dado) variáveis inteiro posição; //Variável auxiliar para “caminhar” início SE (listaCheia) ENTÃO RETORNE(ERROLISTACHEIA) SENÃO posição <- 0; ENQUANTO (posição <= aLista.último E maior(dado, aLista.dados[posição])) FAÇA //Encontrar posição para inserir posição <- posição + 1; FIM ENQUANTO RETORNE(adicionaNaPosição(dado, posição)); FIM SE fim;

44 Algoritmo RetiraEspecífico
Retira um dado específico da lista. Procedimento: testamos se há elementos; testamos se o dado existe e qual sua posição; necessitamos de uma função Posição(dado); chamamos RetiraDaPosição. Parâmetros: o dado a ser retirado; Lista (global).

45 Algoritmo Posição Inteiro FUNÇÃO posição(inteiro dado) variáveis
inteiro posição; início posição <- 0; ENQUANTO (posição <= aLista.último E NÃO(IGUAL(dado,aLista.dados[posição]))) FAÇA posição <- posição + 1; FIM ENQUANTO SE (posição > aLista.último) ENTÃO RETORNE(ERROPOSIÇÃO) SENÃO RETORNE(posição); FIM SE fim;

46 Algoritmo RetiraEspecífico
Inteiro FUNÇÃO retiraEspecífico(inteiro dado) variáveis inteiro posição; início SE (listaVazia) ENTÃO RETORNE(ERROLISTAVAZIA) SENÃO posição <- posição(dado); SE (posição < 0) ENTÃO RETORNE(ERROPOSIÇÃO) RETORNE(retiraDaPosição(posição)); FIM SE fim;

47 Algoritmos Restantes booleano Contém(dado)
As seguintes funções ficam por conta do aluno : booleano Contém(dado) booleano Igual(dado1, dado2) booleano Menor(dado1, dado2)

48 Exercício de Implementação 3
Implemente uma lista em um vetor utilizando a linguagem de programação “C” e a técnica estruturada de programação. Crie o seu tipo de dados tLista em um headerfile; esta deverá ser uma lista de elementos do tipo tAgenda; o tipo tAgenda é um tipo que representa um nome de 30 posições e um número de telefone; crie uma função maior(a,b) que compare os nomes de duas entradas; programe todas as funções documentando cada função, inclusive com dicionário de dados; crie um programa principal que execute todas as funções de lista a partir de um menu. A função procurar específico deverá basear-se no nome em uma Agenda; além destas funções, o programa deverá ser capaz de listar a lista em ordem alfabética.

49 Modelagem dos Tipos constantes MAXLISTA = 100; tipo tAgenda {
caracter nome[31]; caracter fone[11]; }; tipo tLista { tAgenda dados[MAXLISTA]; inteiro último;

50 Modelagem em “C” #define MAXLISTA 100 typedef struct { char nome[31];
char fone[11]; } tAgenda; tAgenda dados[MAXLISTA]; int ultimo; } tLista; Acessando: x = aLista.dados[10].fone;

51 Para comparar Strings em “C”
Utilize a função de comparação de strings strcmp(); esta função utiliza ponteiros para strings como parâmetros. Isto não é importante agora; você pode utilizar diretamente o nome de um string; observe que a linguagem “C” não permite a atribuição de strings de uma variável para a outra usando-se o comando de atribuição. Isto ocorre porque em “C” um string não é um tipo primitivo, mas sim um tipo composto; utilize a função strcpy() para isto; para as duas funções acima você deve incluir <string.h>.