UNIVERSIDADE FEDERAL DE MINAS GERAIS Listas Lineares Cristiano Arbex Valle Vinicius Fernandes dos Santos

UNIVERSIDADE FEDERAL DE MINAS GERAIS Listas Lineares Cristiano Arbex Valle arbex@dcc.ufmg.br Vinicius Fernandes dos Santos viniciussantos@dcc.ufmg.br

COMPUTER SCIENCE Listas Lineares Uma das formas mais simples de representar elementos de um conjunto. Itens podem ser acessados, inseridos ou retirados de uma lista. Podem crescer ou diminuir de tamanho durante a execução de um programa, de acordo com a demanda.

COMPUTER SCIENCE Listas Lineares Adequadas quando não é possível prever a demanda por memória – Permitem a manipulação de quantidades imprevisíveis de dados, de formato também imprevisível. São úteis em aplicações tais como manipulação simbólica, gerência de memória, compiladores, etc.

COMPUTER SCIENCE Definição de Listas Lineares Sequência de zero ou mais itens – x 1, x 2, ···, x n, na qual x i é de um determinado tipo e n representa o tamanho da lista linear Sua principal propriedade estrutural envolve as posições relativas dos itens em uma dimensão: – Assumindo n ≥ 1, x 1 é o primeiro item da lista e x n é o último item da lista. – x i precede x i+1 para i = 1, 2, ···, n – 1 – x i sucede x i-1 para i = 2, 3, ···, n – o elemento x i é dito estar na i-ésima posição da lista

COMPUTER SCIENCE TAD Listas Lineares Operações possíveis: Criar uma lista linear vazia. Inserir um novo item imediatamente após o i-ésimo item. Retirar o i-ésimo item. Localizar o i-ésimo item para examinar e/ou alterar o conteúdo de seus componentes. Combinar duas ou mais listas lineares em uma lista única.

COMPUTER SCIENCE TAD Listas Lineares Operações possíveis: Partir uma lista linear em duas ou mais listas. Fazer uma cópia da lista linear. Ordenar os itens da lista em ordem ascendente ou descendente, de acordo com alguns de seus componentes. Pesquisar a ocorrência de um item com um valor particular em algum componente.

COMPUTER SCIENCE Implementações de Listas Várias estruturas de dados podem ser usadas para representar listas lineares – Cada uma tem vantagens e desvantagens Duas implementações clássicas – Utilizando arranjos (arrays) – Utilizando apontadores

COMPUTER SCIENCE Implementação por Arranjos Os itens da lista são armazenados em posições contíguas de memória A lista pode ser percorrida em qualquer direção A inserção de um novo item pode ser realizada após o último item com custo constante

COMPUTER SCIENCE Implementação por Arranjos A inserção de um novo item no meio da lista requer um deslocamento de todos os itens localizados após o ponto de inserção Retirar um item do início da lista requer um deslocamento de itens para preencher o espaço deixado vazio

COMPUTER SCIENCE Implementação por Arranjos Os itens são armazenados em um array de tamanho suficiente para armazenar a lista – O campo Último aponta para a posição seguinte a do último elemento da lista (primeira posição vazia) – O i-ésimo item da lista está armazenado na (i-1)-ésima posição do array, 0 ≤ i < último – A constante MAX define o tamanho máximo permitido para a lista

COMPUTER SCIENCE Implementação por Arranjos #define MIN 0 #define MAX 1000 typedef int TChave; typedef int Apontador; typedef struct { TChave Chave; /* outros componentes */ } TItem; typedef struct { TItem Item[MAX]; Apontador Primeiro, Ultimo; } TLista;

COMPUTER SCIENCE Implementação por Arranjos void FLVazia(TLista *Lista) { Lista->Primeiro = MIN; Lista->Ultimo = Lista->Primeiro; } int Vazia(TLista Lista) { return (Lista.Primeiro == Lista.Ultimo); }

COMPUTER SCIENCE // insere x no final da lista void InsereN(TItem x, TLista *Lista) { if (Lista->Ultimo >= MAX) printf("Lista cheia\n"); else { Lista->Item[Lista->Ultimo] = x; Lista->Ultimo++; } Implementação por Arranjos

COMPUTER SCIENCE // insere x na posição p void InsereP(TItem x, TLista *Lista, Apontador p) { int i; if (Lista->Ultimo >= MAX || p > Lista->Ultimo) printf("Lista cheia ou posição inválida\n"); else { for (i = Lista->Ultimo; i > p; i--) Lista->Item[i] = Lista->Item[i-1]; Lista->Item[p] = x; Lista->Ultimo++; } Implementação por Arranjos

