Prof. Hilton Cardoso Marins Junior hiltonmarins@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óximo ... NULL

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 principal int main(){. Lista. lista1; O programa principal int 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 principal int main(){. Lista. lista1; O programa principal int 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 /* função de inicialização: retorna uma lista vazia */ Lista* inicializa(){ return 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; } Considerando a lista vazia lista1 novo atual NULL NULL info prox 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; } Considerando a lista vazia lista1 novo atual NULL NULL info prox 1 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; } Considerando a lista vazia lista1 info prox 1 NULL

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; } Considerando a lista NÃO vazia novo lista1 atual info prox info prox 2 NULL 1 NULL

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; } Considerando a lista NÃO vazia novo lista1 atual info prox info prox 2 1 NULL

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; } Considerando a lista NÃO vazia lista1 info prox info prox 2 1 NULL

/. inserção no início: retorna a lista atualizada. / Lista /* 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 /* 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 /* 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 /* 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 info prox info prox info prox . . . ? ? ? NULL inicio

/. inserção no final: retorna a lista atualizada. / Lista /* 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 info prox info prox info prox . . . ? ? ? NULL inicio

/. inserção no final: retorna a lista atualizada. / Lista /* 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 info prox info prox info prox . . . ? ? ? NULL inicio

/. inserção no final: retorna a lista atualizada. / Lista /* 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; } atual info prox info prox info prox . . . ? ? ? NULL inicio

/. inserção no final: retorna a lista atualizada. / Lista /* 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; } atual info prox info prox info prox . . . ? ? ? NULL inicio novo info prox NULL

/. inserção no final: retorna a lista atualizada. / Lista /* 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; } atual info prox info prox info prox . . . ? ? ? inicio novo info prox ? NULL

/. inserção no final: retorna a lista atualizada. / Lista /* 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 info prox info prox info prox . . . ? ? ? info prox ? 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ó Anterior do Atual Atual Próximo do Atual info prox info prox info prox ? ? ? 1o info prox info prox info prox ? ? ? 2o info prox info prox ? ? 3o

/. função remove: remove elemento da lista. /. Lista. removeNo(Lista /* 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 /* 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; } ... atual info prox info prox info prox ? … ? ? ant lista1 NULL

/. função remove: remove elemento da lista. / Lista. removeNo(Lista /* 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; } ... inicio atual info prox info prox info prox ? … ? ? ant lista1 NULL

/. função remove: remove elemento da lista. / Lista. removeNo(Lista /* 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; } ... inicio atual info prox info prox info prox ? … ? ? ant lista1

/. função remove: remove elemento da lista. / Lista. removeNo(Lista /* 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; } ... inicio atual info prox info prox info prox ? … ? ? ant lista1

/. função remove: remove elemento da lista. / Lista. removeNo(Lista /* 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; } ... inicio atual info prox info prox info prox ? … ? ? lista1 ant

/. função remove: remove elemento da lista. / Lista. removeNo(Lista /* 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; } ... inicio atual info prox info prox info prox ? … ? ? lista1 ant

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; /* 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; } ... Situação de remoção no início inicio atual exclui info prox info prox info prox ? … ? ? ant lista1 NULL

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; } ... Situação de remoção no início inicio exclui atual info prox info prox info prox ? … ? ? ant lista1 NULL

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; } ... Situação de remoção no início exclui inicio atual info prox info prox info prox ? … ? ? ant lista1 NULL

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 início exclui inicio atual info prox info prox info prox ? … ? ? ant lista1 NULL

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 início info prox info prox … ? ? lista1

Situação de remoção no meio/final /* 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 inicio atual exclui info prox info prox info prox info ? … ? ? ? lista1 ant

Situação de remoção no meio/final /* 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 inicio atual exclui info prox info prox info prox info ? … ? ? ? lista1 ant

Situação de remoção no meio/final /* 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 inicio atual exclui info prox info prox info prox info ? … ? ? ? lista1 ant

Situação de remoção no meio/final /* 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 info prox info prox info ? … ? ? lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } atual info prox info prox info prox ? ? ? NULL lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } atual exclui info prox info prox info prox ? ? ? NULL lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } exclui atual info prox info prox info prox ? ? ? NULL lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } exclui atual info prox info prox info prox ? ? ? NULL lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } exclui atual info prox info prox info prox ? ? ? NULL lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } exclui atual info prox info prox info prox ? ? ? NULL lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } exclui atual info prox info prox info prox ? ? ? NULL lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } exclui atual info prox info prox info prox ? ? ? NULL lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } exclui atual NULL info prox info prox info prox ? ? ? NULL lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } exclui atual NULL info prox info prox info prox ? … ? ? lista1

/. função libera: libera a memória ocupada pela lista. / Lista /* 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; } exclui atual NULL info prox info prox info prox ? … ? ? lista1 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 inicio n ultimo 100 info prox info prox info prox . . . . NULL

Lista Linear por Encadeamento com Descritor struct TipoLista{ Lista Linear por Encadeamento com Descritor struct TipoLista{ int info; struct TipoLista *prox; }; typedef struct TipoLista Lista; typedef struct TipoDescritor Descritor; Descritor *descritor; struct TipoDescritor{ struct TipoLista *primeiro; int n; struct TipoLista *ultimo; }; descritor inicio n ultimo 100 info prox info prox info prox . . . . NULL

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 dados nul 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