Tcnicas de Programao

Listas Ligadas
Funes normais de implementar em listas ligadas:

int insereInicio(Lista* l, int info); // adiciona no inicio int insereFim(Lista* l, int info); // adiciona no fim

int existe(Lista* l, int info); // se contem um objecto

int remover(Lista* l, int info); // remove um objecto int peekInicio(Lista* l); // Devolve o primeiro objecto da lista

int peekFim(Lista* l); // Devolve o ltimo objecto da lista

(c) Paulo Santos

Listas Simplesmente Ligadas

typedef struct _Nodo {

int dados; struct _Nodo* proximo; } Nodo;
(c) Paulo Santos

typedef struct {
Nodo* head; Nodo* tail; } ListaSL;
3

Listas Simplesmente Ligadas

ListaSL* cria() { ListaSL* l = (ListaSL*)malloc(sizeof(ListaSL)); l->head = NULL; l->tail = NULL; return l; void liberta(ListaSL *l) { } Nodo *aux;
aux = l->head; while(aux != NULL) { l->head = l->head->proximo; free(aux); aux = l->head; } free(l); }
(c) Paulo Santos
4

Listas Simplesmente Ligadas

int insereFim(ListaSL *l, int info) { Nodo *n = (Nodo*)malloc(sizeof(Nodo)); if (n == NULL) return 0; n->dados=info; n->proximo = NULL; // lista vazia if (l->head == NULL) { l->head = n; l->tail = n;

} else {
l->tail->proximo = n; l->tail = n; }

return 1;
}

(c) Paulo Santos

Listas Simplesmente Ligadas

int insereFim(ListaSL *l, int info) { Nodo *n = (Nodo*)malloc(sizeof(Nodo)); if (n == NULL) return 0; n->dados=info; n->proximo = NULL; // lista vazia if (l->head == NULL) { l->head = n; l->tail = n;

} else {
l->tail->proximo = n; l->tail = n; }

return 1;
}

(c) Paulo Santos

Listas Simplesmente Ligadas

int insereFim(ListaSL *l, int info) { Nodo *n = (Nodo*)malloc(sizeof(Nodo)); if (n == NULL) return 0; n->dados=info; n->proximo = NULL; // lista vazia if (l->head == NULL) { l->head = n; l->tail = n;

} else {
l->tail->proximo = n; l->tail = n; }

return 1;
}

(c) Paulo Santos

Listas Simplesmente Ligadas

int insereInicio(ListaSL *l, int info) { Nodo *n = (Nodo*)malloc(sizeof(Nodo)); if (n == NULL) return 0; n->dados=info; n->proximo = NULL; // lista vazia if (l->head == NULL) { l->head = n; l->tail = n;

} else {
n->proximo = l->head; l->head = n; }

return 1;
}

(c) Paulo Santos

Listas Simplesmente Ligadas

int existe(ListaSL *l, int info) { Nodo *aux = l->head; while (aux != NULL && aux->dados != info) aux = aux->proximo; if (aux == NULL) return 0; else return 1; }

(c) Paulo Santos

Listas Simplesmente Ligadas

int remover(ListaSL *l, int info) { }

necessrio prever 6 situaes:

1. A lista est vazia 2. O item a remover o nico da lista

3. O item a remover a cabea

4. O item a remover a cauda 5. O item a remover est no meio da lista 6. O item no se encontra na lista
(c) Paulo Santos
10

Listas Simplesmente Ligadas