COMPUTER SCIENCE Implementação por Arranjos void RetiraP(Apontador p, TLista *Lista, TItem *Item) { int i; if (Vazia(*Lista) || p >= Lista->Ultimo) { printf("Lista vazia ou posição inválida\n"); return; } *Item = Lista->Item[p]; Lista->Ultimo--; for (i = p+1; i Ultimo; i++) Lista->Item[i-1] = Lista->Item[i]; }

COMPUTER SCIENCE Implementação por Arranjos void Imprime(TLista Lista) { Apontador p; for (p = Lista.Primeiro; p < Lista.Ultimo; p++) printf("%d\n", Lista.Item[p].Chave); }

COMPUTER SCIENCE Implementação por Arranjos Vantagens e Desvantagens Vantagens – Economia de memória (“apontadores implícitos”) – Localidade de acesso (blocos contíguos de memória) – Acesso O(1) a qualquer item Desvantagens – Inserção e remoção pode causar o deslocamento de todos os itens no pior caso – Em aplicações em que não existe previsão sobre o crescimento da lista, o tamanho máximo da lista tem de ser definido em tempo de compilação

COMPUTER SCIENCE Implementação por Apontadores Cada item é encadeado com o seguinte mediante uma variável do tipo Apontador – Permite utilizar posições não contíguas de memória – É possível inserir e retirar elementos sem necessidade de deslocar os itens seguintes da lista – Há uma célula cabeça para simplificar as operações sobre a lista

COMPUTER SCIENCE Implementação por Apontadores A lista é constituída de células Cada célula contém um item da lista e um apontador para a célula seguinte O registro TLista contém um apontador para a célula cabeça e um apontador para a última célula da lista

COMPUTER SCIENCE Implementação por Apontadores typedef int TChave; typedef struct { TChave Chave; /* outros componentes */ } TItem; typedef struct Celula *Apontador; typedef struct Celula { TItem Item; Apontador Prox; } TCelula; typedef struct { Apontador Primeiro, Ultimo; } TLista;

COMPUTER SCIENCE Implementação por Apontadores void FLVazia(TLista *Lista) { Lista->Primeiro = malloc(sizeof(TCelula)); Lista->Ultimo = Lista->Primeiro; Lista->Primeiro->Prox = NULL; } int Vazia(TLista Lista) { return (Lista.Primeiro == Lista.Ultimo); } ? “Cabeça” Último Primeiro NULL

COMPUTER SCIENCE Implementação por Apontadores // insere x no final da lista void InsereN(TItem x, TLista *Lista) { Lista->Ultimo->Prox = malloc(sizeof(TCelula)); Lista->Ultimo = Lista->Ultimo->Prox; Lista->Ultimo->Item = x; Lista->Ultimo->Prox = NULL; } info prox info prox info NULL PrimeiroÚltimo

COMPUTER SCIENCE Implementação por Apontadores // insere x no final da lista void InsereN(TItem x, TLista *Lista) { Lista->Ultimo->Prox = malloc(sizeof(TCelula)); Lista->Ultimo = Lista->Ultimo->Prox; Lista->Ultimo->Item = x; Lista->Ultimo->Prox = NULL; } info prox info prox info prox? PrimeiroÚltimo

COMPUTER SCIENCE Implementação por Apontadores // insere x no final da lista void InsereN(TItem x, TLista *Lista) { Lista->Ultimo->Prox = malloc(sizeof(TCelula)); Lista->Ultimo = Lista->Ultimo->Prox; Lista->Ultimo->Item = x; Lista->Ultimo->Prox = NULL; } info prox info prox info prox x NULL PrimeiroÚltimo

COMPUTER SCIENCE Implementação por Apontadores // insere x após a posição p void InsereP(TItem x, TLista *Lista, Apontador p) { Apontador novo = malloc(sizeof(TCelula)); novo->Item = x; novo->Prox = p->Prox; if (novo->Prox == NULL) Lista->Ultimo = novo; p->Prox = novo; } info prox info prox info NULL PrimeiroÚltimop

COMPUTER SCIENCE Implementação por Apontadores // insere x após a posição p void InsereP(TItem x, TLista *Lista, Apontador p) { Apontador novo = malloc(sizeof(TCelula)); novo->Item = x; novo->Prox = p->Prox; if (novo->Prox == NULL) Lista->Ultimo = novo; p->Prox = novo; } info prox info prox info NULL PrimeiroÚltimo ? p

