UNIVERSIDADE FEDERAL

DE MINAS GERAIS

Listas Lineares
Listas Lineares COMPUTER
SCIENCE

• Uma das formas mais simples de representar

elementos de um conjunto
• Itens podem ser acessados, inseridos ou
retirados de uma lista
• Podem crescer ou diminuir de tamanho
durante a execução de um programa, de
acordo com a demanda
Listas Lineares COMPUTER
SCIENCE

• Adequadas quando não é possível prever a

demanda por memória
– Permitem a manipulação de quantidades
imprevisíveis de dados, de formato também
imprevisível
• São úteis em aplicações tais como
manipulação simbólica, gerência de memória,
simulações e compiladores
Definição de Listas Lineares COMPUTER
SCIENCE

• Sequência de zero ou mais itens

– x1, x2, ···, xn, na qual xi é de um determinado tipo e n
representa o tamanho da lista linear
• Sua principal propriedade estrutural envolve as
posições relativas dos itens em uma dimensão
– Assumindo n ≥ 1, x1 é o primeiro item da lista e xn é o
último item da lista
– xi precede xi+1 para i = 1, 2, ···, n – 1
– xi sucede xi-1 para i = 2, 3, ···, n
– o elemento xi é dito estar na i-ésima posição da lista
TAD Listas Lineares COMPUTER
SCIENCE

• Criar uma lista linear vazia

• Inserir um novo item imediatamente após o i-ésimo item
• Retirar o i-ésimo item
• Localizar o i-ésimo item para examinar e/ou alterar o
conteúdo de seus componentes
• Combinar duas ou mais listas lineares em uma lista única
• Partir uma lista linear em duas ou mais listas
• Fazer uma cópia da lista linear
• Ordenar os itens da lista em ordem ascendente ou
descendente, de acordo com alguns de seus componentes
• Pesquisar a ocorrência de um item com um valor particular
em algum componente
Implementações de Listas COMPUTER
SCIENCE

• Várias estruturas de dados podem ser usadas

para representar listas lineares
– Cada uma tem vantagens e desvantagens
• Duas implementações clássicas
– Utilizando arranjos (arrays)
– Utilizando apontadores
Implementação por Arranjos COMPUTER
SCIENCE

• Os itens da lista são armazenados em

posições contíguas de memória
• A lista pode ser percorrida em qualquer
direção
• A inserção de um novo item pode ser
realizada após o último item com custo
constante
• A inserção de um novo item no meio da
lista requer um deslocamento de todos os
itens localizados após o ponto de
inserção
• Retirar um item do início da lista requer
um deslocamento de itens para
preencher o espaço deixado vazio
Implementação por Arranjos COMPUTER
SCIENCE

• Os itens são armazenados em um array de

tamanho suficiente para armazenar a lista
– O campo Último aponta para a posição seguinte a
do último elemento da lista (primeira posição
vazia)
– O i-ésimo item da lista está armazenado na
(i-1)-ésima posição do array, 0 ≤ i < Último
– A constante MAX define o tamanho máximo
permitido para a lista
Implementação por Arranjos COMPUTER
SCIENCE

#define MIN 0
#define MAX 1000

typedef int TChave;

typedef int Apontador;

typedef struct {
TChave Chave;
/* outros componentes */
} TItem;

typedef struct {
TItem Item[MAX];
Apontador Primeiro, Ultimo;
} TLista;
Implementação por Arranjos COMPUTER
SCIENCE

void FLVazia(TLista *Lista) {

Lista->Primeiro = MIN;
Lista->Ultimo = Lista->Primeiro;
}

int Vazia(TLista Lista) {

return (Lista.Primeiro == Lista.Ultimo);
}
Implementação por Arranjos COMPUTER
SCIENCE

// insere x no final da lista

void InsereN(TItem x, TLista *Lista) {
if (Lista->Ultimo >= MAX)
printf("Lista cheia\n");
else {
Lista->Item[Lista->Ultimo] = x;
Lista->Ultimo++;
}
}
Implementação por Arranjos COMPUTER
SCIENCE

// insere x na posição p
void InsereP(TItem x, TLista *Lista, Apontador p) {
int i;

if (Lista->Ultimo >= MAX || p > Lista->Ultimo)

printf("Lista cheia ou posição inválida\n");
else {
for (i = Lista->Ultimo; i > p; i--)
Lista->Item[i] = Lista->Item[i-1];
Lista->Item[p] = x;
Lista->Ultimo++;
}
}
Implementação por Arranjos COMPUTER
SCIENCE

