Estruturas de Dados. Parte dos slides a seguir são adaptações, extensões e recodificações em C dos originais:

Transcrição

1 Estruturas de Dados Listas Dinâmicas Simplesmente Encadeadas Prof. Ricardo J. G. B. Campello Créditos Parte dos slides a seguir são adaptações, extensões e recodificações em C dos originais: disponíveis em cedidos pela Profa. Maria Cristina F. de Oliveira 2 1

2 Listas Dinâmicas Utiliza alocação dinâmica de memória ao invés de arranjos (vetores) pré-alocados. Lista dispõe de toda memória disponível para o programa durante a execução (heap) Alocação/liberação desses endereços é gerenciada pelo S.O., por meio de comandos da linguagem de programação Linguagem C: malloc e free 3 Listas Simplesmente Encadeadas Uma lista encadeada é uma estrutura de dados linear que consiste de uma seqüência interligada de nós (ou nodos) dinamicamente alocados. No caso de encadeamento simples, cada nodo armazena: elemento (registro, objeto,...) ponteiro para o próximo nodo. elemento próximo nodo A B C D 4 2

3 Listas Simplesmente Encadeadas nodo Nodo: elem lig struct list_node { tipo_elem elem; struct list_node *lig; }; typedef struct list_node nodo; 5 Listas Simplesmente Encadeadas nulo (NULL) Lista: typedef struct { int nelem; nodo *head, *tail; } Lista; Lista L; /* Exemplo de Declaração */ 6 3

4 Listas Simplesmente Encadeadas Inicialização: Lista *Definir(void){ Lista *L; L = malloc(sizeof(lista)); L->nelem = 0; L->head = NULL; L->tail = NULL; return L; } nulo (NULL) 7 Inserindo no Início 1. Aloque o novo nodo. 2. Insira o novo elemento. 3. Aponte o novo nodo para head. 4. Aponte head para o novo nodo. PS. símbolo representa NULL. 8 4

5 Inserindo no Início nodo *Inserir_frente(tipo_elem x, Lista *L){ nodo *Pa; Pa = malloc(sizeof(nodo)); Pa->elem = x; Pa->lig = L->head; L->head = Pa; if (L->tail == NULL) /* L antes vazia */ L->tail = L->head; L->nelem++; return Pa; } /* O(1) */ 9 Removendo do Início 1. Aponte um ponteiro auxiliar Pa para head 2. Aponte head para o próximo nodo. 3. Desaloque o primeiro nodo usando Pa 10 5

6 Removendo do Início tipo_elem Remover_frente(Lista *L){ tipo_elem x; nodo *Pa; Pa = L->head; L->head = Pa->lig; if (L->head == NULL) /* L antes com elemento único */ L->tail = NULL; x = Pa->elem; free(pa); L->nelem--; return x; } /* O(1) */ 11 Inserindo no Final 1. Aloque o novo nodo. 2. Insira o novo elemento. 3. Faça o novo nodo apontar para NULL. 4. Faça o antigo último nodo apontar para o novo. 5. Atualize tail para o novo nodo. Podemos inverter a ordem dos passos 4 e 5? 12 6

7 Inserindo no Final nodo *Inserir_final(tipo_elem x, Lista *L){ nodo *Pa; Pa = malloc(sizeof(nodo)); Pa->elem = x; Pa->lig = NULL; if (L->head == NULL) L->head = Pa; /* L antes vazia */ else (L->tail)->lig = Pa; L->tail = Pa; L->nelem++; return Pa; } /* O(1) */ 13 Removendo do Final Remover no final de uma lista simplesmente encadeada não é eficiente. Não existe algoritmo de complexidade (tempo) constante para acessar o nodo anterior a tail. A obtenção a partir de head é O(n), onde n é o número de elementos na lista (nelem na nossa implementação). 14 7

8 Removendo do Final tipo_elem Remover_final(Lista *L){ tipo_elem x; nodo *Pa; Pa = L->head; if ((L->head)->lig == NULL) { /* L com 1 elemento */ L->tail = NULL; L->head = NULL; } else { while (Pa->lig!= L->tail) Pa = Pa->lig; L->tail = Pa; Pa = Pa->lig; (L->tail)->lig = NULL; } x = Pa->elem; free(pa); L->nelem--; return x; } /* O(L.nelem) */ Exercícios 1. Implemente uma função Lista_vazia(Lista *L) que retorna True ou False se a lista está vazia ou não, respectivamente 2. Seja o tipo dos elementos da lista, tipo_elem, definido como um registro (struct) com dois campos: chave e info 1.a. Implemente a seguinte função: retorno Localizar(tipo_elem x, Lista *L); que retorna um registro do tipo retorno, também com dois campos: Campo 1 (int): Rank do elemento com chave x.chave na lista L Campo 2 (nodo*): Ponteiro para o nodo de x em L 1.b. Qual o tempo de execução assintótico (BIG-O) de pior caso? 3. Faz sentido aqui Localizar via Busca Binária? Justifique 8

9 Exercícios 4. Implemente funções para remover elementos quaisquer da lista: tipo_elem Remover_elem(tipo_elem x, Lista *L); tipo_elem Remover_rank(int p, Lista *L); A 1a deve remover da lista o nodo que armazena o elemento com chave x.chave (retornando ao sistema a respectiva memória) e retornar esse elemento A 2a deve fazer o mesmo, mas para o p-ésimo elemento da lista 5. Repita o exercício anterior para as funções Buscar_elem e Buscar_rank, que apenas retornam o elemento, sem remover o respectivo nodo da lista 6. Implemente uma função Modificar que substitua o elemento em uma dada colocação (rank) da lista por outro, retornando-o 17 Exercícios 7. Implemente uma função Modify que substitua um dado elemento x com chave x.chave por outro y também dado. Use Localizar do exercício 1 e Modificar do exercício 5 8. Suponha que se disponha de um ponteiro para um dado nodo da lista (por exemplo obtido via Localizar do exercício 1): Explique porque, mesmo com esse ponteiro em mãos, não é possível remover o respectivo nodo em tempo constante O(1) (sem ter que percorrer a lista a partir de head) É possível modificar a ED dos nodos para tornar isso possível? Justifique 9. Faça um procedimento Esvaziar(Lista *L) que devolva a memória de todos os nodos de uma lista L ao sistema e reinicialize a lista 18 9

10 Bibliografia A. M. Tenembaum et al., Data Structures Using C, Prentice-Hall, 1990 M. T. Goodrich & R. Tamassia, Data Structures and Algorithms in C++/Java, John Wiley & Sons, 2002/2005 N. Ziviani, Projeto de Algoritmos, Thomson, 2a. Edição, 2004 J. L. Szwarcfiter & L. Markenzon, Estruturas de Dados e seus Algoritmos, LTC, 1994 Schildt, H. "C Completo e Total", 3a. Edição, Pearson,