ndice

Introduo ............................................................................................................................................... 2 Listas Ligadas ......................................................................................................................................... 3 Estrutura das Listas Ligadas ................................................................................................................... 3 Operaes de Listas Ligadas ................................................................................................................... 4 Funo de inicializao ....................................................................................................................... 4 Funo de insero.............................................................................................................................. 4 Funo que percorre os elementos da lista.......................................................................................... 5 Funo que verifica se lista est vazia ................................................................................................ 5 Funo de busca .................................................................................................................................. 5 Funo que retira um elemento da lista .............................................................................................. 6 Funo para liberar a lista ................................................................................................................... 7 Vantagens................................................................................................................................................ 7 Desvantagens .......................................................................................................................................... 7 Tipos de Listas Ligadas .......................................................................................................................... 8 Listas Ligadas Simples ....................................................................................................................... 8 Propriedadas das Listas Ligadas Simples ........................................................................................... 8 Listas duplamente ligadas ................................................................................................................... 8 Vantagens............................................................................................................................................ 9 Desvantagens ...................................................................................................................................... 9 Listas circulares .................................................................................................................................. 9 Lista circular duplamente encadeada ................................................................................................ 10 Vantagens.......................................................................................................................................... 10 Desvantagens .................................................................................................................................... 10 Projecto ................................................................................................................................................. 11 Concluso.............................................................................................................................................. 12 Referncias Bibliogrficas .................................................................................................................... 13

Introduo
Frequentemente precisamos agrupar vrios elementos/dados num conjunto. A partida podemos no saber o nmero exacto de elementos a ser agrupados. Em cada instante podemos acrescentar ou remover elemento ao conjunto. Em programao consideramos dois tipos de estruturas que permitem guardar uma coleco de elementos: estrutura esttica e estrutura dinmica. Os elementos podem ser organizados de um modo distinto. Uma matriz uma estrutura que fornecido em linguagens de programao. No entanto, tem pelo menos duas limitaes: (1) rearranjar o tamanho da matriz necessria para criar uma matriz com o tamanho pr-arranjo com o novo tamanho, e (2) nos dados de matriz so prximas umas das outras sequencialmente na memria, o que significa que para inserir um item para a matriz deve ser movido por outro arranjo. Esta limitao pode ser ultrapassada pela utilizao de estruturas ligadas. A estrutura relacionada uma coleo de ns que armazena os dados e links para outros ns. Assim, os ns podem ser localizado em qualquer lugar da memria e da passagem a partir de um n para o outro dentro da estrutura ligada conseguido atravs do armazenamento das referncias ou para outro n ou ns na estrutura. Uma lista encadeada a forma mais simples de representar uma coleco de elementos que juntos formam uma ordenao linear. Cada elemento da coleco representado pelo objecto da classe No . Mesmo quando as estruturas ligadas pode ser implementado numa variedade de formas, mais flexvel a utilizao de um objeto separado para cada n. Listas de dados so conjuntos de elementos de dados "alienado em uma linha", as inseres e excluses so feitas em qualquer parte de uma lista encadeada. As pilhas so importantes para compiladores e sistemas operativos, as inseres e delees so feitas apenas com uma extremidade da pilha isto , na parte superior. As filas de espera representam linhas, as inseres so feitas no final (tambm conhecido como o calcanhar) de uma fila, e delees so feitas a partir do topo (tambm conhecido como a cabea) de uma fila. As rvores fornecem busca e arquivos de dados ordinamiento sytem e expresses compilao em linguagem de mquina. Cada uma destas estruturas de dados tem muitas outras aplicaes interessantes. O presente trabalho tem como objectivo fazer uma abordagem as listas ligadas, para melhor compreenso e com isso sermos capazes de desenvolver uma aplicao cujo seja capaz de registar vrios servios num Registo Cvil como registos de nascimentos, casamentos entre outros.