int remover(ListaSL *l, int info) { Nodo *aux, *aux1; // 1:Lista vazia if (l->head == NULL) return 0; else { aux = l->head; // valor no inicio if (aux->dados == info) { // 2:Lista com um elemento if (l->head == l->tail) { l->head = NULL; l->tail = NULL; free(aux); } else { // 3:Lista com vrios elementos l->head = l->head->proximo; free(aux); } return 1; (c) } // Vai procurar o valor while (aux->proximo != NULL && aux->proximo->dados != info) aux = aux->proximo; // se o valor existe if (aux->proximo != NULL) { // 4:se o ultimo valor da lista if (aux->proximo == l->tail) { l->tail = aux; free(aux->proximo); l->tail->proximo = NULL; } else { // 5:esta no meio da lista aux1 = aux->proximo; aux->proximo = aux->proximo->proximo; free(aux1); } return 1; } else // 6:valor no existe return 0; 11

Paulo } Santos
}

Listas Simplesmente Ligadas

int peekInicio(ListaSL *l) { return l->head->dados; }

int peekFim(ListaSL *l) { return l->tail->dados; }

(c) Paulo Santos

12

Listas Duplamente Ligadas

typedef struct _Nodo { int dados; struct _Nodo* proximo;

typedef struct {
Nodo *head; Nodo *tail; } ListaDL;
13

struct _Nodo* anterior;

} Nodo;
(c) Paulo Santos

Listas Duplamente Ligadas

