prof. hilton cardoso marins junior hiltonmarins@gmail.com lista linear
Post on 18-Apr-2015
105 Views
Preview:
TRANSCRIPT
Prof. Hilton Cardoso Marins Juniorhiltonmarins@gmail.com
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
Lista Linear por Encadeamento
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
Lista Linear por Encadeamento
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.
Lista Linear por Encadeamento
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.
Operações com Lista Linear por Encadeamento
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).
Operações com Lista Linear por Encadeamento
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
/* 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;}
atualnovo
proxinfo
NULL1
NULL
lista1
NULL
Considerando a lista vazia
/* 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;}
proxinfo
NULL1
lista1
Considerando a lista vazia
/* 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;}
lista1
novo
proxinfo
NULL1
proxinfo
NULL2
atual
Considerando a lista NÃO vazia
/* 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;}
lista1
novo
proxinfo
NULL1
proxinfo
2
atual
Considerando a lista NÃO vazia
/* 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;}
lista1
proxinfo
NULL1
proxinfo
2
Considerando a lista NÃO vazia
/* 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;}
/* 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;}
/* inserção no final: retorna a lista atualizada */Lista* insereFinal(Lista *atual, int i){
... /* 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?? ?
/* inserção no final: retorna a lista atualizada */Lista* insereFinal(Lista *atual, int i){
... /* 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???
/* inserção no final: retorna a lista atualizada */Lista* insereFinal(Lista *atual, int i){
... /* 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?? ?
/* inserção no final: retorna a lista atualizada */Lista* insereFinal(Lista *atual, int i){
... /* insere o novo elemento no final*/ Lista *novo = (Lista*) malloc(sizeof(Lista)); novo->info = i; novo->prox = NULL; atual->prox = novo;
return inicio;}
proxinfo proxinfo. . .
inicio
proxinfo
NULL???
atual
/* inserção no final: retorna a lista atualizada */Lista* insereFinal(Lista *atual, int i){
... /* insere o novo elemento no final*/ Lista *novo = (Lista*) malloc(sizeof(Lista)); novo->info = i; novo->prox = NULL; atual->prox = novo;
return inicio;}
proxinfo proxinfo. . .
inicio
proxinfo
NULL
proxinfo
NULL
novo
???
atual
/* inserção no final: retorna a lista atualizada */Lista* insereFinal(Lista *atual, int i){
... /* insere o novo elemento no final*/ Lista *novo = (Lista*) malloc(sizeof(Lista)); novo->info = i; novo->prox = NULL; atual->prox = novo;
return inicio;}
proxinfo proxinfo. . .
inicio
proxinfo
proxinfo
NULL
novo
?? ?
?
atual
/* inserção no final: retorna a lista atualizada */Lista* insereFinal(Lista *atual, int i){
... /* insere o novo elemento no final*/ Lista *novo = (Lista*) malloc(sizeof(Lista)); novo->info = i; novo->prox = NULL; atual->prox = novo;
return inicio;}
lista1
proxinfo proxinfo. . .
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 */
/* 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; }
...
proxinfo proxinfo
lista1
? ?
atual
ant
NULL
proxinfo
? …
/* 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; }
...
proxinfo proxinfo
lista1
? ?
atual
ant
NULL
proxinfo
? …
inicio
/* 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; }
...
proxinfo proxinfo
lista1
? ?
atual
ant
proxinfo
? …
inicio
/* 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; }
...
proxinfo proxinfo
lista1
? ?
atual
ant
proxinfo
? …
inicio
/* 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; }
...
proxinfo proxinfo
lista1
? ?
atual
ant
proxinfo
? …
inicio
/* 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; }
...
proxinfo proxinfo
lista1
? ?
atual
proxinfo
? …
inicio
ant
/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){
.../* 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
/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){
.../* verifica se achou elemento */
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
Situação de remoção no início
/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){
.../* verifica se achou elemento */
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
atualinicioexclui
Situação de remoção no início
/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){
.../* verifica se achou elemento */
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; }
free(exclui); return inicio;}
proxinfo proxinfo
lista1
? ?
proxinfo
? …
ant
NULL
atualinicioexclui
Situação de remoção no início
/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){
.../* verifica se achou elemento */
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; }
free(exclui); return inicio;}
proxinfo
lista1
?
proxinfo
? …
Situação de remoção no início
/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){
.../* verifica se achou elemento */
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; }
free(exclui); return inicio;}
Situação de remoção no meio/final
proxinfo proxinfo
lista1
? ?
atual
proxinfo
?
inicio
ant
info
? …
exclui
/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){
.../* verifica se achou elemento */
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; }
free(exclui); return inicio;}
Situação de remoção no meio/final
proxinfo proxinfo
lista1
? ?
proxinfo
?
inicio
ant
info
? …
atual exclui
/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){
.../* verifica se achou elemento */
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; }
free(exclui); return inicio;}
Situação de remoção no meio/final
proxinfo proxinfo
lista1
? ?
proxinfo
?
inicio
ant
info
? …
atual exclui
/* função remove: remove elemento da lista */Lista* removeNo(Lista *atual, int v){
.../* verifica se achou elemento */
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; }
free(exclui); return inicio;}
Situação de remoção no meio/final
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
/* 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
? ?
exclui
lista1
proxinfo
?
atual
NULL
/* 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
? ?
exclui
lista1
proxinfo
?
atual
NULL
/* 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
? ?
exclui
lista1
proxinfo
?
atual
NULL
/* 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
exclui
NULL
/* 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
exclui
NULL
/* 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
exclui
NULL
/* 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
exclui
NULL
/* 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
exclui
NULL
NULL
/* 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
exclui
NULL
/* 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
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.
Lista Linear por Encadeamento com Descritor
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
Lista Linear por Encadeamento com Descritor
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
top related