Listas Ligadas
Uma lista ligada uma estrutura linear e dinmica, que corresponde a uma sequncia lgica de entradas ou ns. Tipicamente, em uma lista ligada h um ou dois pontos conhecidos de acesso, normalmente o topo da lista (seu primeiro elemento) e eventualmente o fim da lista (seu ltimo elemento). Cada n armazena tambm a localizao do prximo elemento na seqncia, ou seja, de seu n sucessor. Desse modo, o armazenamento de uma lista no requer uma rea contgua de memria.

Fig. 1 Representa graficamente uma estrutura de lista ligada.

Estrutura das Listas Ligadas

A estrutura consiste numa seqncia encadeada de elementos, em geral chamados de ns da lista. A lista representada por um ponteiro para o primeiro elemento (ou n). Do primeiro elemento, podemos alcanar o segundo seguindo o encadeamento, e assim por diante. O ltimo elemento da lista aponta para NULL, sinalizando que no existe um prximo elemento. Para exemplificar a implementao de listas encadeadas em C, vamos considerar um exemplo simples em que queremos armazenar valores inteiros numa lista encadeada. O n da lista pode ser representado pela estrutura abaixo:
struct lista { int info; struct lista* prox; }; typedef struct lista Lista;

Podemos notar que trata-se de uma estrutura auto-referenciada, pois, alm do campo que armazena a informao (no caso, um nmero inteiro), h um campo que um ponteiro para uma prxima estrutura do mesmo tipo. Embora no seja essencial, uma boa estratgia definirmos o tipo Lista como sinnimo de struct lista, conforme mostrado acima. O tipo Lista representa um n da lista e a estrutura de lista encadeada representada pelo ponteiro para seu primeiro elemento (tipo Lista*). Considerando a definio de Lista, podemos definir as principais funes necessrias para implementarmos uma lista encadeada. As listas ligadas apresentam operaes como: inicializa uma lista vazia, cria um novo n, inserir um n na lista, procurar um n na lista, imprimir a lista, remover um n na lista, liberar a lista (Remover todos os elementos) .

Operaes de Listas Ligadas

Funo de inicializao
A funo que inicializa uma lista deve criar uma lista vazia, sem nenhum elemento. Como a lista representada pelo ponteiro para o primeiro elemento, uma lista vazia representada pelo ponteiro NULL, pois no existem elementos na lista. A funo tem como valor de retorno a lista vazia inicializada, isto , o valor de retorno NULL. Uma possvel implementao da funo de inicializao mostrada a seguir:
/* funo de inicializao: retorna uma lista vazia */ Lista* inicializa (void) { return NULL; }

Funo de insero
Uma vez criada a lista vazia, podemos inserir novos elementos nela. Para cada elemento inserido na lista, devemos alocar dinamicamente a memria necessria para armazenar o elemento e encade-lo na lista existente. A funo de insero mais simples insere o novo elemento no incio da lista. Uma possvel implementao dessa funo mostrada a seguir. Devemos notar que o ponteiro que representa a lista deve ter seu valor atualizado, pois a lista deve passar a ser representada pelo ponteiro para o novo primeiro elemento. Por esta razo, a funo de insero recebe como parmetros de entrada a lista onde ser inserido o novo elemento e a informao do novo elemento, e tem como valor de retorno a nova lista, representada pelo ponteiro para o novo elemento.
/* insero no incio: retorna a lista atualizada */ Lista* insere (Lista* l, int i) { Lista* novo = (Lista*) malloc(sizeof(Lista)); novo->info = i; novo->prox = l; return novo; }

Esta funo aloca dinamicamente o espao para armazenar o novo n da lista, guarda a informao no novo n e faz este n apontar para (isto , ter como prximo elemento) o elemento que era o primeiro da lista. A funo ento retorna o representa a lista, que o ponteiro para o novo primeiro elemento. A Figura 2 ilustra a operao de insero de um novo elemento no incio da lista.

Fig2. Insero de um novo elemento no incio da lista.

O trecho de cdigo que cria uma lista inicialmente vazia e insere nela novos elementos.
int main (void) { Lista* l; /* declara uma lista no inicializada */ l = inicializa(); /* inicializa lista como vazia */ l = insere(l, 23); /* insere na lista o elemento 23 */ l = insere(l, 45); /* insere na lista o elemento 45 */ ... return 0; }

