Listas Encadeadas

Listas Seqenciais

Conjunto de itens organizados vetor

a organizao implcita (pela posio)

A L I S T

vet

o smbolo vet representa o endereo do primeiro elemento (ponteiro) ocupa um espao contguo na memria:
permite

acesso a qualquer elemento a partir do ponteiro para o primeiro, utilizando indexao acesso aleatrio

Listas Seqenciais
Qual a principal desvantagem de se usar o armazenamento seqencial para representar Listas? Quantidade fixa de elementos

3

memria alocada sem uso ou impossibilidade de alocar mais memria

Listas Lineares

Soluo?

Utilizar Estruturas de Dados que cresam e diminuam na medida da necessidade Estruturas Dinmicas Alocao dinmica de memria para armazenar os elementos

Listas Encadeadas

Listas Encadeadas

Podem crescer e diminuir dinamicamente

Tamanho mximo no precisa ser definido previamente

Provem flexibilidade, permitindo que os itens sejam rearrumados eficientemente

Tambm chamadas de Listas Ligadas

Listas Encadeadas

A seqncia de elementos especificada explicitamente, onde cada um contm um ponteiro para o prximo da lista (link) Encadeamento Cada elemento chamado de n da lista A lista representada por um ponteiro para o primeiro elemento (ou n) Do primeiro elemento, pode-se alcanar o segundo seguindo o encadeamento e assim sucessivamente Para cada novo elemento inserido na estrutura, um espao na memria alocado dinamicamente, mas a alocao do espao no contgua
lista

Listas Encadeadas

Detalhes que devem ser considerados:

cada elemento possui pelo menos dois campos: um para armazenar a informao e outro para o endereo do prximo (ponteiro) deve haver um ponteiro especial para o 1O da lista o ponteiro do ltimo elemento tem que especificar algum tipo de final (aponta para si prprio ou nulo) uma lista vazia (ou nula) uma lista sem ns
info prox

lista

A
7
n

Listas Encadeadas

Algumas operaes so mais eficientes do que em Lista Seqencial

Mover o elemento com a informao T do fim da lista para o incio Mesmo que a lista seja muito longa, a mudana estrutural realizada atravs de 3 operaes

lista

A
8

Listas Encadeadas

Para insero de um novo elemento X:

aloca-se memria para um elemento e atualiza-se os ponteiros em lista seqencial seria necessrio deslocar todos os elementos a partir do ponto de insero; apenas 2 links so alterados para esta operao no importa quo longa a lista

X
lista

A
9

Listas Encadeadas

Remoo de um elemento:

Basta alterar o ponteiro do elemento anterior ao removido

lista

o contedo de I (no exemplo) ainda existe, mas no mais acessvel pela lista

10

Listas Encadeadas

Lista Encadeada x Seqencial

remoo e insero so mais naturais na lista encadeada

outras operaes j no so to naturais
Encontrar

o k-simo elemento da lista

em uma lista seqencial - simplesmente acessar a[k-1] na lista encadeada necessrio percorrer k links

Achar

um item localizado antes de um outro item

11

Listas Encadeadas
Simplesmente encadeada - ponteiros em uma direo

Duplamente encadeada - ponteiros para duas direes

um ponteiro para o prximo e um para o anterior

12

Listas Encadeadas
Implementaes:
typedef struct tp_no { int info; struct tp_no *prox; } tplista; tplista *lista;
13

Listas Encadeadas
Inicializao

da Lista:

lista=NULL;
Lista

Vazia:

int vazia (tplista *t) { return (t==NULL); }

14

Listas Encadeadas
Alocao

Dinmica de Memria

malloc aloca( ); free exigem #include "stdlib.h"

15

Manipulao da Memria
aloca()
tplista* aloca( ) { tplista* pt; pt=(tplista*) malloc(sizeof(tplista)); return pt; }

No bloco principal:

16

p=aloca( ); if (p!=NULL) /* continua o programa... */ else printf(No h memria disponvel!);

Manipulao da Memria

Funo free

Libera o espao de memria alocado dinamicamente recebe como parmetro o ponteiro da rea de memria a ser liberada Ex.: free(p);

17

Listas Encadeadas
Operaes

Bsicas

vazia(lista); insere(lista, valor); busca(lista, valor); listagem(lista); retira(lista, &valor);

18

Lista Vazia
int vazia (tplista *t) { if (t==NULL) return 1; else return 0; }
19

Listagem

Utilizar um ponteiro auxiliar para percorrer a lista at o final

p
p p p p

20

Listagem
void listagem (tplista *t) { tplista *p; for (p=t; p=NULL; p=p->prox) printf("Info: %d\n", p->info); }

21

