A apresentação está carregando. Por favor, espere

A apresentação está carregando. Por favor, espere

Prof. Hilton Cardoso Marins Junior LISTA LINEAR.

Apresentações semelhantes


Apresentação em tema: "Prof. Hilton Cardoso Marins Junior LISTA LINEAR."— Transcrição da apresentação:

1 Prof. Hilton Cardoso Marins Junior LISTA LINEAR

2 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.

3 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: x 1, x 2,...,x n, onde x 1 é o primeiro nó da lista linear e x n é o último nó da lista linear. Observações: Para 1 < k < n, o nó x k é precedido pelo nó x k-1 e seguido do x k+1. Quando o n = 0 dizemos que a lista está vazia.

4 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). X1X1 X2X2 X3X3 …X N-1 XNXN

5 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];

6 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

7 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 X1X1 X2X2 X n-1 XnXn

8 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 Dado Próximo Dado Próximo Dado Próximo... Dado Próximo NULL

9 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.

10 referente aos dados próximo nó da lista 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.

11 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.

12 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).

13 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){

14 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?

15 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:

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

17 Lista *novo = (Lista*) malloc(sizeof(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; } atual NULL novo proxinfo NULL lista1 NULL Considerando a lista vazia

18 novo->info = i; novo->prox = 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 novo proxinfo NULL 1 lista1 NULL Considerando a lista vazia

19 return novo; /* 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 NULL 1 lista1 Considerando a lista vazia

20 novo->info = i; /* 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 NULL 1 proxinfo NULL 2 atual Considerando a lista NÃO NÃO vazia Considerando a lista NÃO NÃO vazia

21 novo->prox = atual; /* 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 NULL 1 proxinfo 2 atual Considerando a lista NÃO NÃO vazia Considerando a lista NÃO NÃO vazia

22 return novo; /* 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 NULL 1 proxinfo 2 Considerando a lista NÃO NÃO vazia Considerando a lista NÃO NÃO vazia

23 estaVazia(atual) /* 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); }

24 /* 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. 1o1o1o1o 2o2o2o2o

25 /* 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; }

26 Lista *inicio= atual; /*guarda o inicio da 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 proxinfo proxinfo... inicio proxinfo NULL ? ??

27 while((atual->prox != NULL)){ atual = atual->prox; } /* 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 ? ??

28 while((atual->prox != NULL)){ atual = atual->prox; } /* 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 ? ? ?

29 /* 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

30 Lista *novo = (Lista*) malloc(sizeof(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; } proxinfo proxinfo... inicio proxinfo NULL proxinfo NULL novo ?? ? atual

31 novo->info = i; novo->prox = NULL; atual->prox = novo; /* 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

32 return inicio; /* 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 ? ? ? ?

33 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.

34 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.

35 Operação de Remoção de um Nó proxinfo ? proxinfo ? proxinfo ? proxinfo ? proxinfo ? proxinfo ? proxinfo ? proxinfo ? Anterior do Atual Atual Próximo do Atual 1o1o1o1o 2o2o2o2o 3o3o3o3o

36 /* 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; }

37 Lista *ant = NULL; /* ponteiro para elemento anterior */ /* 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 prox info ? …

38 Lista *inicio= atual; /*guarda o inicio da 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; }... proxinfo proxinfo lista1 ? ? atual ant NULL prox info ? … inicio

39 ant = atual; /* 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 prox info ? … inicio

40 atual = atual->prox; /* 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 prox info ? … inicio

41 ant = atual; /* 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 prox info ? … inicio

42 atual = atual->prox; /* 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 prox info ? … inicio ant

43 Lista *exclui = atual; if(ant == NULL){ /* 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 prox info ? … inicio ant NULL exclui Situação de remoção no início

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

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

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

47 return inicio; /* 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 ? prox info ? … Situação de remoção no início

48 Lista *exclui = atual; }else{ /* 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 prox info ? inicio ant info ? … exclui

49 /* remove elemento do meio da lista */ ant->prox = atual->prox; /* 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 ? ? prox info ? inicio ant info ? … atual exclui

50 free(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 ? ? prox info ? inicio ant info ? … atual exclui

51 return inicio; /* 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 ? …

52 Lista *atual /* 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 prox info ? atual NULL

53 exclui = atual; /* 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 prox info ? atual NULL

54 atual = atual->prox; /* 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 prox info ? atual NULL

55 free(exclui); /* 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 prox info ? atual NULL

56 atual != NULL exclui = atual; /* 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 prox info ? atual exclui NULL

57 atual = atual->prox; /* 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 prox info ? atual exclui NULL

58 free(exclui); /* 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 prox info ? atual exclui NULL

59 atual != NULL exclui = atual; /* 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 prox info ? atual exclui NULL

60 atual = atual->prox; /* 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 prox info ? atual exclui NULL

61 free(exclui); /* 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 prox info ? … atual exclui NULL

62 return atual; /* 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 prox info ? … atual exclui NULL

63 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.

64 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 proxinfoproxinfo NULL.. ninicioultimo 100

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

66 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 null

67 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


Carregar ppt "Prof. Hilton Cardoso Marins Junior LISTA LINEAR."

Apresentações semelhantes


Anúncios Google