No podemos deixar de actualizar a varivel que representa a lista a cada insero de um novo elemento.

Funo que percorre os elementos da lista

Para ilustrar a implementao de uma funo que percorre todos os elementos da lista, vamos considerar a criao de uma funo que imprima os valores dos elementos armazenados numa lista. Uma possvel implementao dessa funo mostrada a seguir.
/* funo imprime: imprime valores dos elementos */ void imprime (Lista* l) { Lista* p; /* varivel auxiliar para percorrer a lista */ for (p = l; p != NULL; p = p->prox) printf(info = %d\n, p->info); }

Funo que verifica se lista est vazia

Pode ser til implementarmos uma funo que verifique se uma lista est vazia ou no. A funo recebe a lista e retorna 1 se estiver vazia ou 0 se no estiver vazia. Como sabemos, uma lista est vazia se seu valor NULL. Uma implementao dessa funo mostrada a seguir:
/* funo vazia: retorna 1 se vazia ou 0 se no vazia */ int vazia (Lista* l) { if (l == NULL) return 1; else return 0; }

Essa funo pode ser re-escrita de forma mais compacta, conforme mostrado abaixo:
/* funo vazia: retorna 1 se vazia ou 0 se no vazia */ int vazia (Lista* l) { return (l == NULL); }

Funo de busca
Outra funo til consiste em verificar se um determinado elemento est presente na lista. A funo recebe a informao referente ao elemento que queremos buscar e fornece como valor

de retorno o ponteiro do n da lista que representa o elemento. Caso o elemento no seja encontrado na lista, o valor retornado NULL.
/* funo busca: busca um elemento na lista */ Lista* busca (Lista* l, int v) { Lista* p; for (p=l; p!=NULL; p=p->prox) if (p->info == v) return p; return NULL; /* no achou o elemento */ }

Funo que retira um elemento da lista

Para completar o conjunto de funes que manipulam uma lista, devemos implementar uma funo que nos permita retirar um elemento. A funo tem como parmetros de entrada a lista e o valor do elemento que desejamos retirar, e deve retornar o valor atualizado da lista, pois, se o elemento removido for o primeiro da lista, o valor da lista deve ser actualizado. A funo para retirar um elemento da lista mais complexa. Se descobrirmos que o elemento a ser retirado o primeiro da lista, devemos fazer com que o novo valor da lista passe a ser o ponteiro para o segundo elemento, e ento podemos liberar o espao alocado para o elemento que queremos retirar. Se o elemento a ser removido estiver no meio da lista, devemos fazer com que o elemento anterior a ele passe a apontar para o elemento seguinte, e ento podemos liberar o elemento que queremos retirar. Devemos notar que, no segundo caso, precisamos do ponteiro para o elemento anterior para podermos acertar o encadeamento da lista. As Figuras 3 e 4 ilustram as operaes de remoo.

Fig. 3 Remoo do primeiro elemento da lista.

Fig. 4Remoo de um elemento no meio da lista.

Uma possvel implementao da funo para retirar um elemento da lista mostrada a seguir. Inicialmente, busca-se o elemento que se deseja retirar, guardando uma referncia para o elemento anterior.
/* funo retira: retira elemento da lista */ Lista* retira (Lista* l, int v) { Lista* ant = NULL; /* ponteiro para elemento anterior */ Lista* p = l; /* ponteiro para percorrer a lista*/ /* procura elemento na lista, guardando anterior */ while (p != NULL && p->info != v) { ant = p; p = p->prox; } /* verifica se achou elemento */ if (p == NULL) return l; /* no achou: retorna lista original */ /* retira elemento */ if (ant == NULL) {

/* retira elemento do inicio */ l = p->prox; } else { /* retira elemento do meio da lista */ ant->prox = p->prox; } free(p); return l; }

O caso de retirar o ltimo elemento da lista recai no caso de retirar um elemento no meio da lista, conforme pode ser observado na implementao acima. Mais adiante, estudaremos a implementao de filas com listas encadeadas. Numa fila, devemos armazenar, alm do ponteiro para o primeiro elemento, um ponteiro para o ltimo elemento. Nesse caso, se for removido o ltimo elemento, veremos que ser necessrio actualizar a fila.

