prof. hilton cardoso marins junior [email protected] lista linear

Prof. Hilton Cardoso Marins [email protected]

LISTA LINEAR

Estruturas de Dados

Estruturas de dados e algoritmos são temas fundamentais da Ciência da Compuatação, sendo utilizados nas mais diversas áreas do conhecimento e com os mais diferentes propósitos de aplicação.

Sabe-se que algoritmos manipulam dados. Quando estes dados estão organizados (dispostos) de forma coerente, caracterizam uma forma, uma estrutura de dados.

A organização e os métodos para manipular essa estrutura é que lhe conferem singularidade.

Definição de Lista Linear

Uma lista linear é uma estrutura que permite representar um conjunto de dados com os elementos dispostos em seqüência. Os nós (elementos) da lista podem conter, cada um deles, um dado primitivo ou um dado composto.

Veja a representação: x1, x2, ... ,xn , onde x1 é o primeiro nó da lista linear e xn é o último nó da lista linear.

Observações:

Para 1 < k < n, o nó xk é precedido pelo nó xk-1 e seguido do xk+1.

Quando o n = 0 dizemos que a lista está vazia.

Representação da Lista Linear por Contiguidade

Esta representação explora a sequencialidade da memória do computador, de tal forma que os nós são dispostos em posições contíguas. Esta estrutura é a mesma do vetor. Vejamos o esquema abaixo:

A representação de uma lista linear por contiguidade normalmente é utilizada para armazenar elementos sobre os quais não são necessárias inclusões em posições intermediárias, somente após o último.

Se tivéssemos que incluir ou remover um elemento, em uma posição intermediária, seria preciso deslocar os demais elementos (dali até o fim) uma posição para a direta ou esquerda dependendo do caso (inserção ou remoção).

X1 X2 X3 … XN-1 XN

Definindo uma Lista Linear por Contiguidade

Exemplo de definição de uma Lista Linear por Contiguidade de dado primitivo:

int listaInteiros[100];

Exemplo de definição de uma Lista Linear por Contiguidade de dado composto:

struct dados{char nome[30];char curso[20];char turma;double nota;

};struct dados listaAlunos[100];

Conclusão: Lista Linear por Contiguidade

Operações de ordenação, inserção e remoção de nós exigem um grande esforço computacional se realizadas em posições intermediárias. Este fato pode determinar o baixo desempenho do programa caso estas operações sejam frequentes.

É necessário fazer, a priori, uma estimativa do comprimento máximo que a lista pode tomar, para que o vetor que a contiver seja declarado com este tamanho. Esta limitação deve-se ao fato de que o vetor não pode ter o seu tamanho alterado dinamicamente para permitir a representação de uma lista de comprimento maior do que o inicialmente previsto

Lista Linear por Encadeamento

Uma forma de permitir o crescimento dinâmico do comprimento máximo de uma lista, bem como diminuir o esforço computacional das operações de ordenação, inserção e remoção de nós, é representar a Lista Linear por Encadeamento, onde os nós são ligados entre si para indicar a relação de ordem existente entre eles

X1 X2 Xn-1 Xn


Cada nó, além de conter o dado propriamente dito, deverá conter também a indicação do nó seguinte, caso haja algum.

A seqüencialidade é preservada de uma forma lógica, e não física como na Lista Linear por Contiguidade.

Cada elemento é associado a outro através de um ponteiro (elo de ligação) permitindo desta forma utilizar posições não contíguas da memória.

Dado PróximoDado Próximo Dado PróximoDado Próximo ... DadoDado PróximoNULL


A vantagem da lista linear encadeada está no fato de que se for necessário efetuar uma ordenação, inclusão ou exclusão de um elemento em uma posição intermediária, não há necessidade de deslocar os demais elementos (retirá-los de suas posições originais).

Evitando-se o deslocamento de dados, quando se trata de conjuntos com muitos elementos, consegue-se maior rapidez no processamento.


A representação da Lista Linear por Encadeamento em C pode ser definida da seguinte forma:

struct nome-do-tipo-estrutura{tipo campo-1;tipo campo-2;…tipo campo-n;

struct nome-do-tipo-estrutura *campo-ponteiro;}

Cada nó será composto por uma estrutura (struct) que possui duas partes: uma referente aos dados e outra para indicar qual é o próximo nó da lista.

Operações com Lista Linear por Encadeamento

Veremos as seguintes operações: Inserção, consulta, alteração e remoção

Para realizar operações com uma lista encadeada, precisamos saber onde ela começa, termina e qual o nó que estamos manipulando no momento. Para tanto utilizaremos os quatro ponteiros abaixo:

inicio: ponteiro que aponta para o primeiro nó da lista.

atual: ponteiro que aponta para o nó atual, ou seja, o nó que está sendo manipulado (consultado, alterado ou excluído) no mometo (o nó corrente).

ant ponteiro que aponta o nó anterior ao atual.

novo: ponteiro que aponta para um novo nó que será inserido na lista.


Para exemplificarmos operações com uma lista encadeada utilizaremos a definição abaixo:

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

typedef struct TipoLista Lista;

Trata-se de uma lista linear encadeada de números inteiros, todos os exemplos podem ser adaptados para qualquer outro tipo de dado básico (primitivo) ou estruturado (composto).


Começaremos estudando as seguintes operações com uma lista encadeada:

/* função de inicialização: retorna uma lista vazia */Lista* inicializa();

/* inserção no início: retorna a lista atualizada */Lista* insereInicio(Lista *atual, int i);

/* inserção no final: retorna a lista atualizada */Lista* insereFinal(Lista *atual, int i);

/* função remove: retorna a lista atualizada */Lista* removeNo(Lista *atual, int v){

/* função libera: libera a memória ocupada pela lista */Lista *libera(Lista *atual){

O programa principalint main(){

Lista *lista1;

lista1 = inicializa(); // Inicia um lista vazia

lista1 = insereInicio(lista1, 1); lista1 = insereInicio(lista1, 2);

lista1 = insereInicio(lista1, 3); lista1 = insereInicio(lista1, 4); lista1 = insereInicio(lista1, 5); lista1 = insereFinal(lista1, 6); lista1 = insereFinal(lista1, 7); lista1 = insereFinal(lista1, 8); lista1 = insereFinal(lista1, 9); lista1 = insereFinal(lista1, 10);

printf("\n\nLista"); imprime(lista1);

libera(lista1);system("pause");

return 0;}

Como ficará a lista?

O programa principalint main(){

Lista *lista1;

lista1 = inicializa(); // Inicia um lista vazia

lista1 = insereInicio(lista1, 1); lista1 = insereInicio(lista1, 2);

lista1 = insereInicio(lista1, 3); lista1 = insereInicio(lista1, 4); lista1 = insereInicio(lista1, 5); lista1 = insereFinal(lista1, 6); lista1 = insereFinal(lista1, 7); lista1 = insereFinal(lista1, 8); lista1 = insereFinal(lista1, 9); lista1 = insereFinal(lista1, 10);

printf("\n\nLista"); imprime(lista1);

libera(lista1);system("pause");

return 0;}

Estado da lista após a execução: 5 4 3 2 1 6 7 8 9 10

/* função de inicialização: retorna uma lista vazia */Lista* inicializa(){ return NULL;}

lista1

NULL

/* inserção no início: retorna a lista atualizada */Lista* insereInicio(Lista *atual, int i){ Lista *novo = (Lista*) malloc(sizeof(Lista));

if (estaVazia(atual)){ novo->info = i; novo->prox = NULL; }else{ novo->info = i; novo->prox = atual; } return novo;}

atual

NULL

novo

proxinfo

NULL

lista1

NULL

Considerando a lista vazia


if (estaVazia(atual)){

novo->info = i; novo->prox = NULL; }else{ novo->info = i; novo->prox = atual; } return novo;}

atualnovo

proxinfo

NULL1

NULL

lista1

NULL



if (estaVazia(atual)){

novo->info = i; novo->prox = NULL; }else{ novo->info = i; novo->prox = atual; } return novo;}

proxinfo

NULL1

lista1




lista1

novo

proxinfo

NULL1

proxinfo

NULL2

atual

Considerando a lista NÃO vazia



lista1

novo

proxinfo

NULL1

proxinfo

2

atual




lista1

proxinfo

NULL1

proxinfo

2




/* função vazia: retorna 1 se vazia ou 0 se não vazia */int estaVazia(Lista *atual){ return (atual == NULL);}

/* inserção no final: retorna a lista atualizada */Lista* insereFinal(Lista *atual, int i){

...}

A inserção no final se baseia em dois pontos:

Para inserirmos um novo nó no final da lista devemos fazer com que o último nó seja o atual, aliás todas as operações (inserção, remoção, alteração e consulta) com os nós da lista são baseadas no atual.

Para fazer atual apontar para o último nó, temos que começar fazendo- o apontar para o 1o. nó, depois para o 2o. nó e assim em diante até que

ele aponte para o último.

