jcgs98

void decimalParaBinario(int i) {
  if (i > 1) {
    decimalParaBinario(i / 2);
    if (i) printf("%d", i % 2);
  }
  if ((i == 1) || (!i))
    printf("%d", i);
}

void remRepListaOrd(TLista *L2,TLista *U2)
{
    TLista L=*L2, U=*U2;
    
    if ((!L)||(!L->prox)) return;
    
    remover (&L->prox, &U,L->valor);
    
    remRepListaOrd(&L->prox,&U);
}

agora, Comunista.RJ disse:

void remRepListaOrd(TLista *L2,TLista *U2)
{
    TLista L=*L2, U=*U2;
    
    if ((!L)||(!L->prox)) return;
    
    remover (&L->prox, &U,L->valor);
    
    remRepListaOrd(&L->prox,&U);
}

 

uso a função de remover a partir do próximo da lista.

@devair1010 Não deve ter rodado por causa dessa forma de "escrever":

(*U)?novo->ant=*U,(*U)->prox=novo,*U=novo:*L = novo;

Tenta mudar.

Por exemplo,

(*U)?novo->ant=*U,(*U)->prox=novo,*U=novo:*L = novo;

é igual a:

if (*U) { novo->ant=*U; (*U)->prox=novo; *U=novo; }

else

*L = novo;

#include <stdio.h>
#include <stdlib.h>

typedef struct No
{
   int valor;
   struct No *prox, *ant;
} TNo;

typedef TNo* TLista;

int inserir (TLista *L, TLista *U, int num);
int remover (TLista *L, TLista *U,int numero);
int alterar (TLista L, int velho, int novo);
TLista pesquisar (TLista L, int num);
void exibir (TLista L);
void exibirAoContrario (TLista U);
void clonar (TLista *L, TLista L2);
int inserirNaPosicao (TLista *L, TLista *U, int posicao, int numero);
int menu (TLista L, TLista L2);
int tamanho (TLista L);
void insereFim(TLista *L, TLista *U, int numero);
void botarCrescente(TLista *L);
void inverterLista (TLista *L,TLista *U);
float media(TLista L2);
int pesquisaMaior(TLista L2);
int pesquisaMenor(TLista L2);
float somaDosElementos(TLista L2);
void remRepListaOrd(TLista *L, TLista *U);


int main ()
{
	TLista L=NULL, L2=NULL, U=NULL, pos;
	
	int num1, num2, op;
	
	do
	{
		system ("cls");
      	op = menu (L, L2);
      
      	switch (op)
      	{
//INSERIR
			case 1: printf ("Entre com o número: ");
                    scanf ("%d", &num1);					
					(inserir (&L, &U, num1))?printf ("Inserção realizada!\n"):printf ("ERRO: Inserção não realizada!\n");
                 	break;
//REMOVER
         	case 2: printf ("Entre com o número a ser removido: ");
					scanf ("%d", &num1);                 	
					printf ((!remover (&L, &U, num1))?"ERRO: Remoção não realizada!\n":"Remoção realizada %i vezes!\n", remover (&L, &U, num1));
                 	break;
//ALTERAR
         	case 3: printf ("Entre com o número a ser alterado: ");
                 	scanf ("%d", &num1);                 
                 	printf ("Entre com o novo número: ");
                 	scanf ("%d", &num2);                 
                 	printf ((alterar (L, num1, num2))?"Alteração realizada!\n":"ERRO: Alteração não realizada!\n");
                 	break;
//PESQUISAR
         	case 4: printf ("Entre com o número a ser pesquisado: ");
                 	scanf ("%d", &num1);					               
                 	printf ((pesquisar (L, num1))?"O número foi encontrado na lista!\n":"ERRO: O número não se encontra na lista!\n");
                 	break;
//EXIBE NORMAL
         	case 5: (!L)?printf("Lista vazia!\n"):printf("Lista: "),exibir (L),printf("\n");
					break;			
//EXIBE INVERTIDO
         	case 6: (!U)?printf("Lista vazia!\n"):printf("Lista: "),exibirAoContrario (U),printf("\n");
					break;
//CLONAR			
			case 7: clonar (&L2,L);					
					break;										
//INSERE NA POSIÇÃO
         	case 8: printf ("Entre com o número a ser inserido: ");
                 	scanf ("%d", &num1);                 	
					printf ("Entre com o posicao onde número >>%i<< vai ser inserido: ", num1);
                 	scanf ("%d", &num2);                 	
					printf ((inserirNaPosicao (&L, &U, num2, num1))?"Insercao realizada!\n":"ERRO: Inserção não realizada!\n");
                 	break;
//INSERE NO FIM                 	
            case 9:	printf ("Entre com o número a ser inserido: ");
                 	scanf ("%d", &num1);
					insereFim(&L, &U, num1);
					break;
//ORDENA CRESCENTE					
			case 10:printf((!L)?"Lista vazia!\n":0),botarCrescente(&L);
					break;					
//remover repeticao					
			case 11:remRepListaOrd(&L,&U);
					break;					
//INVERTER
			case 12:inverterLista (&L,&U);
			        break;
//fim
            case 0:	printf ("Fim do programa!\n");
                 	break;
//erro
         	default:printf ("Opção inválida!\nTente novamente!\n");
      }
      system ("pause");
   }
   while (op != 0);
}

int menu (TLista L, TLista L2)
{
	int opcao;
	system	("cls");
	printf	("\nTamanho da Lista: %i\n\n",tamanho (L));
	printf	("Lista: ");exibir (L);
	printf	("|\n");
	printf	("Clone: ");exibir (L2);
	printf	("|\n\n");
	printf	("Menor elemento da lista......: %i. \n", pesquisaMenor(L));
	printf	("Maior elemento da lista......: %i. \n", pesquisaMaior(L));	
	printf	("Media dos elementos da lista.: %.2f. \n\n", media(L));   
   	printf	("Menu de opções:\n\n");
   	printf	("( 1)\tInserir\n( 2)\tRemover\n( 3)\tAlterar\n");
   	printf	("( 4)\tPesquisar\n( 5)\tExibir na Ordem Natural\n");
   	printf	("( 6)\tExibir na Ordem Inversa\n( 7)\tClonar\n");   	
   	printf	("( 8)\tInserir na Posicao\n( 9)\tInsere no Fim\n(10)\tOrdenar Lista\n");   	
   	printf	("(11)\tRemove Repeticoes da lista;
   	printf	("(12)\tInverter Lista\n(13)\tComparar Listas(*FAZER)\n( 0)\tSair\n\n");
   	printf	("Entre Com a Opcao: ");
   	scanf	("%d", &opcao);   
   	return opcao;
}

int inserir (TLista *L, TLista *U, int num)
{
	TLista aux = (TLista) malloc (sizeof(TNo));
   
   	if (!aux)
   	{
    	return 0;
   	}
   	else
   	{
   		aux->valor = num;

      	aux->prox = *L;

      	aux->ant = NULL;

	  	if (*L)
      	{
         	(*L)->ant = aux;
      	}

      	else
      	{
      		*U = aux;
	  	}
      
      	*L = aux;
      
      	return 1;
   	}
}

int remover (TLista *L, TLista *U,int numero)
{
	TLista aux1, aux2, aux3;
	
	int cont;
	
	while ((*L) && ((*L)->valor == numero))
	{
		aux2 = (*L)->ant;
	
		aux1 = (*L)->prox;
	
		free (*L);
	
		cont++;
	
		*L = aux1;
		
		(*L)?(*L)->ant = aux2:0;
	}
	
	if (!*L)
	{
		*U=NULL;
	}
	else
	{
		aux2 = *L;

		aux1 = (*L)->prox;
		
		while (aux1)
		{
			if (aux1->valor == numero)
			{
				aux3 = aux2;
				
				(*U==aux1)?*U=aux3:0;
								
				(aux1->prox)?aux1->prox->ant=aux2:0;
				
				aux2->prox = aux1->prox;
				
				free (aux1);
				
				cont++;
				
				aux1 = aux2->prox;
			}
			else
			{
				aux2 = aux1;
				
				aux1 = aux1->prox;
			}			
		}
	}

	return cont;
}


int alterar (TLista L, int velho, int novo)
{
	TLista aux = L;
	
	int c = 0;
   
   	while (aux)
   	{
    	if (aux->valor == velho)
      	{
        	aux->valor = novo;
			
			c++;
      	}
      	aux = aux->prox;
   	}

    return c;
}

TLista pesquisar (TLista L, int num)
{
	if (L==NULL) return NULL;
	
	if (L->valor==num) return L;
	
	pesquisar (L->prox, num);
}

void exibir (TLista L2)
{
	TLista L=L2;
	
	if(L)
	{
		printf ("%d ", L->valor);
		
		exibir (L->prox);		
	}
}

void exibirAoContrario (TLista U2)
{
	TLista U=U2;
	
	if(U)
	{
		printf ("%d ", U->valor);
		
		exibirAoContrario (U->ant);
	}
}

void clonar (TLista *L, TLista L2)
{	
	TLista L3=L2;
	
	TLista U;	
	
	while(L3)
	{
		insereFim(&*L, &U, L3->valor);	
		
		L3=L3->prox;
	}
}

int inserirNaPosicao (TLista *L, TLista *U, int posicao, int num)
{	
	
	int t=tamanho (*L), con=0;
	
	TLista aux2=*L, aux, novo;
		
	if(!posicao||posicao>t+1)
	{
		return 0;
	}
	
	if(posicao==1)
	{
		inserir (&*L, &*U, num);
		
		return 1;
	}
	
	if(posicao==t+1)
	{
		insereFim(&*L, &*U, num);
		
		return 1;
	}
	
	posicao=posicao-1;
	
	novo=(TLista) malloc (sizeof(TNo));
	
	novo->valor=num;
		
    while (con<posicao-1)
    {
    	aux2=aux2->prox;
    	
        con++;
    }

	aux=aux2->prox;
	
	novo->ant=aux2;
	
	aux2->prox=novo;
	
	aux->ant=novo;
	
	novo->prox=aux;

	return 1;
}

void insereFim(TLista *L, TLista *U, int numero)
{
	TLista novo=(TLista) malloc(sizeof(TNo));	
	
	novo->prox=NULL;
	
	novo->valor=numero;
	
	(*U)?novo->ant=*U,(*U)->prox=novo,*U=novo:*L = novo;
  	
	*U = novo;
}

void botarCrescente(TLista *L)
{
	TLista genesis = *L, ordenada;

	int gV,oV;
   	
	while(genesis)
	{
       	ordenada=genesis->prox;
			
		while(ordenada)
		{
           	if(genesis->valor > ordenada->valor)
			{
               	gV=genesis->valor;
               	oV=ordenada->valor;
               	ordenada->valor=gV;
               	genesis->valor=oV;
			}
			ordenada = ordenada->prox;
		}
		genesis=genesis->prox;
	}
}

int tamanho (TLista L1)
{
	TLista L=L1;
	
	if (!L) return 0;	
	
	return (1+tamanho (L->prox));
}

void inverterLista (TLista *L,TLista *U)
{
	TLista aux=*L;
	
	*L=NULL;
	
	*U=NULL;
	
	while(aux)
	{
		inserir (&*L, &*U, aux->valor);
		
		aux=aux->prox;
	}	
}

int pesquisaMaior(TLista L2)
{
  	TLista L=L2;
  	
	if (!L) return 0;
  	
	int maior = pesquisaMaior(L->prox);

	if (L->valor > maior) return L->valor;
	
	return maior;
}

int pesquisaMenor(TLista L2)
{
	TLista L=L2;
	
	if (!L) return 0;
	
	int menor=L->valor;

	while(L)
	{	
		if(L->valor < menor)
		{
			menor = L->valor;
		}
		L = L->prox;
	}
	return menor;
}

float media(TLista L2)
{	
	if (L2) return (somaDosElementos(L2)/tamanho(L2));
	
	return 0;
}

float somaDosElementos(TLista L2)
{
	TLista L=L2;
	
	if (!L) return 0;
	
	return L->valor + somaDosElementos(L->prox);	
}

void remRepListaOrd(TLista *L2,TLista *U2)
{
    TLista L=*L2, U=*U2;
    
    if ((!L)||(!L->prox)) return;
    
    remover (&L->prox, &U,L->valor);
    
    remRepListaOrd(&L->prox,&U);
}

FIZ A 11

#include <stdio.h>
#include <stdlib.h>

typedef struct No{int valor;struct No *prox, *ant;}TNo;typedef TNo* TLista;

int inserir (TLista *L, TLista *U, int num);
int remover (TLista *L, TLista *U,int numero);
int alterar (TLista L, int velho, int novo);
TLista pesquisar (TLista L, int num);
void exibir (TLista L);
void exibirAoContrario (TLista U);
void clonar (TLista *L, TLista L2);
int inserirNaPosicao (TLista *L, TLista *U, int posicao, int numero);
int menu (TLista L, TLista L2);
int tamanho (TLista L);
void insereFim(TLista *L, TLista *U, int numero);
void botarCrescente(TLista *L);
void inverterLista (TLista *L,TLista *U);
float media(TLista L2);
int pesquisaMaior(TLista L2);
int pesquisaMenor(TLista L2);
float somaDosElementos(TLista L2);
void remRepListaOrd(TLista L);

int main ()
{
TLista L=NULL, L2=NULL, U=NULL, pos;
int num1, num2, op;
do	{
		system ("cls");
      	op = menu (L, L2);
  
		switch (op)	{
//INSERIR
case 1: printf ("Entre com o número: ");
		scanf ("%d", &num1);
		(inserir (&L, &U, num1))?printf ("Inserção realizada!\n"):printf ("ERRO: Inserção não realizada!\n");
		break;
//REMOVER
case 2: printf ("Entre com o número a ser removido: ");
		scanf ("%d", &num1);
		printf ((!remover (&L, &U, num1))?"ERRO: Remoção não realizada!\n":"Remoção realizada %i vezes!\n", remover (&L, &U, num1));
		break;
//ALTERAR
case 3: printf ("Entre com o número a ser alterado: ");
		scanf ("%d", &num1);
        printf ("Entre com o novo número: ");
        scanf ("%d", &num2);
        printf ((alterar (L, num1, num2))?"Alteração realizada!\n":"ERRO: Alteração não realizada!\n");
        break;
//PESQUISAR
case 4: printf ("Entre com o número a ser pesquisado: ");
		scanf ("%d", &num1);      
		printf ((pesquisar (L, num1))?"O número foi encontrado na lista!\n":"ERRO: O número não se encontra na lista!\n");
		break;
//EXIBE NORMAL
case 5: (!L)?printf("Lista vazia!\n"):printf("Lista: "),exibir (L),printf("\n");
		break;			
//EXIBE INVERTIDO
case 6: (!U)?printf("Lista vazia!\n"):printf("Lista: "),exibirAoContrario (U),printf("\n");
		break;
//CLONAR			
case 7:	clonar (&L2,L);					
		break;										
//INSERE NA POSIÇÃO
case 8:	printf ("Entre com o número a ser inserido: ");
        scanf ("%d", &num1);                 	
		printf ("Entre com o posicao onde número >>%i<< vai ser inserido: ", num1);
        scanf ("%d", &num2);                 	
		printf ((inserirNaPosicao (&L, &U, num2, num1))?"Insercao realizada!\n":"ERRO: Inserção não realizada!\n");
        break;
//INSERE NO FIM                 	
case 9:	printf ("Entre com o número a ser inserido: ");
        scanf ("%d", &num1);
		insereFim(&L, &U, num1);
		break;
//ORDENA CRESCENTE					
case 10:printf((!L)?"Lista vazia!\n":0),botarCrescente(&L);
		break;					
//remover repeticao					
case 11:remRepListaOrd(L);
		break;					
//INVERTER
case 12:inverterLista (&L,&U);
		break;
//fim
case 0:	printf ("Fim do programa!\n");
		break;
//erro
		default:printf ("Opção inválida!\nTente novamente!\n");
	}
		system ("pause");
	}
		while (op != 0);
}

int menu (TLista L, TLista L2)
{
	int opcao;
	system	("cls");
	printf	("\nTamanho da Lista: %i\n\n",tamanho (L));
	printf	("Lista: ");exibir (L);
	printf	("|\n");
	printf	("Clone: ");exibir (L2);
	printf	("|\n\n");
	printf	("Menor elemento da lista......: %i. \n", pesquisaMenor(L));
	printf	("Maior elemento da lista......: %i. \n", pesquisaMaior(L));
	printf	("Media dos elementos da lista.: %.2f. \n\n", media(L));
   	printf	("Menu de opções:\n\n");
   	printf	("(1)\tInserir\n(2)\tRemover\n(3)\tAlterar\n");
   	printf	("(4)\tPesquisar\n(5)\tExibir na Ordem Natural\n");
   	printf	("(6)\tExibir na Ordem Inversa\n(7)\tClonar\n");
   	printf	("(8)\tInserir na Posicao\n");
   	printf	("(9)\tInsere no Fim\n(10)\tOrdenar Lista\n"); 	
   	printf	("(11)\tRemove Repeticoes da lista\n(*INCOMPLETA - so remove depois de ordenar)");
   	printf	("(12)\tInverter Lista\n");
   	printf	("(13)\tComparar Listas\n(*FAZER)");
	printf	("(0)\tSair\n\n");
   	printf	("Entre Com a Opcao: ");
   	scanf	("%d", &opcao);
   	return opcao;
}

int inserir (TLista *L, TLista *U, int num)
{
	TLista aux = (TLista) malloc (sizeof(TNo));   
   	if (!aux)	{return 0;}
   	else
   	{
		aux->valor = num;
		aux->prox = *L;
		aux->ant = NULL;

		if (*L)
		{
			(*L)->ant = aux;
      	}

      	else
      	{
      		*U = aux;
	  	}
      
      	*L = aux;
      
		return 1;
	}
}

int remover (TLista *L, TLista *U,int numero)
{
	TLista aux1, aux2, aux3;	
	int cont;	
	while ((*L) && ((*L)->valor == numero))
	{
		aux2 = (*L)->ant;	
		aux1 = (*L)->prox;	
		free (*L);	
		cont++;	
		*L = aux1;		
		(*L)?(*L)->ant = aux2:0;
	}
	
	if (!*L)
	{
		*U=NULL;
	}
	else
	{
		aux2 = *L;
		aux1 = (*L)->prox;		
		while (aux1)
		{
			if (aux1->valor == numero)
			{
				aux3 = aux2;				
				(*U==aux1)?*U=aux3:0;								
				(aux1->prox)?aux1->prox->ant=aux2:0;				
				aux2->prox = aux1->prox;				
				free (aux1);				
				cont++;				
				aux1 = aux2->prox;
			}
			else
			{
				aux2 = aux1;				
				aux1 = aux1->prox;
			}
		}
	}
	return cont;
}

int alterar (TLista L, int velho, int novo)
{
	TLista aux = L;	
	int c = 0;   
   	while (aux)
   	{
    	if (aux->valor == velho)
      	{
        	aux->valor = novo;			
			c++;
      	}
      	aux = aux->prox;
   	}
    return c;
}

TLista pesquisar (TLista L, int num)
{
	if (L==NULL) return NULL;	
	if (L->valor==num) return L;	
	pesquisar (L->prox, num);
}

void exibir (TLista L2)
{
	TLista L=L2;	
	if(L)
	{
		printf ("%d ", L->valor);		
		exibir (L->prox);
	}
}

void exibirAoContrario (TLista U2)
{
	TLista U=U2;	
	if(U)
	{
		printf ("%d ", U->valor);
		exibirAoContrario (U->ant);
	}
}

void clonar (TLista *L, TLista L2)
{	
	TLista L3=L2;
	TLista U;	
	while(L3)
	{
		insereFim(&*L, &U, L3->valor);	
		L3=L3->prox;
	}
}

int inserirNaPosicao (TLista *L, TLista *U, int posicao, int num)
{	
	int t=tamanho (*L), con=0;
	TLista aux2=*L, aux, novo;
	
  	if(!posicao||posicao>t+1)
	{
		return 0;
	}
	
  	if(posicao==1)
	{
		inserir (&*L, &*U, num);
		return 1;
	}

	if(posicao==t+1)
	{
		insereFim(&*L, &*U, num);
		return 1;
	}
	
	posicao=posicao-1;	
	novo=(TLista) malloc (sizeof(TNo));	
	novo->valor=num;
  
    while (con<posicao-1)
    {
    	aux2=aux2->prox;
        con++;
    }

	aux=aux2->prox;	
	novo->ant=aux2;	
	aux2->prox=novo;	
	aux->ant=novo;	
	novo->prox=aux;
  
	return 1;
}

void insereFim(TLista *L, TLista *U, int numero)
{
	TLista novo=(TLista) malloc(sizeof(TNo));
	novo->prox=NULL;	
	novo->valor=numero;
	
	(*U)?novo->ant=*U,(*U)->prox=novo,*U=novo:*L = novo;
  	
	*U = novo;
}

void botarCrescente(TLista *L)
{
	TLista genesis = *L, ordenada;
	int gV,oV;
   	
	while(genesis)
	{
       	ordenada=genesis->prox;
			
		while(ordenada)
		{
           	if(genesis->valor > ordenada->valor)
			{
               	gV=genesis->valor;
               	oV=ordenada->valor;
               	ordenada->valor=gV;
               	genesis->valor=oV;
			}
			ordenada = ordenada->prox;
		}
		genesis=genesis->prox;
	}
}

int tamanho (TLista L1)
{
	TLista L=L1;
  
	if (!L) return 0;	
	
	return (1+tamanho (L->prox));
}

void inverterLista (TLista *L,TLista *U)
{
	TLista aux=*L;
	TLista auxU=*U;
	*L=NULL;
	*U=NULL;
	
	while(aux)
	{
		inserir (&*L, &*U, aux->valor);
		aux=aux->prox;
	}	
}

int pesquisaMaior(TLista L2)
{
  	TLista L=L2;
  
	if (!L) return 0;
  	
	int maior = pesquisaMaior(L->prox);

	if (L->valor > maior) return L->valor;
	
	return maior;
}

int pesquisaMenor(TLista L2)
{
	TLista L=L2;
	
	if (!L) return 0;
	
	int menor=L->valor;

	while(L)
	{	
		if(L->valor < menor)
		{
			menor = L->valor;
		}
		L = L->prox;
	}
	return menor;
}

float media(TLista L2)
{	
	if (L2)
	{
		return (somaDosElementos(L2)/tamanho(L2));
	}
	else
	return 0;
}

float somaDosElementos(TLista L2)
{
	TLista L=L2;
	if (!L)
	{
    	return 0;
	}
	else
	{
		return L->valor + somaDosElementos(L->prox);
	}
}

void remRepListaOrd(TLista L2)
{
    TLista aux;
    TLista L=L2;
  
	if((!L)||(!L->prox)) return;
	    
	if (L->valor == L->prox->valor)
	{
		L->prox->prox->ant=aux;
		aux = L->prox->prox;
		free (L->prox);
		aux->ant=L;
		L->prox = aux;
		remRepListaOrd(L);
	}
	else
	{
		if(!L->prox) return;
		remRepListaOrd(L->prox);
	}
}

Como posso melhorar meu código?
Tudo funciona, mas tem como deixá-lo mais enxuto ou "profissional"?

Obrigado!

#include <stdio.h>
#include <stdlib.h>

#define TRUE 1
#define FALSE 0

typedef struct No {
	int valor;
	struct No *prox;
} TNo;

typedef TNo* TLista;


int inserir (TLista *L, int numero);
int remover (TLista *L, int numero);
int alterar (TLista L, int velho, int novo);
TLista buscar (TLista L, int numero);
void exibir (TLista L);

void mantem (TLista L,TLista *L3);
float somaDosElementos(TLista L);
int comparaListas (TLista L1, TLista L2);/*FAZER*/
void exibirInvertido (TLista L2);
void botarCrescente(TLista *L);
int inserirNoFim (TLista *L, int numero);
void clonar (TLista *L, TLista L2);
void inverterLista (TLista *L);
int inserirNaPosicao (TLista *L, int numero, int posicao);
int tamanhoDaLista (TLista L);
int pesquisaMaior(TLista L2);
int pesquisaMenor(TLista L2);
int menu (TLista L, TLista L2, TLista L3);
float media(TLista L);

void remRepListaOrd(TLista L);

int main (void)
{
	TLista L = NULL, L2 = NULL, L3 = NULL;
	int opcao, num1, num2, alt, pos;	
	
	do
	{
		opcao = menu (L,L2,L3);
		
		switch (opcao)
		{
//inserção
			case 1: printf ("Entre com o número a ser inserido: ");
			scanf ("%d", &num1);
			printf (inserir (&L, num1)?"Elemento inserido!\n":"ERRO: Elemento não inserido!\n");
					break;
				
//remoção
			case 2: printf ("Entre com o número a ser removido: ");
			scanf ("%d", &num1);
			printf (remover (&L, num1)?"Elemento removido!\n":"ERRO: Elemento não removido!\n");
					break;
				
//alterar
			case 3: printf ("Entre com o número a ser alterado: ");
			scanf ("%d", &num1);
			
			printf ("Entre com o novo elemento: ");
			scanf ("%d", &num2);
			
			alt = alterar (L, num1, num2);
			if (alt != 0)
			{
				printf ("%d ocorrencias de %d alteradas!\n", alt, num1);
					}
					else
					{
						printf ("ERRO: Elemento não alterado!\n");
					}
					break;
				
//pesquisar
			case 4: printf ("Entre com o número a ser buscado: ");
			scanf ("%d", &num1);
			
			printf (buscar (L, num1)?"Elemento encontrado!\n":"Elemento não encontrado!\n");
					
					break;
				
//exibir
			case 5: if (!L)
			 		{
						printf("Lista vazia!\n");
					}
					else
					{
						printf("Lista: ");
						exibir (L);
			 			printf("\n");
					}
 	break;
 	
//exibir invertido
			case 6: if (!L)
			 		{
						printf("Lista vazia!\n");
					}
					else
					{
						printf("Lista: ");
						exibirInvertido (L);
			 			printf("\n");
					}
 	break;

//CLONAR			
			case 7: clonar (&L2,L);
					break;
			
//INVERTER		
			case 8:	inverterLista (&L);
			break;
			
//insere no fim
			case 9:	printf ("Entre com o número a ser inserido: ");
			scanf ("%d", &num1);
			printf (inserirNoFim (&L, num1)?"Elemento inserido!\n":"ERRO: Elemento não inserido!\n");
					break;
				
//ordenar
			case 10:L3=NULL;mantem (L,&L3);
					botarCrescente (&L);
					break;
			
//INSERIR NA POSIÇÃO
			case 11:printf ("Entre com o número a ser inserido: ");
			scanf ("%d", &num1);
			printf ("Entre com a posicao: ");
			scanf ("%d", &pos);
			printf (inserirNaPosicao (&L, num1, pos)?"Elemento inserido!\n":"ERRO: Elemento não inserido!\n");
					break;					
//comparar
			case 12:printf (comparaListas (L, L2)?"Elemento encontrado!\n":"Elemento não encontrado!\n");
					break;
					
			case 13:remRepListaOrd(L);
					break;
				
//saída
			case 0: printf ("Fim do programa!\n");
			break;
			
//opção inválida
			default: printf ("Opção inválida! Tente novamente.\n");
		}		
		system ("pause");
	}

	while (opcao != 0);

	return 0;
}

int inserir (TLista *L, int numero)
{
	TLista aux = (TLista) malloc (sizeof(TNo));	
	if (!aux)
	{
		return FALSE;
	}
	else
	{
		aux->valor = numero;
		aux->prox = *L;
		*L = aux;
		return TRUE;
	}
}

int remover (TLista *L, int numero)
{
	TLista aux1, aux2;
	int cont = 0;

	while ((*L) && ((*L)->valor == numero))
	{
		aux1 = (*L)->prox;
		free (*L);
		cont++;
		*L = aux1;
	}

	if (*L)
	{
		aux2 = *L;
		aux1 = (*L)->prox;

		while (aux1)
		{
			if (aux1->valor == numero)
			{
				aux2->prox = aux1->prox;
				free (aux1);
				cont++;
				aux1 = aux2->prox;				
			}
			else
			{
				aux2 = aux1;
				aux1 = aux1->prox;
			}
		}
	}	
	return cont;
}

int alterar (TLista L, int velho, int novo)
{
	TLista i=L;
	int cont=0;
	
	while (i != NULL)
	{
		if (i->valor == velho)
		{
			i->valor = novo;
			cont++;
		}
		i = i->prox;
	}
	return cont;
}

TLista buscar (TLista L, int numero)
/*if (!L){return NULL;}if (L->valor == numero){return L;}return buscar (L->prox,numero);*/
{
	(!L)?NULL:(L->valor == numero)?L:buscar (L->prox,numero);	
}

void exibir (TLista L2)
{
	TLista L=L2;	
	if(L)
	{
		printf ("%d ", L->valor);		
		exibir (L->prox);		
	}
}

int menu (TLista L, TLista L2, TLista L3)
{
	
	int opcao;
   	system	("cls");
	printf	("\nTamanho da Lista: %i\n\n",tamanhoDaLista (L));
	printf	("Lista Antes de Ordenar...: ");exibir (L3);
	printf	("|\n\n");
	printf	("Lista Atual..................: ");exibir (L);
	printf	("|\n");	
	printf	("Menor elemento da lista......: %i. \n", pesquisaMenor(L));
	printf	("Maior elemento da lista......: %i. \n", pesquisaMaior(L));
	float x; (!L)?x=0:x=media(L);
	printf	("Media dos elementos da lista.: %.2f. \n\n", x);	
	printf	("Clone da Lista Atual.....: ");exibir (L2);
	printf	("|\n\n");	
	printf	("Menu de opções:\n\n");
   	printf	("(1)\tInserir\n(2)\tRemover\n(3)\tAlterar\n");
   	printf	("(4)\tPesquisar\n(5)\tExibir na Ordem Natural\n");
   	printf	("(6)\tExibir na Ordem Inversa\n(7)\tClonar\n");
   	printf	("(8)\tInverter Lista\n");
   	printf	("(9)\tInsere no Fim\n(10)\tOrdenar Lista\n");
   	printf	("(11)\tInserir na Posicao\n");
   	printf	("(12)\tComparar Listas(FAZER)\n");
   	printf	("(13)\tRemove Repeticao de Lista Ja Ordenada\n");
   	printf	("(0)\tSair\n\n");
   	printf	("Entre Com a Opcao: ");
   	scanf	("%d", &opcao);

   	return opcao;
}

void botarCrescente(TLista *L)
{
	TLista genesis = *L, ordenada;

	int gV,oV;
   	
	while(genesis)
	{
   	ordenada=genesis->prox;
		   			
		while(ordenada)
		{
   	if(genesis->valor > ordenada->valor)
			{
   	gV=genesis->valor;
   	oV=ordenada->valor;
   	ordenada->valor=gV;
   	genesis->valor=oV;
			}
			ordenada = ordenada->prox;
		}
		genesis=genesis->prox;
	}
}

int inserirNoFim (TLista *L, int numero)
{   
	TLista aux=(TLista)malloc(sizeof(TNo));
	TLista novo=(TLista)malloc(sizeof(TNo));
	TLista aux2=(TLista)malloc(sizeof(TNo));	
	
	novo->valor=numero;
	aux2=*L;
	
	if((!*L))
	{
		aux->valor=numero;		
		aux->prox=*L;		
		*L=aux;		
		return TRUE;
	}
	else
	{
		while(aux2->prox)
{
aux2=aux2->prox;
}
		aux=aux2->prox;
		aux2->prox=novo;
		novo->prox=aux;
				
		return TRUE;
	}
	
}

void clonar (TLista *L, TLista L2)
{
	TLista aux=(TLista)malloc(sizeof(TNo));
		
	*L=NULL;
			
	aux=L2;
	
	while(aux)
	{
		inserirNoFim (&*L, aux->valor);
		aux=aux->prox;
	}	
}

void inverterLista (TLista *L)
{
	TLista aux=(TLista)malloc(sizeof(TNo));	
	aux=*L;	
	*L=NULL;
	
	while(aux)
	{
		inserir (&*L, aux->valor);
		aux=aux->prox;
	}	
}

int inserirNaPosicao (TLista *L, int num, int posicao)
{
	int con=0;
	
	TLista auxL=*L, aux;
	
	TLista novo=(TLista) malloc (sizeof(TNo));
	
	novo->valor=num;	
		
	if(!posicao||posicao>tamanhoDaLista(*L)+1)
	{
		return FALSE;
	}
	
	if(posicao==1)
	{
		inserir (&*L, num);
		return TRUE;
	}
	
	if(posicao==tamanhoDaLista(*L)+1)
	{
		inserirNoFim(&*L, num);
		return 1;
	}
	
	posicao=posicao-1;
		
while (con<posicao-1)
{
	auxL=auxL->prox;
con++;
}

	aux=auxL->prox;
	
	auxL->prox=novo;
	
	novo->prox=aux;

	return TRUE;
}

int tamanhoDaLista (TLista L2)
/*int tam=0;TLista aux=L;while(aux){aux=aux->prox;tam++;}return tam;}*/
{
	TLista L=L2;
	
	if (!L)
	{
		return 0;
	}
	else
	{
		return (1 + tamanhoDaLista(L->prox));
	}
}

int pesquisaMaior(TLista L2)
/*if (!L2) return 0;TLista L=L2;int maior = L->valor;while(L){if(L->valor > maior){maior = L->valor;}L=L->prox;}return maior;*/
{
  	TLista L=L2;
  	
	if (!L) return 0;
  	
	int maior = pesquisaMaior(L->prox);

	if (L->valor > maior) return L->valor;
	
	return maior;
}

int pesquisaMenor(TLista L2)
{
	TLista L=L2;
	
	if (!L) return 0;
	
	int menor=L->valor;

	while(L)
	{	
		if(L->valor < menor)
		{
			menor = L->valor;
		}
		L = L->prox;
	}
	return menor;
}

float media(TLista L2)
{	
	return (somaDosElementos(L2)/tamanhoDaLista(L2));
}

void exibirInvertido (TLista L2)
{
	TLista L=L2;	
	if(L)
	{
		exibirInvertido (L->prox);		
		printf ("%d ", L->valor);
	}
}

int comparaListas (TLista L1, TLista L2)/*GOSTARIA DE FAZER RECURSIVAMENTE*/
{
	TLista l1=L1;
	while (l1)
	{
		if (!buscar(L2,l1->valor))
		{
			return 0;
		}
		l1=l1->prox;
	}
	
	return 1;
}

float somaDosElementos(TLista L2)
{
	TLista L=L2;
	if (!L)
	{
	return 0;
	}
	else
	{
		return L->valor + somaDosElementos(L->prox);
	}
}

void remRepListaOrd(TLista L)
{
TLista aux;

	if((!L)||(!L->prox)) return;
	
	(L->valor == L->prox->valor)?aux = L->prox->prox,free (L->prox),L->prox = aux,remRepListaOrd(L):remRepListaOrd(L->prox);
}

void mantem (TLista L1,TLista *L3)
{
	TLista L=L1;	
	if (!L)
	{
		return;
	}
	else
	{
		inserirNoFim (&*L3, L->valor);
	}
	mantem (L->prox,&*L3);
}

@arfneto Tá errado não, tá certo.

"não há como saber qual das operações vai ser executada primeiro" ???????????????????????????

Em 25/11/2020 às 20:29, arfneto disse:

Acha que esse segundo return vai ser executado alguma vez?

Leu a parte que escrevi que é desnecessário? Enfim...

Em 25/11/2020 às 20:29, arfneto disse:

Quanto ao primeiro return, o único que vai rodar na prática:

Sério???? Se você não me avisa! Caramba...

Em 25/11/2020 às 20:29, arfneto disse:

tem dois #include obsoletos e fora do padrão e que sequer estão em uso.

Sério??? Nossa! 

Em 25/11/2020 às 20:29, arfneto disse:

O problema é que você usa str1 duas vezes como parâmetro de chamada para uma função. Na mesma linha., uma soma.

Acho que você deveria estudar mais aritmética de ponteiros.... talvez entenda o que foi feito.

Em 25/11/2020 às 20:29, arfneto disse:

Nesse compilador online retorna 9

Compilador online? Puts...

Em 25/11/2020 às 20:29, arfneto disse:

Por outro lado, compare com a saída do programa que te mostrei, e que tem a solução recursiva completa sem se apoiar naquela "deixa" do enunciado e funciona em qualquer plataforma...

É só admitir que não sabe...

Em 25/11/2020 às 20:29, arfneto disse:

tem dois return em seguida   e isso é folclórico

Você e 3 pessoas vão rir muito. O resto vai saber o que houve...

4 horas atrás, arfneto disse:

 

Uma discussão assim longa já não vai mais ajudar ninguém, porque imagino que as pessoas não tenham paciência de acompanhar esses argumentos, e cansei desse tópico. Eu tinha me esquecido do tanto que eu tentei te explicar muito do que está errado, e desisto. Vou resumir aqui de novo, uma última vez, e recomendo que seja ainda mais humilde e tente entender.

 

Veja como termina sua função comparaString() por exemplo:
 

int comparaString(char* str1, char* str2)
{
	if (!str1[0])
	{
		return 0;
	}

	return(comparaString2(str1[0], str2) + comparaString(++str1, str2));
	return (comparaString(++str1, str2));
}

 

Acha que esse segundo return vai ser executado alguma vez? Não, não vai.  Sabe o que é unreachable code? É isso aí acima. Se você tem um patrão ou um professor, melhor não mostrar isso. No forum já mostrou.

 

Quanto ao primeiro return, o único que vai rodar na prática:

 

	return(comparaString2(str1[0], str2) + comparaString(++str1, str2));

 

Entenda que isso está ERRADO. Não é minha opinião. Isso é UB, undefined behavior, comportamento indefinido.

 

Pelo modo como programa acho que não tem experiência ainda para entender isso e então vou tentar te explicar:

 

O problema é que você usa str1 duas vezes como parâmetro de chamada para uma função. Na mesma linha., uma soma.

E em uma das vezes você altera o valor. A linguagem C  não garante a ordem de execução dessa soma e pode ser que incremente antes ou depois da primeira chamada. Se incrementar antes vai passar o parâmetro alterado já na primeira chamada.

 

Isso quer dizer que dependendo da ordem de execução seu programa retorna 7, 8 ou 9. Retorna 8 apenas se mantiver a chamada a gets() apesar dos avisos do gcc e do passar dos anos. No Windows não vai aceitar gets() no compilador da Microsoft. E continua sendo UB.

Veja a mensagem do gcc 9.3 por exemplo, com -Wall que é o padrão em muitas escolas e empresas

 

 

Mais ainda, em gcc 9.3, Ubuntu, com gets()
 

 

Ao menos retornou 8

 

Mas a essência do problema é o undefined behavior, o uso de uma variável alterada no meio de uma expressão cuja ordem de avaliação não é garantida. E no meio de uma chamada a duas funções recursivas. Isso num ambiente profissional poderia te custar caro.

 

No forum não importa. Entendo que esse talvez não seja um erro ao alcance de um iniciante perceber e por isso estou escrevendo de novo a respeito. E de todo modo você não deve ter sequer lido os avisos sobre gets() na tela, exceto os que eu te dei, e parece que eu não tenho assim muito crédito, então fica aqui o aviso para ficar atento a isso no futuro.

 

Nesse compilador online retorna 9
 

 

Em gcc em Linux retorna em geral 9:
 

 

no windows
 

 

No SUSE Linux

 

Ou no Ubuntu

 

Mas no Windows com o compilador da Microsoft retorna 7
 

 

Isso é esperado, como eu disse: pode acontecer qualquer coisa.

 

Seu programa no geral não está assim bom.

• fflush() não existe para fluxos de entrada em geral.
• gets() é marcada como obsoleta há mais de vinte anos e alguns compiladores simplesmente não tem isso
• tem dois #include obsoletos e fora do padrão e que sequer estão em uso.
• tem dois return em seguida   e isso é folclórico
• tem uma expressão cujo comportamento é indefinido pelo padrão.

Por outro lado, compare com a saída do programa que te mostrei, e que tem a solução recursiva completa sem se apoiar naquela "deixa" do enunciado e funciona em qualquer plataforma...

 

 

Assim é. O código está no tópico.

 

Abaixo o código usado em todas as plataformas, o que você postou, com os 2 #include removidos e a chamada a gets() trocada por fgets()
 

  Ocultar conteúdo

#include <string.h>
#include <stdio.h>
#include <stdlib.h>

int comparaString2(char str1, char* str2);

int comparaString(char* str1, char* str2);

int main(void)
{
	int cont = 0;
	char str1[100], str2[100];
	fflush(stdin);
	printf("\nString1...:\n");
	fgets(str1, 100, stdin);
	fflush(stdin);
	printf("\nString2...:\n");
	fgets(str2, 100, stdin);
	cont = comparaString(str1, str2);
	printf("\nExistem %i caracteres comuns entre as duas strings\n", cont);
	return 0;
}

int comparaString(char* str1, char* str2)
{
	if (!str1[0])
	{
		return 0;
	}
	return(comparaString2(str1[0], str2) + comparaString(++str1, str2));
	return (comparaString(++str1, str2));
}

int comparaString2(char str1, char* str2)
{
	if (!str2[0])
	{
		return 0;
	}
	if (str2[0] == str1)
	{
		return (1 + comparaString2(str1, ++str2));
	}
	else
		return comparaString2(str1, ++str2);
}

 

 

O segundo return que botei na comparaString é desnecessário...

@arfneto

6 minutos atrás, arfneto disse:

 

Você sabe o que é ambiguidade? Um tópico que fala em inserir na ordem o número 4 na quarta posição e a série é 1 2 3 5 6 7 8 não é ambíguo pra você?

 

 

Sério?

 

Você não quer ajuda? Leia o que as pessoas de boa vontade escrevem para te ajudar 

 

Entendeu o código que eu postei?

 

Se quer apenas inserir na posição N, o que é inútil, basta contar os avanços a partir da raiz. E contornar o caso da lista não ter ao menos N-1 elementos.

 

 

"Você sabe o que é ambiguidade? Um tópico que fala em inserir na ordem o número 4 na quarta posição e a série é 1 2 3 5 6 7 8 não é ambíguo pra você?"
Não... qualquer pessoa teria lido a expressão "por exemplo" e saberia que se tratava apenas de um exemplo!

Ajudar é bem diferente disso aí.

Retiro o convite. Obrigado!

3 horas atrás, arfneto disse:

Sua pergunta é ambígua: você diz que quer inserir na quarta posição, mas sugere que quer também inserir na ordem numérica.
 

 

Se quer inserir na quarta posição é uma coisa, se quer inserir na ordem é outra.

 

Inserir na posição N 

É trivial, apenas tem o caso especial de a lista não ter ao menos (N-1) elementos. Se posiciona no início, conta os avanços, cria o nó e ajusta os ponteiros. É um exercíçio comum para iniciantes, mas pouco útil. Foi discutido aqui dias atrás.

 

Inserir em ordem

É trivial, mas é mais útil. Em geral o que se faz é usar uma função de comparação para manter a inserção genérica e poder classificar por CPF, por nome, por idade, o que tiver dentro do nó ou puder ser determinado a partir dele.

 

É a técnica usada por exemplo no qsort() em
 

void qsort(
	void *base, size_t nitems, 
	size_t size, 
	int (*compar)(const void *, const void*)
);

 

Eis um protótipo de uma solução em uso aqui:

Lista*      _inserir_na_ordem(void*, Lista*, int(*)(void*, void*));
 

E uma implementação com muitos comentários. No fundo não tem 20 linhas. Pode entender a lógica melhor

 

/*
 aqui a ideia e simples: tenho um elemento 'item'
 para inserir. Mas quero inserir na ordem.
 So que nao sei qual o conteudo entao nao sei qual a ordem.

 Se eu tiver que saber o conteudo entao a lista nao sera mais
 generica e o trabalho nao vai poder ser usado depois sem
 alterar o codigo, compilar e tal

 Logico que nao queremos abrir mao disso porque nao queremos
 mexer mais nesse codigo. Uma lista e uma lista afinal

 A solucao e a simples, usada em todas as bibliotecas e
 sistemas desde os '60. So vai mudando o nome. Hook, CallBack
 sei la

 A funcao f() escrita pelo cara que conhece os items compara dois
 itens e devolve -1, 0 ou 1 conforme o primeiro seja menor
 igual ou maior que o segundo Pronto

Se a funcao veio em branco insere no final e pronto

Queremos manter uma propriedade chamada estabilidade, que ocorre
quando os elementos iguais sao inseridos um depois do outro

*/
Lista*      _inserir_na_ordem(void* item, Lista* l, int(*f)(void*, void*))
{
    if (l == NULL) return l; // sem lista
    if (item == NULL) return l; // sem item
    // se nao veio a funcao insere no fim e pronto
    if (f == NULL)
        return _inserir_no_final(item, l);
    // se nao tinha nada insere no final. Ou no inicio
    if (l->quantos == 0)
        return _inserir_no_final(item, l);
    // entao tem mais gente. o caso comum
    // segue a lista e acha a posicao
    Node* p = l->inicio;
    // agora comparamos os itens
    // p->item e item para inserir, claro, na ordem
    do
    {
        int res = f(item, p->item); // -1,0,1
        // se voltou > 0 a posicao e mais pra frente
        // continua na lista
        if (res > 0)
        {
            p = p->proxima;
            continue;
        };  // if()
        // se voltou 0 insere o item depois de p
        if (res == 0)
            // aqui tem uma pegadinha se for inserir depois do ultimo
            if (p == l->fim)
                l->fim = _inserir_node_depois(item, p);
            else
                p = _inserir_node_depois(item, p);
        else
        {
            // aqui tem uma pegadinha se for inserir antes do primeiro
            if (p == l->inicio)
                l->inicio = _inserir_node_antes(item, p);
            else
                p = _inserir_node_antes(item, p);
        };  // if()
        // agora atualiza a quantidade e retorna
        l->quantos = l->quantos + 1;
        return l;
    } while (p != NULL);
    // se nao retornou ainda e porque esse novo item e o maior
    // de todos entao insere no final
    return _inserir_no_final(item, l);
};  // inserir_na_ordem()