void RetiraP(Apontador p, TLista *Lista, TItem *Item) {

int i;

if (Vazia(*Lista) || p >= Lista->Ultimo) {

printf("Lista vazia ou posição inválida\n");
return;
}
*Item = Lista->Item[p];
Lista->Ultimo--;
for (i = p+1; i <= Lista->Ultimo; i++)
Lista->Item[i-1] = Lista->Item[i];
}
Implementação por Arranjos COMPUTER
SCIENCE

void Imprime(TLista Lista) {

Apontador p;

for (p = Lista.Primeiro; p < Lista.Ultimo; p++)

printf("%d\n", Lista.Item[p].Chave);
}
Implementação por Arranjos
COMPUTER
Vantagens e Desvantagens SCIENCE

• Vantagens
– Economia de memória (“apontadores implícitos”)
– Localidade de acesso (blocos contíguos de memória)
– Acesso O(1) a qualquer item
• Desvantagens
– Inserção e remoção pode causar o deslocamento de
todos os itens no pior caso
– Em aplicações em que não existe previsão sobre o
crescimento da lista, o tamanho máximo da lista tem
de ser definido em tempo de compilação
Implementação por Apontadores COMPUTER
SCIENCE

• Cada item é encadeado com o seguinte

mediante uma variável do tipo Apontador
– Permite utilizar posições não contíguas de
memória
– É possível inserir e retirar elementos sem
necessidade de deslocar os itens seguintes da lista
– Há uma célula cabeça para simplificar as
operações sobre a lista
Implementação por Apontadores COMPUTER
SCIENCE

• A lista é constituída de células

• Cada célula contém um item da lista e um
apontador para a célula seguinte
• O registro TLista contém um apontador para a
célula cabeça e um apontador para a última
célula da lista
Implementação por Apontadores COMPUTER
SCIENCE

typedef int TChave;

typedef struct {
TChave Chave;
/* outros componentes */
} TItem;

typedef struct Celula *Apontador;

typedef struct Celula {

TItem Item;
Apontador Prox;
} TCelula;

typedef struct {
Apontador Primeiro, Ultimo;
} TLista;
Implementação por Apontadores COMPUTER
SCIENCE

void FLVazia(TLista *Lista) {

Lista->Primeiro = malloc(sizeof(TCelula));
Lista->Ultimo = Lista->Primeiro;
Lista->Primeiro->Prox = NULL;
}

int Vazia(TLista Lista) {

return (Lista.Primeiro == Lista.Ultimo);
}
“Cabeça”

Primeiro
?
NULL

Último
Implementação por Apontadores COMPUTER
SCIENCE

// insere x no final da lista

void InsereN(TItem x, TLista *Lista) {
Lista->Ultimo->Prox = malloc(sizeof(TCelula));
Lista->Ultimo = Lista->Ultimo->Prox;
Lista->Ultimo->Item = x;
Lista->Ultimo->Prox = NULL;
}

Primeiro Último

info info info

prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

// insere x no final da lista

void InsereN(TItem x, TLista *Lista) {
Lista->Ultimo->Prox = malloc(sizeof(TCelula));
Lista->Ultimo = Lista->Ultimo->Prox;
Lista->Ultimo->Item = x;
Lista->Ultimo->Prox = NULL;
}

Primeiro Último

info info info

prox prox prox prox ?
Implementação por Apontadores COMPUTER
SCIENCE

// insere x no final da lista

void InsereN(TItem x, TLista *Lista) {
Lista->Ultimo->Prox = malloc(sizeof(TCelula));
Lista->Ultimo = Lista->Ultimo->Prox;
Lista->Ultimo->Item = x;
Lista->Ultimo->Prox = NULL;
}

Primeiro Último

info info info

prox prox prox prox ?
Implementação por Apontadores COMPUTER
SCIENCE

// insere x no final da lista

void InsereN(TItem x, TLista *Lista) {
Lista->Ultimo->Prox = malloc(sizeof(TCelula));
Lista->Ultimo = Lista->Ultimo->Prox;
Lista->Ultimo->Item = x;
Lista->Ultimo->Prox = NULL;
}

Primeiro Último

info info info x

prox prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

// insere x após a posição p

void InsereP(TItem x, TLista *Lista, Apontador p) {
Apontador novo = malloc(sizeof(TCelula));
novo->Item = x;
novo->Prox = p->Prox;
if (novo->Prox == NULL)
Lista->Ultimo = novo;
p->Prox = novo;
}
Primeiro p Último

info info info

prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

// insere x após a posição p

void InsereP(TItem x, TLista *Lista, Apontador p) {
Apontador novo = malloc(sizeof(TCelula));
novo->Item = x;
novo->Prox = p->Prox;
if (novo->Prox == NULL)
Lista->Ultimo = novo;
p->Prox = novo;
}
Primeiro p Último

info info info

prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

// insere x após a posição p