Funo para liberar a lista

Uma outra funo til que devemos considerar destri a lista, liberando todos os elementos alocados. Uma implementao dessa funo mostrada abaixo. A funo percorre elemento a elemento, liberando-os. importante observar que devemos guardar a referncia para o prximo elemento antes de liberar o elemento corrente (se liberssemos o elemento e depois tentssemos acessar o encadeamento, estaramos acessando um espao de memria que no estaria mais reservado para nosso uso).
void libera (Lista* l) { Lista* p = l; while (p != NULL) { Lista* t = p->prox; /* guarda referncia para o prximo elemento */ free(p); /* libera a memria apontada por p */ p = t; /* faz p apontar para o prximo */ } }

Vantagens

A insero ou remoo de um elemento na lista no implica a mudana de lugar de outros elementos; No necessrio definir, no momento da criao da lista, o nmero mximo de elementos que esta poder ter. Ou seja, possvel alocar memria "dinamicamente", apenas para o nmero de ns necessrios. uma estrutura de dados dinmica, muito flexvel, que permite a fcil insero e remoo dos seus elementos. Facilita o gerenciamento de vrias listas (fuso, diviso,...) .

Desvantagens

A manipulao torna-se mais "perigosa" uma vez que, se o encadeamento (ligao) entre elementos da lista for mal feito, toda a lista pode ser perdida; Para aceder ao elemento na posio n da lista, deve-se percorrer os n - 1 anteriores. Acesso indirecto aos elementos . Tempo varivel para acessar os elementos (depende da posio do elemento) . Gasto de memria maior pela necessidade de um novo campo para o ponteiro .

Tipos de Listas Ligadas

Listas Ligadas Simples
Uma lista encadeada simples aquela que contm apenas um link por n. Este link aponta para o prximo n da lista, ou para um valor nulo (vazio) quando se trata do n final. Se um n contm dados de campo refere-se a um outro n, em seguida, vrios ns podem ser fiadas utilizando apenas uma varivel para aceder a sequncia completa de ns. Uma sequncia de ns como este a implementao mais comum de uma lista encadeada, que uma estrutura de dados constitudo por ns onde cada n contm determinadas informaes e de referncia para outro n na lista. Se um n tem apenas um link para o seu sucessor dentro desta seqncia, a lista chamada de uma simples lista ligada. Um exemplo desta lista mostrado na Figura 5. Note que apenas uma varivel p usada para acessar qualquer n na lista. O ltimo n na lista pode ser reconhecida como um ca mpo de referncia nula.
Figura 1. Exemplo Lista Ligada Simples

Propriedadas das Listas Ligadas Simples

Uma lista vazia aponta sempre para NULL O ltimo N da lista sempre aponta para NULL Qualquer N da lista sempre aponta para o N seguinte, permitindo um passeio do primeiro ao ltimo. Todo N criado deve sempre apontar para NULL, at que sua posio na lista seja definida.

Listas duplamente ligadas

A estrutura de lista encadeada vista nas sees anteriores caracteriza-se por formar um encadeamento simples entre os elementos: cada elemento armazena um ponteiro para o prximo elemento da lista. Desta forma, no temos como percorrer eficientemente os elementos em ordem inversa, isto , do final para o incio da lista. O encadeamento simples tambm dificulta a retirada de um elemento da lista. Mesmo se tivermos o ponteiro do elemento que desejamos retirar, temos que percorrer a lista, elemento por elemento, para encontrarmos o elemento anterior, pois, dado um determinado elemento, no temos como acessar diretamente seu elemento anterior. Para solucionar esses problemas, podemos formar o que chamamos de listas duplamente encadeadas. Nelas, cada elemento tem um ponteiro para o prximo elemento e um ponteiro para o elemento anterior.

Desta forma, dado um elemento, podemos acessar ambos os elementos adjacentes: o prximo e o anterior. Se tivermos um ponteiro para o ltimo elemento da lista, podemos percorrer a lista em ordem inversa, bastando acessar continuamente o elemento anterior, at alcanar o primeiro elemento da lista, que no tem elemento anterior (o ponteiro do elemento anterior vale NULL).