COMPUTER SCIENCE Implementação por Apontadores // insere x após a posição p void InsereP(TItem x, TLista *Lista, Apontador p) { Apontador novo = malloc(sizeof(TCelula)); novo->Item = x; novo->Prox = p->Prox; if (novo->Prox == NULL) Lista->Ultimo = novo; p->Prox = novo; } info prox info prox info NULL PrimeiroÚltimo x prox p

COMPUTER SCIENCE Implementação por Apontadores // retira o item seguinte ao apontado por p void RetiraP(Apontador p, TLista *L, TItem *Item) { if (Vazia(*L) || p == NULL || p->Prox == NULL) { printf("Lista vazia ou posição inválida\n"); return; } Apontador q = p->Prox; *Item = q->Item; p->Prox = q->Prox; if (p->Prox == NULL) L->Ultimo = p; free(q); }

COMPUTER SCIENCE Implementação por Apontadores // retira o item seguinte ao apontado por p void RetiraP(Apontador p, TLista *L, TItem *Item) {... Apontador q = p->Prox; *Item = q->Item; p->Prox = q->Prox; if (p->Prox == NULL) L->Ultimo = p; free(q); } info prox info prox info NULL PrimeiroÚltimo x prox ? Item p

COMPUTER SCIENCE Implementação por Apontadores // retira o item seguinte ao apontado por p void RetiraP(Apontador p, TLista *L, TItem *Item) {... Apontador q = p->Prox; *Item = q->Item; p->Prox = q->Prox; if (p->Prox == NULL) L->Ultimo = p; free(q); } info prox info prox info NULL PrimeiroÚltimo x prox p ? Item q

COMPUTER SCIENCE Implementação por Apontadores // retira o item seguinte ao apontado por p void RetiraP(Apontador p, TLista *L, TItem *Item) {... Apontador q = p->Prox; *Item = q->Item; p->Prox = q->Prox; if (p->Prox == NULL) L->Ultimo = p; free(q); } info prox info prox info NULL PrimeiroÚltimo x prox p x Item q

COMPUTER SCIENCE Implementação por Apontadores // retira o item seguinte ao apontado por p void RetiraP(Apontador p, TLista *L, TItem *Item) {... Apontador q = p->Prox; *Item = q->Item; p->Prox = q->Prox; if (p->Prox == NULL) L->Ultimo = p; free(q); } info prox info prox info NULL PrimeiroÚltimop x Item

COMPUTER SCIENCE Implementação por Apontadores void Imprime(TLista Lista) { Apontador p; p = Lista.Primeiro->Prox; while (p != NULL) { printf("%d\n", p->Item.Chave); p = p->Prox; } info prox info prox info NULL PrimeiroÚltimo info prox p

COMPUTER SCIENCE Implementação por Apontadores void Imprime(TLista Lista) { Apontador p; p = Lista.Primeiro->Prox; while (p != NULL) { printf("%d\n", p->Item.Chave); p = p->Prox; } info prox info prox info NULL PrimeiroÚltimo info prox NULL p

COMPUTER SCIENCE Implementação por Apontadores Vantagens e Desvantagens Vantagens – Inserção e remoção têm custo constante Importante quando a ordem precisa ser mantida – Tamanho máximo não precisa ser definido a priori Importante quando não há previsão sobre crescimento Desvantagens – Memória extra para armazenar os apontadores – Baixa localidade de acesso (memória não-contígua) – O(n) para acessar um item no pior caso

UNIVERSIDADE FEDERAL DE MINAS GERAIS Listas Lineares Cristiano Arbex Valle Vinicius Fernandes dos Santos

Apresentações semelhantes

Apresentação em tema: "UNIVERSIDADE FEDERAL DE MINAS GERAIS Listas Lineares Cristiano Arbex Valle Vinicius Fernandes dos Santos"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback

Login

Autorizar-se através da rede social:

UNIVERSIDADE FEDERAL DE MINAS GERAIS Listas Lineares Cristiano Arbex Valle Vinicius Fernandes dos Santos

Apresentações semelhantes

Apresentação em tema: "UNIVERSIDADE FEDERAL DE MINAS GERAIS Listas Lineares Cristiano Arbex Valle Vinicius Fernandes dos Santos"— Transcrição da apresentação:

Apresentações semelhantes

Sobre projeto

Feedback