implementa as funcoes restantes de lib_lista.c

lib_lista.c

@@ -7,7 +7,6 @@ int inicializa_lista(t_lista *l)
 {
 	t_nodo *sentinel;
 
-	/* Insert beginning sentinel */
 	sentinel = (t_nodo*) malloc (sizeof (t_nodo));
 	if (sentinel == NULL)
 		return 0;
@@ -15,7 +14,6 @@ int inicializa_lista(t_lista *l)
 	sentinel->prev = l->ini;
 	l->ini = sentinel;
 	
-	/* Insert end sentinel */
 	sentinel = (t_nodo*) malloc (sizeof (t_nodo));
 	if (sentinel == NULL)
 		return 0;
@@ -135,10 +133,7 @@ int insere_ordenado_lista(int item, t_lista *l)
 int remove_inicio_lista(int *item, t_lista *l)
 {
 	if (lista_vazia(l))
-	{
-		item = NULL;
 		return 0;
-	}
 
 	t_nodo *p = l->ini->prox;
 
@@ -156,10 +151,7 @@ int remove_inicio_lista(int *item, t_lista *l)
 int remove_fim_lista(int *item, t_lista *l)
 {
 	if (lista_vazia(l))
-	{
-		item = NULL;
 		return 0;
-	}
 	
 	t_nodo *p = l->fim->prev;
 
@@ -174,54 +166,127 @@ int remove_fim_lista(int *item, t_lista *l)
 	return 1;
 }
 
-/*
-  Se o elemento chave existir na lista, o retorna em *item.
-  Retorna 1 se a operação foi bem sucedida e zero caso contrário
-  (elemento não encontrado também retorna zero).
-*/
-int remove_item_lista(int chave, int *item, t_lista *l){return 1;}
+int remove_item_lista(int chave, int *item, t_lista *l)
+{
+	if (lista_vazia(l))
+		return 0;
 
-/*
-  Retorna 1 se o elemento contendo a chave chave existe na lista,
-  caso contrário retorna zero.
-*/
-int pertence_lista(int chave, t_lista *l){return 1;}
+	t_nodo *p = l->ini->prox;
+	while (p->prox != NULL && p->chave != chave)
+		p = p->prox;
 
-/* 
-  Inicializa o ponteiro atual para o primeiro elemento da lista.
-  Retorna 1 se a operação foi bem sucedida e zero caso contrário.
-*/
-int inicializa_atual_inicio(t_lista *l){return 1;}
+	if (p->prox == NULL)
+		return 0;
 
-/* 
-  Inicializa o ponteiro atual para o ultimo elemento da lista.
-  Retorna 1 se a operação foi bem sucedida e zero caso contrário.
-*/
-int inicializa_atual_fim(t_lista *l){return 1;}
+	*item = p->chave;
+	p->prev->prox = p->prox;
+	p->prox->prev = p->prev;
+	free (p);
+
+	return 1;
+}
+
+int pertence_lista(int chave, t_lista *l)
+{
+	if (lista_vazia(l))
+		return 0;
+
+	t_nodo *p = l->ini->prox;
+	while (p->prox != NULL && p->chave != chave)
+		p = p->prox;
+
+	if (p->prox == NULL)
+		return 0;
+
+	return 1;
+}
 
 /* 
-  Faz o ponteiro atual apontar para o próximo nodo da lista l e retorna 
-  este ponteiro. Se atual estiver apontando para o último, isto é, não 
-  tem próximo, retorna NULL.
+	Para poder retornar o ponteiro de atual, foi necessário 
+	alterar o tipo do retorno de void para t_nodo*.
 */
-void incrementa_atual(t_lista *l){}
+t_nodo* inicializa_atual_inicio(t_lista *l)
+{
+	if (lista_vazia(l))
+		return NULL;
+
+	l->atual = l->ini->prox;
+	return l->atual;
+}
 
 /* 
-  Faz o ponteiro atual apontar para o nodo anterior da lista l e retorna 
-  este ponteiro. Se atual estiver apontando para o primeiro, isto é, não 
-  tem anterior, retorna NULL.
+	Para poder retornar o ponteiro de atual, foi necessário 
+	alterar o tipo do retorno de void para t_nodo*.
 */
-void decrementa_atual(t_lista *l){}
+t_nodo* inicializa_atual_fim(t_lista *l)
+{
+	if (lista_vazia(l))
+		return NULL;
+
+	l->atual = l->fim->prev;
+	return l->atual;
+}
 
 /* 
-  Retorna em *item o valor contido na chave apontada pelo ponteiro atual. 
-  Se atual não for válido a função retorna zero senão retorna 1.
+	Para poder retornar o ponteiro de atual, foi necessário 
+	alterar o tipo do retorno de void para t_nodo*.
 */
-int consulta_item_atual(int *item, t_lista *atual){return 1;}
+t_nodo* incrementa_atual(t_lista *l)
+{
+	if (lista_vazia(l) || l->atual == NULL) 
+		return NULL;
+
+	if (l->atual->prox == l->fim)
+		return NULL;
+
+	l->atual = l->atual->prox;
+
+	return l->atual;	
+}
 
 /* 
-  Remove o elemento apontado por atual da lista l e o retorna em *item.
-  Faz o atual apontar para o sucessor do nodo removido.
-  Retorna 1 se houve sucesso e zero caso contrário.
+	Para poder retornar o ponteiro de atual, foi necessário 
+	alterar o tipo do retorno de void para t_nodo*.
 */
-int remove_item_atual(int *item, t_lista *l){return 1;}
+t_nodo* decrementa_atual(t_lista *l)
+{
+	if (lista_vazia(l) || l->atual == NULL) 
+		return NULL;
+
+	if (l->atual->prev == l->ini)
+		return NULL;
+
+	l->atual = l->atual->prev;
+
+	return l->atual;	
+}
+
+int consulta_item_atual(int *item, t_nodo *atual)
+{
+	if (atual == NULL) 
+		return 0;
+
+	*item = atual->chave;
+	return 1;
+}
+
+int remove_item_atual(int *item, t_lista *l)
+{
+	if (l->atual == NULL)
+		return 0;
+
+	t_nodo *p = l->atual;
+	p->prev->prox = p->prox;
+	p->prox->prev = p->prev;
+
+	if (p->prox->prox == NULL)
+		l->atual = p->prev;
+
+	else
+		l->atual = p->prox;
+
+	*item = p->chave;
+	free (p);
+
+	return 1;
+}

lib_lista.h

@@ -93,33 +93,33 @@ int pertence_lista(int chave, t_lista *l);
   Inicializa o ponteiro atual para o primeiro elemento da lista.
   Retorna 1 se a operação foi bem sucedida e zero caso contrário.
 */
-int inicializa_atual_inicio(t_lista *l);
+t_nodo* inicializa_atual_inicio(t_lista *l);
 
 /* 
   Inicializa o ponteiro atual para o ultimo elemento da lista.
   Retorna 1 se a operação foi bem sucedida e zero caso contrário.
 */
-int inicializa_atual_fim(t_lista *l);
+t_nodo* inicializa_atual_fim(t_lista *l);
 
 /*
   Faz o ponteiro atual apontar para o próximo nodo da lista l e retorna 
   este ponteiro. Se atual estiver apontando para o último, isto é, não 
   tem próximo, retorna NULL.
 */
-void incrementa_atual(t_lista *l);
+t_nodo* incrementa_atual(t_lista *l);
 
 /*
   Faz o ponteiro atual apontar para o nodo anterior da lista l e retorna 
   este ponteiro. Se atual estiver apontando para o primeiro, isto é, não 
   tem anterior, retorna NULL.
 */
-void decrementa_atual(t_lista *l);
+t_nodo* decrementa_atual(t_lista *l);
 
 /*
   Retorna em *item o valor contido na chave apontada pelo ponteiro atual. 
   Se atual não for válido a função retorna zero senão retorna 1.
 */
-int consulta_item_atual(int *item, t_lista *atual);
+int consulta_item_atual(int *item, t_nodo *atual);
 
 /*
   Remove o elemento apontado por atual da lista l e o retorna em *item.

main.c

@@ -21,6 +21,7 @@ int main ()
 {
 	t_lista l;
 	int item;
+	t_nodo* atual;
 
 	inicializa_lista(&l);
 	insere_ordenado_lista(7, &l);
@@ -29,9 +30,18 @@ int main ()
 	insere_ordenado_lista(3, &l);
 	insere_ordenado_lista(2, &l);
 	imprime (&l);
-	remove_fim_lista(&item, &l);
-	remove_fim_lista(&item, &l);
+	atual = inicializa_atual_inicio(&l);
+	atual = incrementa_atual(&l);
+	atual = incrementa_atual(&l);
+	atual = incrementa_atual(&l);
+	atual = incrementa_atual(&l);
+	remove_item_atual (&item, &l);
+	printf ("%d\n", item);
 	imprime (&l);
+	atual = decrementa_atual(&l);
+	atual = incrementa_atual(&l);
+	consulta_item_atual (&item, atual);
+	printf ("%d\n", item);
 
 	return 0;
 }