Fig. 6 Arranjo da memria de uma lista duplamente encadeada

Para exemplificar a implementao de listas duplamente encadeadas, vamos novamente considerar o exemplo simples no qual queremos armazenar valores inteiros na lista. O n da lista pode ser representado pela estrutura abaixo e a lista pode ser representada atravs do ponteiro para o primeiro n.
struct lista2 { int info; struct lista2* ant; struct lista2* prox; }; typedef struct Lista2 Lista2;

Vantagens
Maior facilidade de controle da lista, maior confiabilidade e menor risco de perda acidental da lista.

Desvantagens
Maior gasto de espao em disco (2 ns a mais).

Listas circulares
Algumas aplicaes necessitam representar conjuntos cclicos. Por exemplo, as arestas que delimitam uma face podem ser agrupadas por uma estrutura circular. Para esses casos, podemos usar listas circulares. Numa lista circular, o ltimo elemento tem como prximo o primeiro elemento da lista, formando um ciclo. A rigor, neste caso, no faz sentido falarmos em primeiro ou ltimo elemento. A lista pode ser representada por um ponteiro para um elemento inicial qualquer da lista. A Figura 7 ilustra o arranjo da memria para a representao de uma lista circular.
Fig. 7 Arranjo da memria de uma lista circular.

Para percorrer os elementos de uma lista circular, visitamos todos os elementos a partir do ponteiro do elemento inicial at alcanarmos novamente esse mesmo elemento. O cdigo abaixo exemplifica essa forma de percorrer os elementos. Neste caso, para simplificar, consideramos uma lista que armazena valores inteiros.

