Adição das funções 'insereNaPos', 'removeNaPos' e 'leNaPos', para ins…

…erir, remover e ler na Posição, respectivamente.

Lista.c

@@ -1,3 +1,20 @@
+/********************************************************
+ * TAD Lista -- program to initialize, manipulate and   *
+ *            print Lists.                              *
+ *                                                      *
+ * Author:  LOFFI, Murilo                               *
+ *                                                      *
+ * Purpose:  Learning abstract types of data.           *
+ *                                                      *
+ * Usage:                                               *
+ *      Edit the main.c archive to include fuctions and *
+ *      variables at your desire.                       *
+ ********************************************************/
+
+
+//Lista.c
+
+
 #include "Lista.h"
 #include <stdio.h>
 #include <stdlib.h>
@@ -10,7 +27,7 @@ void inicializa_lista(Lista *p, int t){
 }
 
 int lista_vazia(Lista l){
-	return l.cabeca == NULL; //se o cabeca não aponta pra nenhum elemento, a lista está vazia
+	return l.cabeca == NULL;
 }
 
 /*int insereNoInicio(Lista *p, void *info){
@@ -59,7 +76,7 @@ void mostra_lista(Lista l, void(*mostra)(void*)){
 		printf("Lista vazia!\n");
 	else{ 
 		Elemento *p = l.cabeca;
-		while(p!=NULL){
+		while(p != NULL){
 		mostra(p->info);
 		p = p->proximo;
 		}
@@ -97,23 +114,23 @@ int insereNoFim(Lista *l, void *info){
 }
 
 int removeDoFim(Lista *l, void *info){
-	if(lista_vazia(*l))  //verifica se a lista já está vazia
+	if(lista_vazia(*l))
 		return ERRO_LISTA_VAZIA;
-	if(l->cabeca->proximo == NULL) 		//Para esta codição há somente 1 elemento na lista.
-		return removeDoInicio(l,info); 		//Novamente reutilizando código.
-	Elemento *p = l->cabeca;     
-	while(p->proximo->proximo != NULL){ //'p' percorre a lista até seu penúltimo elemento
+	if(l->cabeca->proximo == NULL) //Somente 1 elemento.
+		return removeDoInicio(l,info); //Novamente reutilizando código.
+	Elemento *p = l->cabeca;
+	while(p->proximo->proximo != NULL){ 
 		p = p->proximo;	
-			/* Como o último elemento não tem ponteiro apontando para o elemento antecessor,
-			por isso a lista é percorrida apenas até o penúltimo!*/
+		/* Como o último elemento não tem ponteiro apontando para o elemento,
+		por isso a lista é percorrida apenas até o penúltimo*/
 	}
-	Elemento *x = p->proximo; //Novo elemento x recebe o último. Este será o elemento desalocado.
-	memcpy(info, x->info, l->tamInfo); //copia informação para o ponteiro info, que ficará disponível
-	free(x->info); //desaloca a informação do último elemento.
-	free(x); //desaloca o último elemento.
-	p->proximo = NULL;
-		/*Penúltimo elemento passa a apontar para NULL sem que seja necessário
-		percorrer toda a lista novamente*/
+	Elemento *x = p->proximo; //Este será o elemento desalocado
+	memcpy(info, x->info, l->tamInfo);
+	free(x->info);
+	free(x);
+	p->proximo = NULL; 
+	/*Penúltimo elemento passa a apontar para NULL sem que seja necessário
+	percorrer toda a lista novamente*/
 	return 1; //sucesso
 }
 
@@ -126,21 +143,80 @@ void desaloca_lista(Lista *l){
 		p=proximo;
 	}
 	l->cabeca = NULL;
-}
-
-//MÉTODO N.1
+} //MÉTODO N.1
 
 /* MÉTODO N.2:
 Podemos utilizar abstração e resolver o mesmo problema com um
-código mais elegante */
+código mais elegante
 
-/*
-void desaloca_lista_v2(Lista *l){ 
-	void *aux = malloc(l->tamInfo); //cria-se um ponteiro que recebe
+void desaloca_lista_v2(Lista *l){
+	void *aux = malloc(l->tamInfo);
 	while(!lista_vazia(*l)){
 		removeDoInicio(l,aux);
 	}
 	free(aux);
 }
 */
