aula07-listas e filas
TRANSCRIPT
-
Tcnicas de Programao
-
(c) Paulo Santos2
Listas LigadasFunes 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 Santos3
Listas Simplesmente Ligadas
typedef struct _Nodo {
int dados;
struct _Nodo* proximo;
} Nodo;
typedef struct {
Nodo* head;
Nodo* tail;
} ListaSL;
-
(c) Paulo Santos4
Listas Simplesmente LigadasListaSL* 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 Santos5
Listas Simplesmente Ligadasint 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 Santos6
Listas Simplesmente Ligadasint 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 Santos7
Listas Simplesmente Ligadasint 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 Santos8
Listas Simplesmente Ligadasint 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 Santos9
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 Santos10
Listas Simplesmente Ligadasint 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 Santos11
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;
}
// 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;
}
}
-
(c) Paulo Santos12
Listas Simplesmente Ligadas
int peekInicio(ListaSL *l) {
return l->head->dados;
}
int peekFim(ListaSL *l) {
return l->tail->dados;
}
-
(c) Paulo Santos13
Listas Duplamente Ligadas
typedef struct _Nodo {
int dados;
struct _Nodo* proximo;
struct _Nodo* anterior;
} Nodo;
typedef struct {
Nodo *head;
Nodo *tail;
} ListaDL;
-
(c) Paulo Santos14
Listas Duplamente Ligadasint 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 Santos15
Listas Duplamente Ligadasint 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 Santos16
Listas Duplamente Ligadasint 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 Santos17
Listas Duplamente Ligadasint 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 vaziaif (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 Santos18
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 Santos19
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;
}
// 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;
}
}
-
(c) Paulo Santos20
Listas Duplamente Ligadas
int peekInicio(ListaSL *l) {
return l->head->dados;
}
int peekFim(ListaSL *l) {
return l->tail->dados;
}
-
(c) Paulo Santos21
Listas LigadasOutras 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 Santos22
Exemplos Agendar Jogos
1 Jornada:
Benfica Belenenses
Porto Braga
Sporting -
Acadmica
-
(c) Paulo Santos23
Exemplos Agendar Jogos
2 Jornada:
Benfica Porto
Sporting Belenenses
Acadmica - Braga
-
(c) Paulo Santos24
Exemplos Agendar Jogos
3 Jornada:
Benfica Sporting
Acadmica Porto
Braga - Belenenses
-
(c) Paulo Santos25
Exemplos Agendar Jogos
4 Jornada:
Benfica Acadmica
Braga Sporting
Belenenses - Porto
-
(c) Paulo Santos26
Exemplos Agendar Jogos
5 Jornada:
Benfica Braga
Belenenses Acadmica
Porto - Sporting
-
(c) Paulo Santos27
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 Santos28
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 Santos29
Filas FIFO, LIFO, FILO, LILOFIFO: 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 Santos30
Filas FIFO, LIFO, FILO, LILOFILO: 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 Santos31
Funes usuais nas Filas void colocar(Fila *f, int info);
int tirar(Fila *f);
int peek(Fila *f);
Como criar Listas?
-
(c) Paulo Santos32
Filas FILO ou LIFOComo funciona uma Pilha?
O Primeiro
prato a entrar
o ltimo a sair.
Uma fila FILO
ou LIFO uma
Pilha
-
(c) Paulo Santos33
Filas FIFO ou LILOComo 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