Enquanto o campo próximo de atual não for NULL indica que ainda não é o último nó.

Quando descobrimos o último nó, podemos então ligá-lo ao novo nó, concluindo desta forma a inserção do novo nó no final da lista.

1o

2o

/* inserção no final: retorna a lista atualizada */Lista* insereFinal(Lista *atual, int i){ /* se lista vazia, insere no inicio.*/ if (estaVazia(atual)){ return insereInicio(atual, i); }

/* acessa o final da lista.*/ Lista *inicio= atual; /*guarda o inicio da lista.*/ while((atual->prox != NULL)){ atual = atual->prox; }

/* insere o novo elemento no final*/ Lista *novo = (Lista*) malloc(sizeof(Lista)); novo->info = i; novo->prox = NULL; atual->prox = novo;

return inicio;}


... /* acessa o final da lista.*/ Lista *inicio= atual; /*guarda o inicio da lista.*/ while((atual->prox != NULL)){ atual = atual->prox; } ...

atual

proxinfo proxinfo. . .

inicio

proxinfo

NULL?? ?



atual


inicio

proxinfo

NULL???



atual


inicio

proxinfo

NULL?? ?


... /* insere o novo elemento no final*/ Lista *novo = (Lista*) malloc(sizeof(Lista)); novo->info = i; novo->prox = NULL; atual->prox = novo;

return inicio;}


inicio

proxinfo

NULL???

atual



return inicio;}


inicio

proxinfo

NULL

proxinfo

NULL

novo

???

atual



return inicio;}


inicio

proxinfo

proxinfo

NULL

novo

?? ?

?

atual



return inicio;}

lista1


proxinfo

proxinfo

NULL

?? ?

?

Outras Formas de Inserção

Podemos adaptar a forma de inserção vista anteriormente (no início e no final da lista) de modo a inserir nós no meio da lista (de acordo com algum critério, por exemplo uma determinda ordem).

Consultar todos os Nós da Lista

Nada deve ser feito se a Lista estiver vazia. Para mostrar todos os nós faça com que atual aponte para todos os nós, começando pelo primeiro nó. Para cada nó que atual aponte, mostre seus dados. Pare de mostrar dados quando atual apontar para NULL, é sinal de que a lista acabou.

Alterar um Nó da Lista

Nada deve ser feito se a Lista estiver vazia. A alteração de um nó nada mais é do que a consulta ao nó desejado seguido da alteração de seus dados.

Operação de Remoção de um Nó

Toda operação de remoção de um nó da lista deve prever a situação em que a lista esteja vazia, pois neste caso não há nenhum nó a remover.

Ao remover o último nó de uma lista, esta voltará a situação inicial (lista vazia).

A remoção de nó no meio da lista nada mais é do que a consulta ao nó desejado seguido da sua remoção. Uma sugestão é usar dois ponteiros: um para indicar o nó a ser excluído e outro para indicar o nó anterior, pois ao se remover o nó, devemos fazer a ligação do nó anterior do atual ao próximo do atual.

A remoção de nó no final da lista exige um caminhamento sobre a lista a partir do início, pois o acesso a qualquer nó da lista é sempre feito linearmente através dos nós que o antecedem.

Operação de Remoção de um Nó

proxinfo

?

proxinfo

?

proxinfo

?

proxinfo

?

proxinfo

?

proxinfo

?

proxinfo

?

proxinfo

?

Anterior do Atual

Atual

Próximo do Atual

1o

2o

3o

/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){

Lista *ant = NULL; /* ponteiro para elemento anterior */

/* procura elemento na lista, guardando anterior */ Lista *inicio= atual; /*guarda o inicio da lista.*/ while((atual != NULL) && (atual->info != v)){ ant = atual; atual = atual->prox; }

/* verifica se achou elemento */ if(atual == NULL) return inicio; /* não achou: retorna original */

/* remove() elemento */ Lista *exclui = atual; if(ant == NULL){ /* remove elemento do inicio */ atual = atual->prox; inicio = atual;

}else{ /* remove elemento do meio da lista */ ant->prox = atual->prox; } free(exclui); return inicio;}

