Aula 06,07, 08

Listas Lineares

Listas lineares (Fila e Pilha) e duplamente encadeadas

Profa. Jéssica Oliveira

Listas Lineares

É uma estrutura de dados na qual os elementos estão organizados de maneira

sequencial.

É formada por um conjunto de dados afins (de um mesmo tipo). O elemento

é chamado de nó ou nodo.
Preserva a relação de ordem entre seus elementos.

Não necessariamente os elementos estão fisicamente em ordem na memória

Quando os elementos estão fisicamente em ordem – lista linear sequencial

(ou contigua)

Quando não estão fisicamente em ordem – lista linear encadeada

Listas Lineares

De acordo com as operação que são permitidas

serem realizadas, as listas lineares se classificam
em:

- Pilhas

- Filas
Pilhas
É uma lista linear na qual o primeiro elemento a entrar é o último elemento a
sair.

Também é chamada de LIFO (“LAST IN FIRST OUT”), o último elemento

que entrou, é o primeiro a sair.

Possui apenas uma entrada, chamada de topo, a partir da qual os dados

entram e saem dela. Exemplos de pilhas são:

pilha de pratos,
pilha de livros,
pilha de cartas de um baralho, Fonte: https://www.google.com/lbaralhoempilhado
etc.

Fonte: https://www.google.com/livro
Fonte: https://www.google.com/prato
Exemplo da Pilha em C

#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <string>

struct lista{
int info;
struct lista *prox;
};

typedef struct lista Lista;

Lista *topoLista = NULL;

/* inserção no início: retorna a lista atualizada */

