Capítulo 2
Recapitulação

2.2 Listas usando Vetores

2.2 Estrutura de Dados Lista - Definição
    2.2.1 Listas usando Vetores: Modelagem de Listas utilizando Programação Estruturada
      Modelagem da Lista
      Algoritmo InicializaLista
      Algoritmo DestroiLista
      Algoritmo ListaCheia
      Algoritmo ListaVazia
      Algoritmo Adiciona
      Algoritmo Retira
      Algoritmo AdicionaNoInício
      Algoritmo RetiraDoInício
      Algoritmo AdicionaNaPosição
      Algoritmo RetiraDaPosição
      Algoritmo AdicionaEmOrdem
      Algoritmo RetiraEspecífico
      Algoritmos Restantes
    2.2.2 Exercícios de implementação

 
 
 
 
 
 
 
 
 
 
Esta Aula em PowerPoint

2.2 Estrutura de Dados Lista - Definição

Uma Estrutura de Dados Lista é um conjunto de dados dispostos e/ou acessáveis em uma seqüência determinada. Vimos 2 Aspectos Em um projeo de software, 2 aspectos devem ser considerados:


2.2.1 Listas usando Vetores: Modelagem de Listas utilizando Programação Estruturada

Modelagem da Lista
  constantes Maxlista = 100; tipo Lista {

inteiro dados[Maxlista];

inteiro ultimo;

};
 

  1. Colocar e retirar dados da lista.
  2. Testar se a lista está vazia ou cheia e outros testes.
  3. Inicializa-la e garantir a ordem dos elementos.
Adiciona(dado)
AdicionaNoInício(dado)
AdicionaNaPosição(dado,posição)
AdicionaEmOrdem(dado)
Retira()
RetiraDoInício()
RetiraDaPosição(posição)
RetiraEspecífico(dado)
ListaCheia
ListaVazia
Posicao(dado)
Contem(dado)
Igual(dado1,dado2)
Maior(dado1,dado2)
Menor(dado1,dado2)
InicializaLista
DestroiLista


Algoritmo InicializaLista

FUNÇÃO inicializaLista()
início
    aLista.ultimo <- -1;
fim;

Observação: Este e os próximos algoritmos pressupõem que foi definida uma variável global tipo Lista denominada aLista.
 

Algoritmo DestroiLista
  FUNÇÃO destroiLista()
início
    aLista.ultimo <- -1;
fim;

Observação: Este algoritmo parece redundante. Colocar a sua semantica em separado da inicialização porém, é importante. Mais tarde veremos que, utilizando alocação deinâmica de memória, possuir um destrutor para alista é muito importante.
 

Algoritmo ListaCheia Booleano FUNÇÃO listaCheia()
início
    SE (aLista.ultimo = Maxlista - 1) ENTÃO
        RETORNE(Verdade)
    SENÃO
        RETORNE(Falso);
    FIM SE
fim;
Algoritmo ListaVazia Booleano FUNÇÃO listaVazia()
início
    SE (aLista.ultimo = -1) ENTÃO
        RETORNE(Verdade);
    SENÃO
        RETORNE(Falso);
    FIM SE
fim;
Algoritmo Adiciona Constantes ErroListaCheia = -1;
ErroListaVazia = -2;
ErroPosição = -3;


Inteiro FUNÇÃO adiciona(inteiro dado)
início

SE (listaCheia) ENTÃO RETORNE(ErroListaCheia); SENÃO aLista.ultimo <- aLista.ultimo + 1.
aLista.dados[aLista.ultimo] <- dado;
RETORNE(aLista.ultimo);
FIM SE
fim;
Algoritmo Retira Inteiro FUNÇÃO retira()
início SE (listaVazia) ENTÃO RETORNE(ErroListaVazia); SENÃO aLista.ultimo <- aLista.ultimo - 1.
RETORNE(aLista.dados[aLista.ultimo + 1]);
FIM SE
fim;

Observação: note que aqui se aplicam as mesmas restrições das diversas variantes do algoritmo desempilha.


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.ultimo <- aLista.ultimo + 1;
posição <- aLista.ultimo;
ENQUANTO (posição > 0) FAÇA "Empurrar tudo para tras"
aLista.dados[posicao] <- aLista.dados[posicao - 1];
posição <- posição - 1;
FIM ENQUANTO
aLista.dados[0] <- dado;
RETORNE(0);
FIM SE
fim;
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.ultimo <- aLista.ultimo - 1;
valor <- aLista.dados[0];
posição <- 0;
ENQUANTO (posição <= aLista.ultimo) FAÇA "Empurrar tudo para frente"
aLista.dados[posicao] <- aLista.dados[posicao + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
fim;
Algoritmo AdicionaNaPosição Inteiro FUNÇÃO adicionaNaPosição(inteiro dado, destino)
variáveis inteiro posição; início SE (listaCheia) ENTÃO RETORNE(ErroListaCheia); SENÃO SE (destino > aLista.ultimo + 1) ENTÃO RETORNE(ErroPosição); FIM SE
aLista.ultimo <- aLista.ultimo + 1;
posição <- aLista.ultimo;
ENQUANTO (posição > destino) FAÇA "Empurrar tudo para tras"
aLista.dados[posicao] <- aLista.dados[posicao - 1];
posição <- posição - 1;
FIM ENQUANTO
aLista.dados[destino] <- dado;
RETORNE(destino);
FIM SE
fim;
Algoritmo RetiraDaPosição Inteiro FUNÇÃO retiraDaPosição(inteiro fonte)
variáveis inteiro posição;
inteiro valor;
início SE (fonte > aLista.ultimo) ENTÃO RETORNE(ErroPosição); SENÃO SE (listaVazia) ENTÃO RETORNE(ErroListaVazia); SENÃO aLista.ultimo <- aLista.ultimo - 1;
valor <- aLista.dados[fonte];
posição <- fonte;
ENQUANTO (posição <= aLista.ultimo) FAÇA "Empurrar tudo para frente"
aLista.dados[posicao] <- aLista.dados[posicao + 1];
posição <- posição + 1;
FIM ENQUANTO
RETORNE(valor);
FIM SE
FIM SE
fim;
Algoritmo AdicionaEmOrdem


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.ultimo 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;
Algoritmo RetiraEspecífico
Preâmbulo: Algoritmo Posição
Inteiro FUNÇÃO posição(inteiro dado)
variáveis inteiro posição; início posição <- 0;
ENQUANTO (posição <= aLista.ultimo E
          NÃO(IGUAL(dado,aLista.dados[posição]))) FAÇA posição <- posição + 1; FIM ENQUANTO
SE (posição > aLista.ultimo) ENTÃO RETORNE(ErroPosição); SENÃO RETORNE(posição); FIM SE
fim;
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); SENÃO RETORNE(retiraDaPosição(posição)); FIM SE
FIM SE
fim;
Algoritmos Restantes 2.2.2.2 Exercícios de implementação: