fork download

copy

#include <stdio.h>
#include <stdlib.h>
 
/* Questão 2
 
Crie um TAD Lista (genérica), com as funções a seguir.
 
criarLista() Cria a lista vazia, alocando a memória necessária.
inserir(lista, elem) Insere um elemento ao final da lista.
inserirPos(lista, pos, elem) Insere um elemento na posição informada.
remover(lista, pos) Remove o elemento da posição informada (lembre-se de liberar a memória).
obter(lista, pos) Retorna o elemento localizado na posição informada.
tamanho(lista) Retorna a quantidade de elementos da lista.
destruirLista(lista) Destrói toda a lista (lembre-se de liberar a memória).
 
*/
 
 
 
/* Minhas estruturas */
typedef struct lista 
{
	struct no *prim;
	struct no *ult;
	int tam;
}lista;
 
 
typedef struct no
{
	struct no *prox;
	void *elem;
}no;
 
typedef struct pessoa
{
	char nome;
	int idade;
}pessoa;
 
 
/* minhas funções */
lista *criaLista()
{
	lista *lst = malloc(sizeof(lista));
	lst -> prim = NULL;
	lst -> ult = NULL;
	lst -> tam = 0;
	return lst;
}
 
 
no *criaNo(void *n)
{
	no *no = malloc(sizeof(no));
	no -> prox = NULL;
	no -> valor = n;
	return no;
}
 
 
pessoa *criaPessoa(char nome, int idade)
{
	pessoa *pessoa = malloc(sizeof(pessoa));
 
	pessoa -> nome = nome;
	pessoa -> idade = idade;
 
	return pessoa;
}
 
/* falta essa daqui */
lista *inserir(lista *lst, void )
{
	no *novoNo = criaNo(val);
 
	if (lst -> prim == NULL)
		lst -> prim = novoNo;
	else
		lst -> ult -> prox = novoNo;
 
	lst -> ult = novoNo;
	lst -> tam++;	
	return lst;
}
 
/* falta essa daqui */
lista *inserirPos(lista *lst, int pos, int val) 
{
	no *novoNo = criaNo(val);
	no *noAux;
	int cont = 1;
 
	if (pos == 0)
	{
		novoNo -> prox = lst -> prim;
		lst -> prim = novoNo;
	}	
 
	else if ((pos > 0) && (pos <= lst -> tam - 1))
	{
		noAux = lst -> prim;
		while (cont < pos)
		{
			noAux = noAux -> prox;
			cont++;
		}
		novoNo -> prox = noAux -> prox;
		noAux -> prox = novoNo;
	}
 
	else
	{
		lst -> ult -> prox = novoNo;
		lst -> ult = novoNo;
	}
 
	lst -> tam++;
	return lst;
}
 
/* falta essa daqui */
lista *remover(lista *lst, int pos) 
{
	no *auxNo, *auxRem;
	int cont;
 
	if (pos == 0)
	{
		auxNo = lst -> prim -> prox;
		free(lst -> prim);
		lst -> prim = auxNo;
	}
	else if ((pos > 0) && (pos < lst -> tam))
	{
 
		auxNo = lst -> prim;
		cont = 1;
		while (cont < pos)
		{
			auxNo = auxNo -> prox;
			cont++;
		}
		auxRem = auxNo -> prox;
		auxNo -> prox = auxNo -> prox -> prox;
		free(auxRem);
 
	}
	else
	{
		auxNo = lst -> prim;
		cont = 1;
		while (cont < pos)
		{
			auxNo = auxNo -> prox;
			cont++;
		}
		free (lst -> ult);
		lst -> ult = auxNo;
	}
 
	lst -> tam--;
	return lst;
}
 
 
/* falta essa daqui */
int obter(lista *lst, int pos)
{
	int i = 0;
	no *noAux = lst -> prim;
 
	if (pos == 0)
	{
		return lst -> prim -> valor;
	}	
	else if ((pos > 0) && (pos < lst->tam - 1))
	{
		while(i < pos)
		{
			noAux = noAux -> prox;
			i++;
		}
		return noAux -> valor;
	}
	else
	{
		return lst -> ult -> valor;
	}
}
 
 
int tamanho(lista *lst)
{
	return lst -> tam;
} 
 
 
 
void destruirLista(lista *lst)
{
	no *auxNo;
 
	while (lst -> prim != NULL)
	{
		auxNo = lst -> prim;
		lst -> prim = auxNo -> prox;
		free(auxNo);
	}
 
	free(lst);
}
 
 
int main()
{
	/* criando pessoas */
	pessoa *p1 = criaPessoa("anne", 24);
	pessoa *p2 = criaPessoa("joão", 21);
	pessoa *p2 = criaPessoa("maria", 20);
 
 
	/* testa função criarLista */
	lista *lst = criaLista();
 
	/* testa função inserir */
	inserir(lst, p1);
	inserir(lst, p2);
 
 
	/* testa função inserirPos */
	inserirPos(lst, 2, p3);
 
	/* testa função imprimir */
	imprimir(lst);
 
	/* testa função tamanho */
	printf("Teste da função tamanho(): %d\n", tamanho(lst));
 
	/* testa função obter */
	printf("Teste da função obter(): %d\n", obter(lst, 2));
 
 
	/* testa função remover 
	remover(lst, 0);	
	imprimir(lst);*/
 
 
	/* testa função destruirLista 
	destruirLista(lst);*/
 
	return 0;
}

prog.c: In function ‘criaNo’:
prog.c:57:5: error: ‘no {aka struct no}’ has no member named ‘valor’
  no -> valor = n;
     ^~
prog.c: At top level:
prog.c:73:1: error: ‘void’ must be the only parameter
 lista *inserir(lista *lst, void )
 ^~~~~
prog.c: In function ‘inserir’:
prog.c:75:22: error: ‘val’ undeclared (first use in this function)
  no *novoNo = criaNo(val);
                      ^~~
prog.c:75:22: note: each undeclared identifier is reported only once for each function it appears in
prog.c: In function ‘inserirPos’:
prog.c:90:22: warning: passing argument 1 of ‘criaNo’ makes pointer from integer without a cast [-Wint-conversion]
  no *novoNo = criaNo(val);
                      ^~~
prog.c:53:5: note: expected ‘void *’ but argument is of type ‘int’
 no *criaNo(void *n)
     ^~~~~~
prog.c: In function ‘obter’:
prog.c:175:22: error: ‘struct no’ has no member named ‘valor’
   return lst -> prim -> valor;
                      ^~
prog.c:184:16: error: ‘no {aka struct no}’ has no member named ‘valor’
   return noAux -> valor;
                ^~
prog.c:188:21: error: ‘struct no’ has no member named ‘valor’
   return lst -> ult -> valor;
                     ^~
prog.c: In function ‘main’:
prog.c:218:26: warning: passing argument 1 of ‘criaPessoa’ makes integer from pointer without a cast [-Wint-conversion]
  pessoa *p1 = criaPessoa("anne", 24);
                          ^~~~~~
prog.c:62:9: note: expected ‘char’ but argument is of type ‘char *’
 pessoa *criaPessoa(char nome, int idade)
         ^~~~~~~~~~
prog.c:219:26: warning: passing argument 1 of ‘criaPessoa’ makes integer from pointer without a cast [-Wint-conversion]
  pessoa *p2 = criaPessoa("joão", 21);
                          ^~~~~~~
prog.c:62:9: note: expected ‘char’ but argument is of type ‘char *’
 pessoa *criaPessoa(char nome, int idade)
         ^~~~~~~~~~
prog.c:220:10: error: redefinition of ‘p2’
  pessoa *p2 = criaPessoa("maria", 20);
          ^~
prog.c:219:10: note: previous definition of ‘p2’ was here
  pessoa *p2 = criaPessoa("joão", 21);
          ^~
prog.c:220:26: warning: passing argument 1 of ‘criaPessoa’ makes integer from pointer without a cast [-Wint-conversion]
  pessoa *p2 = criaPessoa("maria", 20);
                          ^~~~~~~
prog.c:62:9: note: expected ‘char’ but argument is of type ‘char *’
 pessoa *criaPessoa(char nome, int idade)
         ^~~~~~~~~~
prog.c:227:2: error: too many arguments to function ‘inserir’
  inserir(lst, p1);
  ^~~~~~~
prog.c:73:8: note: declared here
 lista *inserir(lista *lst, void )
        ^~~~~~~
prog.c:228:2: error: too many arguments to function ‘inserir’
  inserir(lst, p2);
  ^~~~~~~
prog.c:73:8: note: declared here
 lista *inserir(lista *lst, void )
        ^~~~~~~
prog.c:232:21: error: ‘p3’ undeclared (first use in this function)
  inserirPos(lst, 2, p3);
                     ^~
prog.c:235:2: warning: implicit declaration of function ‘imprimir’ [-Wimplicit-function-declaration]
  imprimir(lst);
  ^~~~~~~~
prog.c: In function ‘obter’:
prog.c:190:1: warning: control reaches end of non-void function [-Wreturn-type]
 }
 ^

Standard output is empty