void InsereP(TItem x, TLista *Lista, Apontador p) {
Apontador novo = malloc(sizeof(TCelula));
novo->Item = x;
novo->Prox = p->Prox;
if (novo->Prox == NULL)
Lista->Ultimo = novo;
p->Prox = novo;
}
Primeiro p Último

x
prox

info info info

prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

// insere x após a posição p

void InsereP(TItem x, TLista *Lista, Apontador p) {
Apontador novo = malloc(sizeof(TCelula));
novo->Item = x;
novo->Prox = p->Prox;
if (novo->Prox == NULL)
Lista->Ultimo = novo;
p->Prox = novo;
}
Primeiro p Último

x
prox

info info info

prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

// retira o item seguinte ao apontado por p

void RetiraP(Apontador p, TLista *L, TItem *Item) {
if (Vazia(*L) || p == NULL || p->Prox == NULL) {
printf("Lista vazia ou posição inválida\n");
return;
}
Apontador q = p->Prox;
*Item = q->Item;
p->Prox = q->Prox;
if (p->Prox == NULL)
L->Ultimo = p;
free(q);
}
Implementação por Apontadores COMPUTER
SCIENCE

// retira o item seguinte ao apontado por p

void RetiraP(Apontador p, TLista *L, TItem *Item) {
... Apontador q = p->Prox;
*Item = q->Item;
p->Prox = q->Prox;
if (p->Prox == NULL) Item
L->Ultimo = p;
free(q);
}
Primeiro p Último
?

info x info info

prox prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

// retira o item seguinte ao apontado por p

void RetiraP(Apontador p, TLista *L, TItem *Item) {
... Apontador q = p->Prox;
*Item = q->Item;
p->Prox = q->Prox;
if (p->Prox == NULL) Item
L->Ultimo = p;
free(q);
}
Primeiro p q Último
?

info x info info

prox prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

// retira o item seguinte ao apontado por p

void RetiraP(Apontador p, TLista *L, TItem *Item) {
... Apontador q = p->Prox;
*Item = q->Item;
p->Prox = q->Prox;
if (p->Prox == NULL) Item
L->Ultimo = p;
free(q);
}
Primeiro p q Último
x

info x info info

prox prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

// retira o item seguinte ao apontado por p

void RetiraP(Apontador p, TLista *L, TItem *Item) {
... Apontador q = p->Prox;
*Item = q->Item;
p->Prox = q->Prox;
if (p->Prox == NULL) Item
L->Ultimo = p;
free(q);
}
Primeiro p q Último
x

info x info info

prox prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

// retira o item seguinte ao apontado por p

void RetiraP(Apontador p, TLista *L, TItem *Item) {
... Apontador q = p->Prox;
*Item = q->Item;
p->Prox = q->Prox;
if (p->Prox == NULL) Item
L->Ultimo = p;
free(q);
}
Primeiro p Último
x

info info info

prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

void Imprime(TLista Lista) {

Apontador p;
p = Lista.Primeiro->Prox;
while (p != NULL) {
printf("%d\n", p->Item.Chave);
p = p->Prox;
}
}
Primeiro p Último

info info info info

prox prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

void Imprime(TLista Lista) {

Apontador p;
p = Lista.Primeiro->Prox;
while (p != NULL) {
printf("%d\n", p->Item.Chave);
p = p->Prox;
}
}
Primeiro p Último

info info info info

prox prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

void Imprime(TLista Lista) {

Apontador p;
p = Lista.Primeiro->Prox;
while (p != NULL) {
printf("%d\n", p->Item.Chave);
p = p->Prox;
}
}
Primeiro p Último

info info info info

prox prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

void Imprime(TLista Lista) {

Apontador p;
p = Lista.Primeiro->Prox;
while (p != NULL) {
printf("%d\n", p->Item.Chave);
p = p->Prox;
}
}
Primeiro p Último

info info info info

prox prox prox prox NULL
Implementação por Apontadores COMPUTER
SCIENCE

void Imprime(TLista Lista) {

Apontador p;
p = Lista.Primeiro->Prox;
while (p != NULL) {
printf("%d\n", p->Item.Chave);
p = p->Prox;
}
}
Primeiro p Último
NULL

info info info info

prox prox prox prox NULL
Implementação por Apontadores
COMPUTER
Vantagens e Desvantagens SCIENCE

• Vantagens
– Inserção e remoção têm custo constante
• Importante quando a ordem precisa ser mantida
– Tamanho máximo não precisa ser definido a priori
• Importante quando não há previsão sobre crescimento
• Desvantagens
– Memória extra para armazenar os apontadores
– Baixa localidade de acesso (memória não-contígua)
– O(n) para acessar um item no pior caso