-
+
+int insereNaPos(Lista *l, void *info, int pos){
+	if (pos < 0)
+		return ERRO_POS_INVALIDA; //Nao é possível posições negativas
+	if (pos == 0)
+		return insereNoInicio(l, info); //chamamento de função == reaproveitando código
+	if (lista_vazia(*l)) 
+		return ERRO_POS_INVALIDA; //caso a posição > 0
+	Elemento *p = l->cabeca;
+	int cont = 0;
+	while(cont < pos-1 && p->proximo != NULL ){
+		p = p->proximo;
+		cont++;
+	}
+	if(cont != pos-1)
+		return ERRO_POS_INVALIDA;
+	Elemento *novo = aloca_ele(info, l->tamInfo);
+	if(novo == NULL)
+		return 0; //Erro na alocação
+	novo->proximo = p->proximo; 	//atenção com a ordem neste fim,
+	p->proximo = novo; 		//caso 'p->proximo = novo'
+	return 1; //sucesso
+}
+
+int removeDaPos(Lista *l, void *info, int pos){
+	if(lista_vazia(*l))
+		return ERRO_LISTA_VAZIA;
+	if(pos<0)
+		return ERRO_POS_INVALIDA;
+	if(pos==0)
+		return removeDoInicio(l,info);
+	Elemento *p = l->cabeca;
+	int cont = 0;
+	while(cont < pos-1 && p->proximo != NULL){
+		p=p->proximo;
+		cont++;
+	}
+	if(p->proximo == NULL)
+		return ERRO_POS_INVALIDA;
+	Elemento *x = p->proximo;
+	p->proximo = x->proximo;
+	memcpy(info, x->info, l->tamInfo);
+	free(x->info);
+	free(x);
+	return 1; //sucesso
+}
+
+int leNaPos(Lista *l, void *info, int pos){
+	if(lista_vazia(*l))
+		return ERRO_LISTA_VAZIA;
+	if(pos<0)
+		return ERRO_POS_INVALIDA;
+	Elemento *p = l->cabeca;
+	int cont = 0;
+	while(cont < pos && p->proximo != NULL){
+		p=p->proximo;
+		cont++;
+	}
+	if(cont != pos)
+		return ERRO_POS_INVALIDA;
+	memcpy(info, p->info, l->tamInfo); //para a função modificaNaPos, basta inverter os 2 primerios parâmetros.
+	return 1; //sucesso
+}

Lista.h

@@ -1,14 +1,30 @@
-#define ERRO_LISTA_VAZIA -1 //####POR QUE MESMO O "DEFINE ERRO_LISTA_VAZIA" é utilizado?
+ /********************************************************           
+  * TAD Lista -- program to initialize, manipulate and   *
+  *            print Lists.                              *
+  *                                                      *   
+  * Author:  LOFFI, Murilo                               *   
+  *                                                      *   
+  * Purpose:  Learning abstract types of data.           *   
+  *                                                      *   
+  * Usage:                                               *   
+  *      Edit the main.c archive to include fuctions and *
+  *      variables at your desire.                       *   
+  ********************************************************/
+
+
+//Lista.h
+
+
+#define ERRO_LISTA_VAZIA -1
+#define ERRO_POS_INVALIDA -2
 #include <stdio.h>
 
-typedef struct ele{ 
-		/*aqui a gente dá nome "ele" à estrutura para que ela possa se auto 
-		referenciar na declaração do ponteiro proximo*/ 
+typedef struct ele{ //aqui a gente dá nome "ele" à estrutura para que ela possa se auto referenciar na declaração do ponteiro proximo 
 	void *info;
 	struct ele *proximo;
 }Elemento;
 
-typedef struct{ //
+typedef struct{
 	Elemento *cabeca;
 	int tamInfo;
 }Lista;
@@ -23,4 +39,7 @@ int removeDoInicio(Lista *l, void *info);
 int insereNoFim(Lista *l, void *info);
 int removeDoFim(Lista *l, void *info);
 void desaloca_lista(Lista *l);
-//void desaloca_lista_v2(Lista *l);
+void desaloca_lista_v2(Lista *l);
+int insereNaPos(Lista *l, void *info, int pos);
+int removeDaPos(Lista *l, void *info, int pos);
+int leNaPos(Lista *l, void *info, int pos);

main.c

@@ -1,9 +1,13 @@
+//main.c
+
 #include "Lista.h"
 
 void mostra_float(void *p){
 	printf("%.1f\n", *(float *)p);
 }
 
+
+
 int main(){
 	Lista l1;
 	inicializa_lista(&l1, sizeof(float));
@@ -35,6 +39,19 @@ int main(){
 	printf("\nremoveu do fim:\n%f \n\n",y);
 	printf("\nlista atual:\n");
 	mostra_lista(l1,mostra_float);
-} 
-
-//ADICIONANDO AQUI SÓ UNS COMENTÁRIOS A FIM DE FAZER EXPERIMENTOS COM O GITHUB
+	printf("\n\nInserido na posição 3:\n");
+	x=7;
+	insereNaPos(&l1, &x, 3);
+	mostra_lista(l1,mostra_float);
+	printf("\n\nInseridos na posição 3:\n");
+	x=4.7;
+	insereNaPos(&l1, &x, 3);
+	x=5.1;
+	insereNaPos(&l1, &x, 3);
+	mostra_lista(l1,mostra_float);
+	removeDaPos(&l1, &x, 1);
+	printf("\nRemovida na posicao 1: %.1f\n", x);
+	mostra_lista(l1,mostra_float);
+	leNaPos(&l1, &y, 3);
+	printf("\n\nLeitura na posicao 3: %.1f\n", y);
+}