Busca
Utilizar um ponteiro auxiliar para percorrer a lista at encontrar ou at chegar ao final A funo retorna o ponteiro para o elemento ou NULL caso no encontre

22

Busca
tplista* busca (tplista *t , int valor) { tplista *p=t; while ((p!=NULL) && (p->info!=valor))

p=p->prox;
return p; }
23

Insero no Incio

24

Cada elemento armazena uma informao do tipo tp_item A funo: recebe como parmetros um ponteiro para a lista e o novo elemento tenta alocar dinamicamente o espao para o novo n, guardando a informao e fazendo ele apontar para o incio da lista retorna o novo ponteiro da lista ou NULL caso no seja possvel incluir

Insero no Incio
Estrutura usada:

typedef int tp_item;

typedef struct tp_no { tp_item info; struct tp_no *prox; } tplista; tplista * lista;
25

prim

Insero no Incio
tplista * insere (tplista *t , int valor) { tplista *novo; Insere em qualquer lista, novo = aloca( ); retornando um ponteiro if (!novo) para o primeiro. Quem chama a funo deve return(NULL); atualizar o ponteiro da lista else { com o valor retornado: novo->info = valor; lista= insere(lista,12); novo->prox = t; return(novo); } }

26

Insero no Incio (Por referncia)

int insere (tplista **t , int valor) { tplista *novo; Insere em qualquer lista, novo = aloca( ); retornando 1 ou zero para if (!novo) indicar sucesso ou falta de return 0; memria. A funo j atualiza automaticamente o else { ponteiro de incio da lista. novo->info = valor; ok= insere(12,lista); novo->prox = *t; if (!ok) *t=novo; printf(Sem memria); return 1; } }

27

Insero Geral

Insere elementos em uma lista classificada, mantendo a ordenao Ponto chave: localizar o elemento da lista que precede o novo De posse do ponteiro para este antecessor, pode-se encadear o novo elemento: o novo apontar para o prximo do antecessor o antecessor apontar para o novo

28

Insero Geral
Estrutura usada:

typedef int tp_item;

typedef struct tp_no { tp_item info; struct tp_no *prox; } tplista; tplista * lista;
29

G B E M R

tplista* insere (tplista *t , tp_item e) {

/* novo n */

tplista *novo;
/* ponteiro p/ anterior */

/* procura posio do elemento */

tplista *ant=NULL;
/* ponteiro p/ percorrer */

while (p!=NULL && p->info<e) { ant=p; p=p->prox; } if (ant==NULL) {

tplista *p=t; novo = aloca(); if (!novo) return(NULL); novo->info = e; }

/* insere elemento no incio */

novo->prox=t; t=novo; } else {

/* insere elemento no meio */

novo->prox=ant->prox; ant->prox=novo; } return t;

int insere (tplista **t , tp_item e) {

/* Por Referncia */
tplista *novo; tplista *ant=NULL; tplista *p=*t; novo = aloca(); if (!novo) return 0; novo->info = e; while (p && p->info<e) { ant=p; p=p->prox; }

novo->prox=p; if (ant==NULL) *t=novo; else ant->prox=novo; return 1;

}

Remoo

Procurar o elemento a ser removido e guardar uma referncia para o anterior Se encontrar:

se for o primeiro: lista passa a apontar para o segundo e espao do primeiro liberado se estiver no meio ou fim: seu antecessor passa a apontar para seu prximo e o espao liberado

32

tp_lista* retira (tp_lista *t, tpitem e) {

/* ponteiro p/ anterior */

tp_lista *ant=NULL;
/* ponteiro p/ percorrer */

tp_lista *p=t; /* procura elemento na lista, guardando o anterior */ while (p!=NULL && p->info!=e) { ant=p; p=p->prox; }

if (p==NULL) { /* No Achou; retorna NULL */ printf("No existe\n"); return NULL; } /* Achou */ if (ant==NULL) { /* retira elemento do incio */ t=p->prox; } else { /* retira elemento do meio */ ant->prox=p->prox; } free(p); return t; }

int retira (tplista **t, tpitem e) {

/* Por Referncia */
tplista *ant=NULL, *p=*t; while (p!=NULL && p->info!=*e) { ant=p; p=p->prox; } if (p==NULL) return 0; else { if (ant==NULL) *t=p->prox; else ant->prox=p->prox; free(p); return 1; }

Liberar Lista

Liberar todos os elementos alocados

Percorrer todos os elementos, liberando cada um

preciso guardar a referncia para o prximo antes de liberar o atual

35

Liberar Lista
void destroi (tplista *t) { tplista *p=t, *q; while (p!=NULL) { q=p->prox; /* guarda referncia p/ o prximo */ free(p); /* libera a memria apontada por p */ p=q; /* faz p apontar para o prximo */ } }
36