/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){ Lista *ant = NULL; /* ponteiro para elemento anterior */


...

proxinfo proxinfo

lista1

? ?

atual

ant

NULL

proxinfo

? …



...

proxinfo proxinfo

lista1

? ?

atual

ant

NULL

proxinfo

? …

inicio



...

proxinfo proxinfo

lista1

? ?

atual

ant

proxinfo

? …

inicio



...

proxinfo proxinfo

lista1

? ?

atual

proxinfo

? …

inicio

ant


.../* verifica se achou elemento */

if(atual == NULL) return inicio; /* retorna lista original*/

/* remove o elemento */ Lista *exclui = atual;

if(ant == NULL){ atual = atual->prox; inicio = atual; }else{ /* remove elemento do meio da lista */ ant->prox = atual->prox; }

...

proxinfo proxinfo

lista1

? ?

atual

proxinfo

? …

inicio

ant

NULL

exclui

Situação de remoção no início



if(atual == NULL) return inicio; /* não achou */

/* remove() elemento */ Lista *exclui = atual;

if(ant == NULL){ atual = atual->prox; inicio = atual; }else{ /* remove elemento do meio da lista */ ant->prox = atual->prox; }

...

proxinfo proxinfo

lista1

? ?

proxinfo

? …

ant

NULL

atualinicio exclui





/* remove() elemento */Lista *exclui = atual;if(ant == NULL){

atual = atual->prox; inicio = atual; }else{ /* remove elemento do meio da lista */ ant->prox = atual->prox; }

...

proxinfo proxinfo

lista1

? ?

proxinfo

? …

ant

NULL

atualinicioexclui







free(exclui); return inicio;}

proxinfo proxinfo

lista1

? ?

proxinfo

? …

ant

NULL

atualinicioexclui








proxinfo

lista1

?

proxinfo

? …








Situação de remoção no meio/final

proxinfo proxinfo

lista1

? ?

atual

proxinfo

?

inicio

ant

info

? …

exclui








proxinfo proxinfo

lista1

? ?

proxinfo

?

inicio

ant

info

? …

atual exclui








proxinfo proxinfo

lista1

? ?

info

? …

/* função libera: libera a memória ocupada pela lista */Lista *libera(Lista *atual){ Lista *exclui; while(atual != NULL){ exclui = atual; atual = atual->prox; free(exclui); } return atual;}

proxinfo proxinfo

? ?

lista1

proxinfo

?

atual

NULL


proxinfo proxinfo

? ?

exclui

lista1

proxinfo

?

atual

NULL


proxinfo proxinfo

? ?

lista1

proxinfo

?

atual

exclui

NULL


proxinfo proxinfo

? ?

lista1

proxinfo

?

atual

exclui

NULL

NULL


proxinfo proxinfo

? ?

lista1

proxinfo

? …

atual

exclui

NULL


proxinfo proxinfo

? ?

lista1

proxinfo

? …

atual

exclui

NULL

NULL

Lista Linear por Encadeamento com Descritor

Até agora, em todas as operações de acesso ao último nó de uma lista, foi necessário o caminhamento sobre os demais nós da lista, a partir do primeiro.

Para facilitar o acesso ao último nó da lista podemos utilizar uma variável (do tipo apontador) para apontar para o último nó da lista.

Para simplificar ainda mais podemos reunir em um único elemento as referências ao primeiro e último nó de uma lista. Este elemento chamamos de nó descritor ou líder da lista. O acesso aos elementos da lista será sempre efetuado através do seu descritor.

O descritor pode armazenar outras informações da lista, como quantidade de nós, data da criação, autor, dentre outras.


Agora a variável descritor é que representará a lista encadeada. Todas as operações com a lista encadeada serão realizadas a partir da variável descritor.

descritor

proxinfo proxinfo proxinfo

NULL. . . .

ninicio ultimo

100


struct TipoLista{int info;struct TipoLista *prox;

};

typedef struct TipoLista Lista;typedef struct TipoDescritor Descritor;

Descritor *descritor;descrit

or

proxinfo proxinfo proxinfo

NULL. . . .

ninicio ultimo

100

struct TipoDescritor{ struct TipoLista *primeiro; int n; struct TipoLista *ultimo;};

Lista Linear por Encadeamento Duplo com Descritor

Em uma lista duplamente encadeada cada nó possui duas referências ao invés de uma só. Uma referência aponta para o nó predecessor e a outra aponta para o nó sucessor.

Com esta nova abordagem (encadeamento duplo), a passagem pelos nós da lista pode ser feita em dois sentidos: para frente e para trás.n

dadosnul dados dados null

Lista Linear por Encadeamento Duplo Circular com Descritor

Uma variação da lista duplamente encadeada é a lista circular, onde uma extremidade livre da lista aponta para outra.

Cada nó da lista satisfaz a seguinte condição:

(atual->proximo)->anterior = atual = (atual->anterior)->proximo

n

dados dados dados

prof. hilton cardoso marins junior [email protected] lista linear

Documents