void insere(){
int valor;

system("cls");
printf("----------------------------------------\n");
Fila
É uma lista linear na qual o primeiro elemento a entrar é o primeiro
elemento a sair.

Também é chamada de FIFO (“FIRST IN FIRST OUT”) - O primeiro

elemento que entrar será o primeiro a sair.

Os elementos ”entram por trás e saem pela frente”.

Exemplos de filas são: Fila de caixa de banco, Fila de vagões

de trem, Sala de espera de um médico

Fonte: https://www.google.com/fila
Exemplo de Fila em C

#include <stdio.h>
#include <stdlib.h>

struct lista{
int info;
struct lista *prox;
};

struct lista *topoLista=NULL;

int cont=0;

/* inserção no início: retorna a lista atualizada */

struct lista *insere (int v)
{
struct lista *novo = (struct lista*) malloc(sizeof(struct lista))
novo->info = v;
novo->prox = topoLista;
topoLista = novo;
cont++;
 LL duplamente encadeadas

Lista Duplamente encadeadas

• Cada nodo tem 2 campos de elo

• A lista pode ser percorrida nas duas direções

Anterior Info Próximo

Nodo genérico
PtLista

L1 L2 L3 L4
 LL duplamente encadeadas

Operações
• Criar e inicializar uma lista
• Inserir novo nodo
• Remover um nodo Algoritmos
• Consultar um nodo
• Destruir lista Semelhantes a LL encadeada simples

Tipo de nodo utilizado nos algoritmos:

struct no {
struct no* ant;
int info;
struct no* prox;
}
typedef struct no Lista;
Algoritmo: criar lista circular
Lista* Cria_lista(void)

Lista* Cria_lista(void)
{
return NULL;
}
 LL duplamente encadeadas

Inserção de um novo nodo no meio da

lista
Novo nodo
PtLista
L5

L1 L2 L3 L4

PtLista L5

L1 L2 L3 L4
 Inserção de um novo nodo no
inicio da lista
PtLista
L5

L1 L2 L3 L4

PtLista

L5 L1 L2 L3 L4
Algoritmo: inserir um nodo no inicio da lista
Lista* Insere_elem(Lista* Ptl,int elem)
Lista* Insere_elem(Lista *Ptl, int elem)
{
Lista *Ptnodo;
Ptnodo = (Lista*)malloc(sizeof(Lista));
if (Ptnodo == NULL)
return Ptl;
Ptnodo->info = elem;
Ptnodo->prox = Ptl;
Ptnodo->ant = NULL;
if(Ptl != NULL)
Ptl->ant = Ptnodo;
Ptl = Ptnodo;
return Ptl;
}
 LL duplamente encadeadas

Remoção de novo nodo

PtLista
Remover

A B C D

PtLista

A B C D
Algoritmo:Remover um nodo de LL Duplamente Encadeada
Lista* Remove_elem(Lista *Ptl, int elem)

Lista* Remove_elem(Lista *Ptl, int elem)

{
Lista *atual;
if (Ptl == NULL)
return Ptl;

atual = Ptl;
while (atual != NULL && elem != atual->info)
{
atual = atual->prox;
}
if (atual == NULL)// não achou
return Ptl;

if (atual == Ptl)// primeiro nodo a ser removido

Ptl = atual->prox;
else // nodo removido do meio ou do final da lista
atual->ant->prox = atual->prox;

if (atual->prox != NULL)
atual->prox->ant = atual->ant;
free(atual);
return Ptl;
}
 LL duplamente encadeadas

Consulta à lista

• Acesso sempre pelo primeiro nodo da lista

• A lista pode ser percorrida nas duas direções
 LL encadeada circular
Algoritmo: Consulta K-esimo nodo da Lista
int Consulta_nodo(Lista Ptl, int pos,int *elem)
int Consulta_nodo(Lista *Ptl, int pos, int *elem)
{
int cont = 1;
Lista *pt;
pt = Ptl;
if (pos <= 0 || pt == NULL)
return 0;
while(pt != NULL && cont < pos)
{
pt=pt->prox;
cont++;
}
if (pt == NULL)
return 0;
else {
*elem=pt->info;
return 1;
}
}
Algoritmo: destruir lista circular
Lista* Libera_lista(Lista *Ptl)

Lista* Libera_lista(Lista *Ptl)

{
Lista *aux;
while (Ptl!= NULL)
{
aux = Ptl;
Ptl = Ptl->prox;
free(aux);
}

return NULL;
}
 lladae2d.h

typedef struct no Lista;

Lista* Cria_lista(void);
Lista* Libera_lista(Lista* Ptl);
int E_vazia(Lista* Ptl);
int E_cheia(Lista* Ptl);
Lista* Insere_elem(Lista* Ptl, int elem);
Lista* Remove_elem(Lista* Ptl, int elem);
int Tamanho_lista(Lista* Ptl);
int Consulta_nodo(Lista* Ptl, int pos, int *elem);
#include <stdio.h>
#include <stdlib.h>
#include "lladae2d.h“ lladae2d.c
struct no {
struct no* ant;
int info;
struct no* prox;
};
Lista* Cria_lista(void)
{……..}
Lista* Libera_lista(Lista *Ptl)
{…….}
int E_vazia(Lista *Ptl)
{…….}
int E_cheia(Lista *Ptl)
{…….}
Lista* Insere_elem(Lista *Ptl, int elem)
{.......}
Lista* Remove_elem(Lista *Ptl, int elem)
{.......}
int Tamanho_lista(Lista Ptl)
{…….}
int Consulta_nodo(Lista *Ptl, int pos,int *elem)
{……}
 insereInicio(LISTA);
break;

case 3:
insereFim(LISTA);
break;

case 4:
inicia(LISTA);
break;

default:
printf("Comando invalido\n\n");
}
}

int vazia(node *LISTA)

{
if(LISTA->prox == NULL)
return 1;
else
return 0;
}
 Referências

1. ASCENCIO , Ana Fernanda Gomes; ARAUJO, Graziela Santos. Estrutura de Dados:

algoritmos, analise da complexidade e implementações
em Java e C/C++. São Paulo. Pearson. 2010
2. PUGA, Sandra; RISSETTI, Gerson Logica de Programação e Estruturas de Dados - Com
Aplicações em Java - 3? Ed. Pearson. 2010.

3. TAMASSIA, Roberto; GOODRICH, Michael T., Estruturas de Dados e Algoritmos em Java

[recurso eletrônico, Minha Biblioteca]. Porto
Alegre: Grupo A, 2011.
 Exercício

Veja a lista de atividades sobre lista no

BlackBoard