C Funções para Lista Duplamente Encadeadas.

jcgs98 · 10 de janeiro de 2021

#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);
	}
}

devair1010 · 11 de janeiro de 2021

@Comunista.RJ ainda não sei sobre Listas encadeadas , mas testando seu código Visual Studio , não compilou , então fiz algumas modificações e rodou , mas essas funções que estão faltando não consegui fazer nada delas e seu código modificado ficou assim :

#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>
#include <locale.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);
TCHAR getch();
void saindo();
void gotoxy_2(int x, int y);
void som(int f, int d);
int letras[8][5] = { { 15 , 16 , 14 ,  1 , 30 }, /* letra  S */
				     { 14 , 17 , 31 , 17 , 17 }, /* letra  A */
				     { 14 ,  4 ,  4 ,  4 , 14 }, /* letra  I */
				     { 17 , 25 , 21 , 19 , 17 }, /* letra  N */
				     { 30 , 17 , 17 , 17 , 30 }, /* letra  D */
				     { 14 , 17 , 17 , 17 , 14 }, /* letra  O */
				     {  0 ,  0 ,  0 ,  0 ,  0 }, /* letra    */
				     {  1 ,  2 ,  4 ,  0 , 16 }  /* letra  ! */
                   };
int sm[8] = { 800,400,800,400,2500,200,2500,200 };
int main()
{
	TLista L = NULL, L2 = NULL, U = NULL, pos=0;
	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");
			saindo();
			break;
		default:
			printf("Opção inválida!\nTente novamente!\n");
		}
		printf("\n\n\n\t\t\t\tTecle\n");
		getch();
	} while ( op != 0 );
}

int menu(TLista L, TLista L2)
{
	int opcao;
	TCHAR k = 0;
	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");
	printf(" (  2 )\tRemover\n");
	printf(" (  3 )\tAlterar\n");
	printf(" (  4 )\tPesquisar\n");
	printf(" (  5 )\tExibir na Ordem Natural\n");
	printf(" (  6 )\tExibir na Ordem Inversa\n");
	printf(" (  7 )\tClonar\n");
	printf(" (  8 )\tInserir na Posicao\n");
	printf(" (  9 )\tInsere no Fim\n");
	printf(" ( 10 )\tOrdenar Lista\n");
	printf(" ( 11 )\tRemove Repeticoes da lista  (*INCOMPLETA - so remove depois de ordenar)\n");
	printf(" ( 12 )\tInverter Lista\n");
	printf(" ( 13 )\tComparar Listas (*FAZER)\n");
	printf(" (  0 )\tSair\n\n");
	printf("       \tEntre Com a Opcao: ");
	//scanf("%d", &opcao);
	opcao = getch() - 48;
	printf("\n");
	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 = 0;
	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 = 0;
	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);
	}
}
TCHAR getch()
{
	DWORD mode, cc;
	HANDLE h = GetStdHandle(STD_INPUT_HANDLE);
	if (h == NULL)
	{
		return 0; // console not found
	}
	GetConsoleMode(h, &mode);
	SetConsoleMode(h, mode & ~(ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT));
	TCHAR c = 0;
	ReadConsole(h, &c, 1, &cc, NULL);
	SetConsoleMode(h, mode);
	return c;
}
void saindo()
{
	int px, py;                               /*  variáveis simples                                    */
	HANDLE hOut;                              /*  controle dos dispositivos do pc                      */
	hOut = GetStdHandle(STD_OUTPUT_HANDLE);   /*  pega a saída padrão                                  */
	CONSOLE_SCREEN_BUFFER_INFO SBInfo;        /*  informações sobre a buffer da tela                   */
	GetConsoleScreenBufferInfo(hOut, &SBInfo);/*  pega a posição do cursor do console                  */
	px = SBInfo.dwCursorPosition.X;           /*  pX será a posição da coluna do cursor no console     */
	py = SBInfo.dwCursorPosition.Y;           /*  pY será a posição da linha do cursor no console      */
	int y1 = py + 15, x1 = 20, y2,
		x2 = x1, j, i, a, b;                  /*  y1=linha inicial  y2 para recuperar a linha inicial  */
	gotoxy_2(x1, y1);
	y1 -= 10;
	gotoxy_2(x1, y1);
	y2 = y1;
	for (i = 0; i < 8; i++)
	{                                         /*  sao 8 letras                                         */
		for (j = 0; j < 5; j++)
		{                                     /*  o caractere é de 5 linhas                            */
			x1 = x2;
			a = letras[i][j];                 /*  pega o numero da 1 linha do caractere                */
			for (b = 0; b < 5; b++)
			{                                 /*  aqui eh um numero de apenas 8 bits                   */
				gotoxy_2(x1, y1);
				if (a % 2 != 0)
				{                             /*  se bit 0 igual 1                                     */
					printf("%c", 219);        /*  coloca espaço invertido senão coloca espaço normal   */
				}
				else
				{
					printf(" ");              /*  senão coloca espaço normal                           */
				}
				a = a / 2;                    /*  dividindo numero por 2 desloca os bits para direita  */
				x1--;
				Sleep(10);
			}
			y1++;                             /*  muda para proxima linha                              */
			x1 = x2;                          /*  volta para a coluna inicial                          */
		}                                     /*  proxima linha                                        */
		x2 = x2 + 6;                          /*  avança 6 colunas posicionando para o prox caract     */
		y1 = y2;                              /*  volta para linha inicial                             */
	}                                         /*  imprimiu o primeiro caractere                        */
	for (j = 0; j < 8; j += 2)
		som(sm[j], sm[j + 1]);
}
void gotoxy_2(int x, int y)
{
	COORD c;
	c.X = x;
	c.Y = y;
	SetConsoleCursorPosition(GetStdHandle(STD_OUTPUT_HANDLE), c);
}
void som(int f, int d)
{
	Beep(f, d);/* primeiro a frquência depois o tempo de duração do som */
}

jcgs98 · 26 de janeiro de 2021

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);
}