Devemos salientar que o caso em que a lista vazia ainda deve ser tratado (se a lista vazia, o ponteiro para um elemento inicial vale NULL).
void imprime_circular (Lista* l) { Lista* p = l; /* faz p apontar para o n inicial */ /* testa se lista no vazia */ if (p) { { /* percorre os elementos at alcanar novamente o incio */ do { printf("%d\n", p->info); /* imprime informao do n */ p = p->prox; /* avana para o prximo n */ } while (p != l);

Lista circular duplamente encadeada

Uma lista circular tambm pode ser construda com encadeamento duplo. Neste caso, o que seria o ltimo elemento da lista passa ter como prximo o primeiro elemento, que, por sua vez, passa a ter o ltimo como anterior. Com essa construo podemos percorrer a lista nos dois sentidos, a partir de um ponteiro para um elemento qualquer. Abaixo, ilustramos o cdigo para imprimir a lista no sentido reverso, isto , percorrendo o encadeamento dos elementos anteriores.
void imprime_circular_rev (Lista2* l) { Lista2* p = l; /* faz p apontar para o n inicial */ /* testa se lista no vazia */ if (p) { { /* percorre os elementos at alcanar novamente o incio */ do { printf("%d\n", p->info); /* imprime informao do n */ p = p->ant; /* "avana" para o n anterior */ } while (p != l); }

Vantagens
Economia de espao em disco (1 n a menos que a lista duplamente encadeada com sentinelas), maior confiabilidade em relao ao modelo comum.

Desvantagens
Maior complexidade nos algoritmos.

Projecto
Cartrio um nome genrico que designa uma repartio pblica ou privada que tem a custdia de documentos (cartas) e que lhes d f pblica. Registo civil o termo jurdico que designa o assentamento dos factos da vida de um indivduo, tais como o seu nascimento, casamento, divrcio ou morte (bito). Tambm so passveis de registro civil as interdies, as tutelas, as adopes, os pactos pr-nupciais, o exerccio do poder familiar (chamado de ptrio poder no antigo cdigo civil de 1916 do Brasil; em Portugal: poder paternal), a opo de nacionalidade, entre outros fatos que afectam diretamente a relao jurdica entre diferentes cidados.

Concluso
Uma Lista Ligada representa um conjunto de elementos denominados ns onde as informaes so armazenadas. Cada n deve obrigatoriamente possuir um apontador para o prximo elemento da lista, caracterizando assim uma ligao entre ns. Portanto, um n um registo que contm a informao a ser armazenada e o apontador ara o prximo n. A utilizao de listas ligadas resolve vrios problemas tpico que, se usando vectores seria muito trabalhoso. Alguns problemas exigem que certas prioridades dos elementos do vectores sejam garantidas como, por exemplo, a ordem em que o elementos so inseridos define a ordem que sero removidos. As listas ligadas conseguem ser mais vantajosas em relao aos vectores pois usando as listas ligadas, no h necessidade de redimensionar pois considera cada elemento individualmente, pois num vector o redimensionamento obrigatio. Nas Listas ligadas no preciso deslocar valores para garantir alguma ordem dos elementos, mas uma das desvantagens das listas ligadas que com estas no possvel fazer acesso imediato ou seja necessrio percorrer alguns elementos. Podemos utilizar a estrutura dinmica simplesmente encadeada ou duplamente encadeada para implementao da lista circular. Para implementao deste tipo de lista devemos especificar classe NoD composto por elemento, referncia para o elemento seguinte e referncia para o elemento anterior. Listas circulares so listas onde o primeiro e ltimo elemento esto ligados. Uma lista encadeada a forma mais simples de representar uma coleco de elementos que juntos formam uma ordenao linear. Cada elemento da coleco representado pelo objecto da classe No . A ordenao determinada armazenando num n uma referncia para um elemento e uma referncia, chamada de prximo, para o prximo n da coleco. As listas duplamente ligadas consiste quando cada No da lista duplamente encadeada possui uma ligao no s para o prximo elemento, mas tambm para o elemento anterior da lista. Esta variante da lista simplesmente encadeada permite a insero e a remoo na cabea e na cauda da lista com o tempo de execuo O(1). Listas circulares so listas onde o primeiro e ltimo elemento esto ligados. Podemos utilizar a estrutura dinmica simplesmente encadeada ou duplamente encadeada para implementao da lista circular.

Referncias Bibliogrficas
Adam Drozdek, Estructura de datos y algoritmos en Java, Thomson, 2. Edicon. Grupo Papime Pe - 100205, Introduccon a las cincias de La computacin con Java, Universidad Nacional Autnoma de Mxico, 1 Edicin, 2007 Detel, Harvey M. Y Deitel, Paul J., Cmo programar en C/C++ y Java, Pearson Educacin, Mxico, 2004, Cuarta Edicin. Caelum Ensino e Solues em Java CS -14 Algoritmos Estruturas de Dados em Java http://www.cin.ufpe.br/~jndm/edados/referencias/Algoritmos%20e%20Estruturas%20 de%20Dados%20em%20Java.pdf (acessado a 15/03/2012) Algoritmos e Tipos Abstractos de Informao, 2003 http://ltodi.est.ips.pt/atai/index_files/TADs%20em%20Java%20e%20Estruturas.pdf (acessado a 15/03/2012) MC 102 Aoritmos e Programao de Computadores - Listas Ligadas, 2007 http://www.lis.ic.unicamp.br/~mc102/files/mc102jk-a28-4pp.pdf (acessado a 21/03/2012) Estruturas de Dados Dinmicas e Genricos em Java Adaptado dos slides do livro: Java, an Introduction to Problem Solving and Programming, 4d Walter Savitch http://pwp.net.ipl.pt/cc.isel/cvaz/Textos/POO/EDDG.pdf (acessado a 21/03/2012) W. Celes e J. L. Rangel, Listas Encadeadas http://www.ic.unicamp.br/~ra069320/PED/MC102/1s2008/Apostilas/Cap10.pdf (acessado a 25/03/2012) Nelson Freire , Linguagem JAVA Contentores de Objetos http://www.dei.isep.ipp.pt/~nfreire/JAVA%20-%20Contentores.pdf (acessado a 25/03/2012) Prof. Daniel Lucrdio , Desenvolvimento de Software Orientado a Objetos http://www2.dc.ufscar.br/~daniel/files/dsoo/08.poo.parte2.pdf (acessado a 27/03/2012)