int insereFim(ListaDL *l, int info) { Nodo *n = (Nodo*)malloc(sizeof(Nodo)); if (n == NULL) return 0; n->dados=info; n->proximo = NULL; n->anterior = NULL; // lista vazia if (l->head == NULL) { l->head = n; l->tail = n; } else { n->anterior = l->tail; l->tail->proximo = n; l->tail = n; } return 1; }

(c) Paulo Santos

14

Listas Duplamente Ligadas

int insereFim(ListaDL *l, int info) { Nodo *n = (Nodo*)malloc(sizeof(Nodo)); if (n == NULL) return 0; n->dados=info; n->proximo = NULL; n->anterior = NULL; // lista vazia if (l->head == NULL) { l->head = n; l->tail = n; } else { n->anterior = l->tail; l->tail->proximo = n; l->tail = n; } return 1; }

(c) Paulo Santos

15

Listas Duplamente Ligadas

int insereFim(ListaDL *l, int info) { Nodo *n = (Nodo*)malloc(sizeof(Nodo)); if (n == NULL) return 0; n->dados=info; n->proximo = NULL; n->anterior = NULL; // lista vazia if (l->head == NULL) { l->head = n; l->tail = n; } else { n->anterior = l->tail; l->tail->proximo = n; l->tail = n; } return 1; }

(c) Paulo Santos

16

Listas Duplamente Ligadas

int insereInicio(ListaDL *l, int info) { Nodo *n = (Nodo*)malloc(sizeof(Nodo)); if (n == NULL) return 0; n->dados=info; n->proximo = NULL; n->anterior = NULL; // lista vazia if (l->head == NULL) { l->head = n; l->tail = n; } else { n->proximo = l->head; l->head->anterior = n; l->head = n; } return 1; } (c) Paulo Santos

17

Listas Duplamente Ligadas

int existe(ListaDL *l, int info) {
Nodo *aux = l->head; while (aux != NULL && aux->dados != info) aux = aux->proximo; if (aux == NULL) return 0; else return 1; } } int existe(ListaDL *l, int info) { Nodo *aux = l->tail; while (aux != NULL && aux->dados != info) aux = aux->anterior;

if (aux == NULL)
return 0; else

return 1;

(c) Paulo Santos

18

Listas Duplamente Ligadas

int remover(ListaDL *l, int info) { Nodo *aux; // 1:Lista vazia if (l->head == NULL) return 0; else { aux = l->head; // valor no inicio if (aux->dados == info) { // 2:Lista com um elemento if (l->head == l->tail) { l->head = NULL; l->tail = NULL; free(aux); } else { // 3:Lista com vrios elementos l->head = l->head->proximo; l->head->anterior = NULL; free(aux); } return 1; (c) } // Vai procurar o valor while (aux != NULL && aux->dados!= info) aux = aux->proximo; // se o valor existe if (aux != NULL) { // 4:se o ultimo valor da lista if (aux == l->tail) { l->tail = l->tail->anterior; l->tail->proximo = NULL; free(aux); } else { // 5:esta no meio da lista aux->anterior->proximo = aux->proximo; aux->proximo->anterior = aux->anterior; free(aux); } return 1; } else // 6:valor no existe return 0; } }

Paulo Santos

19

Listas Duplamente Ligadas

int peekInicio(ListaSL *l) { return l->head->dados; }

int peekFim(ListaSL *l) { return l->tail->dados; }

(c) Paulo Santos

20

Listas Ligadas
Outras funes que tambm podem ser implementados:

int insereOrdenado(Lista *l, int info); // Insere de forma ordenada int numElemento(Lista *l); // Devolve o nmero de elementos

int get(int i); // Devolve o objecto da posio i

int insereApos(Lista *l, int i, int info); // insere a seguir posicao i int insereAntes(Lista *l, int i, int ingo); // insere antes da posicao i

(c) Paulo Santos

21

Exemplos Agendar Jogos

1 Jornada:
Benfica Belenenses Porto Braga

Sporting Acadmica
(c) Paulo Santos
22

Exemplos Agendar Jogos

2 Jornada:
Benfica Porto Sporting Belenenses Acadmica - Braga

(c) Paulo Santos

23

Exemplos Agendar Jogos

3 Jornada:
Benfica Sporting

Acadmica Porto
Braga - Belenenses

(c) Paulo Santos

24

Exemplos Agendar Jogos

4 Jornada:
Benfica Acadmica Braga Sporting

Belenenses - Porto
(c) Paulo Santos

25

Exemplos Agendar Jogos

5 Jornada: Benfica Braga Belenenses Acadmica Porto - Sporting

(c) Paulo Santos

26

Exemplos Alocao de Memria

O Sistema Operativo, possui uma lista ligada para fazer a gesto de memria. Na lista cada item possui:

Se o segmento de memoria est livre ou ocupado

Inicio do Segmento Tamanho Prximo Segmento

(c) Paulo Santos

27

Exemplos Alocao de Memria

Algoritmo First Fit: Percorre a lista at encontrar o primeiro espao disponvel.

Algoritmo Next Fit: O mesmo que o anterior, s que em vez de partir sempre do inicio da lista, parte da ltima posio.
Algoritmo Best Fit: Verifica toda a lista para encontrar o segmento livre cujo tamanho melhor se aproxima s necessidades Algortimo Worst Fit: Verifica toda a lista para encontrar o segmento livre com o maior tamanho.
(c) Paulo Santos
28

Filas FIFO, LIFO, FILO, LILO

FIFO: First In First Out Entra: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Sai: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

LILO: Last In Last Out

Entra: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Sai: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10

FIFO = LILO
(c) Paulo Santos
29

Filas FIFO, LIFO, FILO, LILO

FILO: First In Last Out Entra: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 Sai: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

LIFO: Last In First Out

Entra: 1, 2, 3, 4, 5, 6, 7, 8, 9, 10
Sai: 10, 9, 8, 7, 6, 5, 4, 3, 2, 1

FILO = LIFO
(c) Paulo Santos
30

Funes usuais nas Filas

void colocar(Fila *f, int info);

int tirar(Fila *f);

int peek(Fila *f);

Como criar Listas?

(c) Paulo Santos

31

Filas FILO ou LIFO

Como funciona uma Pilha?
O Primeiro

prato a entrar
o ltimo a sair.

Uma fila FILO

ou LIFO uma

Pilha
(c) Paulo Santos
32

Filas FIFO ou LILO

Como funciona uma Lista Ligada?

Colocar um elemento na Fila inserir no fim da Lista. Retirar um elemento da FIa remover no inicio da Lista.

Uma lista FIFO ou LILO uma Lista Ligada

(c) Paulo Santos
33