Solucaoestdados - Histórico de revisão

imported>Fargoud em 14h15min de 7 de outubro de 2016

2016-10-07T14:15:03Z

← Edição anterior		Edição das 11h15min de 7 de outubro de 2016
Linha 79:		Linha 79:
	{//caso o novo dado seja MAIOR OU IGUAL ao primeiro:		{//caso o novo dado seja MAIOR OU IGUAL ao primeiro:
	if(toupper(ptratual->titulo[i]) < toupper(ptrnovo->titulo[i])) //testa se é MAIOR		if(toupper(ptratual->titulo[i]) < toupper(ptrnovo->titulo[i])) //testa se é MAIOR
	{ ptemp = ptratual;		{
	ptratual = ptratual->ptrprox;		if(ptratual->ptrprox !=(struct prs *)NULL) //se não chegou no final da lista
			{ ptemp = ptratual;
			ptratual = ptratual->ptrprox;
			}
			else //chegou no final da lista
			{
			ptratual->ptrprox = ptrnovo;
			encontrou = 1;
			}

	}		}
	else //duas primeiras letras são IGUAIS - compara as proximas letras		else //duas primeiras letras são IGUAIS - compara as proximas letras

imported>Fargoud em 13h55min de 7 de outubro de 2016

2016-10-07T13:55:49Z

← Edição anterior		Edição das 10h55min de 7 de outubro de 2016
Linha 1:		Linha 1:
	/*******************************************************************************/		/*******************************************************************************/
	/*** PROGRAMA LIVRARIA 2 - Demonstra como criar lista encadeada ordenada */
	/*******************************************************************************/		/*** PROGRAMA LIVRARIA 2 - Demonstra como criar lista encadeada ordenada */

			/*******************************************************************************/

	#include <stdlib.h> /* para a função atof(), que transforma uma string em float */		#include <stdlib.h> /* para a função atof(), que transforma uma string em float */
Linha 21:		Linha 23:

	/* declara estruturas tipo prs para montar a lista encadeada */		/* declara estruturas tipo prs para montar a lista encadeada */
	struct prs ptrprim, ptratual, *ptrnovo;		struct prs ptrprim, ptratual, *ptrnovo;

	//Função main():		//Função main():
	void main (void)		void main (void)
	{ char ch;		{ char ch;
	ptrprim = (struct prs ) NULL; / sem dados ainda */		ptrprim = (struct prs ) NULL; / sem dados ainda */
	for(;ch != 's';)		for(;ch != 's';)
Linha 48:		Linha 50:
	void inserealfa(void)		void inserealfa(void)
	{ char numstr[81];		{ char numstr[81];
	int encontrou = 0;		int encontrou = 0,i=0;
	struct prs * ptemp;		struct prs * ptemp;
	/* reserva espaço na memória (malloc) para armazenar estrutura do tamanho (sizeof) de prs */		/* reserva espaço na memória (malloc) para armazenar estrutura do tamanho (sizeof) de prs */
Linha 71:		Linha 73:
	else //lista já tem dado(s)		else //lista já tem dado(s)
	{ ptratual= ptemp = ptrprim;		{ ptratual= ptemp = ptrprim;

	do{ //busca por ordem alfabética onde pode inserir novo dado		do{ //busca por ordem alfabética onde pode inserir novo dado

	if(toupper(ptratual->titulo[0]) <= toupper(ptrnovo->titulo[0]))		if(toupper(ptratual->titulo[i]) <= toupper(ptrnovo->titulo[i]))
	{//caso o novo dado seja MAIOR OU IGUAL ao primeiro:		{//caso o novo dado seja MAIOR OU IGUAL ao primeiro:
	if(toupper(ptratual->titulo[0]) < toupper(ptrnovo->titulo[0])) //testa se é MAIOR		if(toupper(ptratual->titulo[i]) < toupper(ptrnovo->titulo[i])) //testa se é MAIOR
	{ ptemp = ptratual;		{ ptemp = ptratual;
	ptratual = ptratual->ptrprox;		ptratual = ptratual->ptrprox;
	}		}
	else //duas primeiras letras são IGUAIS - compara as proximas letras		else //duas primeiras letras são IGUAIS - compara as proximas letras
	{		{
	while(toupper(ptratual->titulo[i]) == toupper(ptrnovo->titulo[i]) )		while(toupper(ptratual->titulo[i]) == toupper(ptrnovo->titulo[i]) )
Linha 89:		Linha 91:
	ptrnovo -> ptrprox = ptratual->ptrprox;		ptrnovo -> ptrprox = ptratual->ptrprox;
	ptratual->ptrprox = ptrnovo;		ptratual->ptrprox = ptrnovo;
	}
	else //titulo que entrou é menor		}else //titulo que entrou é menor
	{		{
	ptrnovo->ptrprox = ptratual;		ptrnovo->ptrprox = ptratual;
Linha 97:		Linha 99:
	if(ptemp!=ptratual)//caso já haja mais de um dado na lista		if(ptemp!=ptratual)//caso já haja mais de um dado na lista
	ptemp->ptrprox = ptrnovo;		ptemp->ptrprox = ptrnovo;

	}		}
			encontrou = 1;
	encontrou = 1;
	} //fim else - dado novo igual ao atual		} //fim else - dado novo igual ao atual

Linha 121:		Linha 122:
	}		}

	/*** FUNÇÃO LISTATOT - lista os dados de todos os livros ***/		/*** FUNÇÃO LISTATOT - lista os dados de todos os livros ***/
	void listatot(void)		void listatot(void)
	{		{
	if(ptrprim == (struct prs *) NULL)		if(ptrprim == (struct prs *) NULL)
	{ printf("\n\nLista vazia!!\n");		{ printf("\n\nLista vazia!!\n");
	return;		return;
	}		}
	ptratual = ptrprim;		ptratual = ptrprim;
	do		do
	{ printf("Titulo: %s. \n", ptratual -> titulo);		{ printf("Titulo: %s. \n", ptratual -> titulo);
	printf("Autor: %s.\n", ptratual -> autor);		printf("Autor: %s.\n", ptratual -> autor);
	printf("Numero do registro: %3d.", ptratual -> regnum);		printf("Numero do registro: %3d.", ptratual -> regnum);
	printf("Preço: %4.2f. \n\n", ptratual -> preco);		printf("Preço: %4.2f. \n\n", ptratual -> preco);
	ptratual = ptratual -> ptrprox;		ptratual = ptratual -> ptrprox;
	} while(ptratual != (struct prs *) NULL);		} while(ptratual != (struct prs *) NULL);
	printf("\n_______________________\n");		printf("\n_______________________\n");
	}		}

	--------------------		--------------------

imported>Fargoud em 13h54min de 7 de outubro de 2016

2016-10-07T13:54:16Z

← Edição anterior		Edição das 10h54min de 7 de outubro de 2016
Linha 89:		Linha 89:
	ptrnovo -> ptrprox = ptratual->ptrprox;		ptrnovo -> ptrprox = ptratual->ptrprox;
	ptratual->ptrprox = ptrnovo;		ptratual->ptrprox = ptrnovo;

	}		}

	else //titulo que entrou é menor		else //titulo que entrou é menor
	{		{

imported>Fargoud em 13h51min de 7 de outubro de 2016

2016-10-07T13:51:23Z

← Edição anterior		Edição das 10h51min de 7 de outubro de 2016
Linha 90:		Linha 90:
	ptratual->ptrprox = ptrnovo;		ptratual->ptrprox = ptrnovo;

	}else //titulo que entrou é menor		}

			else //titulo que entrou é menor
	{		{
	ptrnovo->ptrprox = ptratual;		ptrnovo->ptrprox = ptratual;
	ptemp->ptrprox = ptrnovo;		if(ptratual == ptrprim) //caso o dado tenha que ser inserido no início da lista
			ptrprim = ptrnovo;
			if(ptemp!=ptratual)//caso já haja mais de um dado na lista
			ptemp->ptrprox = ptrnovo;

	}		}
	encontrou = 1;
			encontrou = 1;
	} //fim else - dado novo igual ao atual		} //fim else - dado novo igual ao atual

imported>Fargoud em 13h39min de 7 de outubro de 2016

2016-10-07T13:39:53Z

← Edição anterior		Edição das 10h39min de 7 de outubro de 2016
Linha 80:		Linha 80:
	ptratual = ptratual->ptrprox;		ptratual = ptratual->ptrprox;
	}		}
	else //duas primeiras letras são IGUAIS - compara ~~o segundo caractere de cada~~ titulo		else //duas primeiras letras são IGUAIS - compara as proximas letras
	if(toupper(ptratual->titulo[1]) < toupper(ptrnovo->titulo[1]) )		{
	{//se o titulo que entrou for maior		while(toupper(ptratual->titulo[i]) == toupper(ptrnovo->titulo[i]) )
			i++;

			if(toupper(ptratual->titulo[i]) < toupper(ptrnovo->titulo[i]) )
			{//se o titulo que entrou for maior
	ptrnovo -> ptrprox = ptratual->ptrprox;		ptrnovo -> ptrprox = ptratual->ptrprox;
	~~ptemp~~->ptrprox = ptrnovo;		ptratual->ptrprox = ptrnovo;

	}		}else //titulo que entrou é menor
			{
			ptrnovo->ptrprox = ptratual;
			ptemp->ptrprox = ptrnovo;
			}
			encontrou = 1;
			} //fim else - dado novo igual ao atual

	}else //dado que entrou é MENOR que atual - tem que ser inserido neste local		}else //dado que entrou é MENOR que atual - tem que ser inserido neste local
Linha 102:		Linha 112:
	}//fim else - lista já tem dados		}//fim else - lista já tem dados

	printf("\n_______________________________\n");		printf("\n_______________________________\n");

	}		}

	/*** FUNÇÃO LISTATOT - lista os dados de todos os livros ***/		/*** FUNÇÃO LISTATOT - lista os dados de todos os livros ***/

imported>Fargoud em 13h19min de 7 de outubro de 2016

2016-10-07T13:19:19Z

imported>Fargoud em 13h18min de 7 de outubro de 2016

2016-10-07T13:18:05Z

← Edição anterior		Edição das 10h18min de 7 de outubro de 2016
Linha 1:		Linha 1:
	/*******************************************************************************/		/*******************************************************************************/

	/*** PROGRAMA LIVRARIA 2 - Demonstra como criar lista encadeada ordenada */		/*** PROGRAMA LIVRARIA 2 - Demonstra como criar lista encadeada ordenada */

	/*******************************************************************************/		/*******************************************************************************/

	#include <stdlib.h> /* para a função atof(), que transforma uma string em float */		#include <stdlib.h> /* para a função atof(), que transforma uma string em float */

imported>Fargoud em 13h17min de 7 de outubro de 2016

2016-10-07T13:17:43Z

Mostrar alterações

imported>Fargoud em 13h00min de 7 de outubro de 2016

2016-10-07T13:00:34Z

Mostrar alterações

imported>Fargoud: Criou página com '/***************************************************************************/ /* PROGRAMA LIVRARIA - Demonstra como criar listas lineares */ /*** he...'

2016-09-30T10:27:40Z

Criou página com '***************************************************************************: ** PROGRAMA LIVRARIA - Demonstra como criar listas lineares: /*** he...'

Página nova

/*****************************************************************************/
/*** PROGRAMA LIVRARIA - Demonstra como criar listas lineares */
/*** heterogêneas estáticas em C */
/***************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h> /* para funções atoi() e atof(), que transformam uma string em int e float */
#include <strings.h>

struct livro
{ char titulo[30];
char autor[30];
int regnum;
double preco;
}*PtrIni, *PtrFim, *PtrAtual;

struct livro * busca(char tit[30]);
void novolivro(void);
void listatot(void);

struct livro lista_livros[50]; /* declara uma matriz com 50 estruturas do tipo livro */
int n=0; // contadora do número de livros incluídos

int main (void)
{ char ch, titu[30];
struct livro * ender;

for(;ch != 's';)
{ printf("\nDigite: 'e' para adicionar um livro\n");
printf("\t'l ' para listar os livros\n");
printf("\t'b' para buscar um livro pelo titulo\n");
printf("\t's' para sair:\n");
ch = getche();
printf("\n");
{ case 'e' : novolivro(); break;
case 'l' : listatot(); break;
case 'b' : printf("\nEntre com o nome do livro que quer buscar: ");
gets(titu);
ender = busca(titu);
if(ender) printf("\nO autor do livro é: %s", ender->autor);
else printf("\nNao foi achada nenhuma ocorrencia deste livro!!");
break;
case 's' : printf("\nFim do programa"); break;
default : puts("\nDigite somente opções válidas: ");
}
}

return 0;
}

/***** FUNÇÃO NOVOLIVRO - adiciona um novo livro ao arquivo ***/
void novolivro(void)
{ char numstr[81];
if(!n) PtrIni = &lista_livros[n];
else PtrFim = &lista_livros[n];

printf("\n Registro %d. \nDigite titulo: ", n+1);
gets (lista_livros[n].titulo);
printf("Digite autor: ");
gets(lista_livros[n].autor);
printf("Digite o número do livro (3 digitos): ");
gets(numstr);
lista_livros[n].regnum = atoi(numstr);
printf("Digite preço:");
gets(numstr);
lista_livros[n++].preco = atof(numstr);
printf("\n_______________________________\n");
}

/***** FUNÇÃO LISTATOT - lista os dados de todos os livros *****/
void listatot(void)
{
int i;
if( !n)
printf("\n\nLista vazia!!\n");
else
for( i=0; i<n; i++)
{ printf("\n Registro %d.\n", i+1);
printf("Titulo: %s. \n", lista_livros[i].titulo);
printf("Autor: %s.\n", lista_livros[i].autor);
printf("Numero do registro: %3d.", lista_livros[i].regnum);
printf("Preço: %4.2f. \n\n", lista_livros[i].preco);
}
printf("\n_______________________\n");
}

/***** FUNÇÃO BUSCA - lista os dados de todos os livros *****/
struct livro * busca(char tit[30])
{ PtrAtual = PtrIni;
while (strcmp(PtrAtual->titulo, tit) && (PtrAtual <= PtrFim))
PtrAtual ++;
if(PtrAtual <= PtrFim) return PtrAtual;
else return (struct livro *)NULL;
}

/*****************************************************************************/
/*** PROGRAMA LIVRARIA - Demonstra como criar listas lineares */
/*** heterogêneas estáticas em C */
/ ***************************************************************************/
#include <stdio.h>
#include <conio.h>
#include <stdlib.h> /* para funções atoi() e atof(), que transformam uma string em int e float */
#include <strings.h>

struct livro
{ char titulo[30];
char autor[30];
int regnum;
double preco;
}*PtrIni, *PtrFim, *PtrAtual;

struct livro * busca(char tit[30]);
void novolivro(void);
void listatot(void);

struct livro lista_livros[50]; /* declara uma matriz com 50 estruturas do tipo livro */
int n=0; // contadora do número de livros incluídos

void main (void)
{ char ch, titu[30];
struct livro * ender;

for(;ch != 's';)
{ printf("\nDigite: 'e' para adicionar um livro\n");
printf("\t'l ' para listar os livros\n");
printf("\t's' para sair:\n");
ch = getche();
printf("\n");
switch(ch)
{ case 'e' : novolivro(); break;
case 'l' : listatot(); break;
case 'b' : printf("\nEntre com o numero do livro que quer buscar: ");
gets(titu);
ender = busca(titu);
printf("\nO autor do livro é: %s", ender->autor);
break;
case 's' : printf("\nFim do programa"); break;
default : puts("\nDigite somente opções válidas: ");
}
}
}

/***** FUNÇÃO NOVOLIVRO - adiciona um novo livro ao arquivo ***/
void novolivro(void)
{ char numstr[81];
if(!n) PtrIni = &lista_livros[n];
else PtrFim = &lista_livros[n];

printf("\n Registro %d. \nDigite titulo: ", n+1);
gets (lista_livros[n].titulo);
printf("Digite autor: ");
gets(lista_livros[n].autor);
printf("Digite o número do livro (3 digitos): ");
gets(numstr);
lista_livros[n].regnum = atoi(numstr);
printf("Digite preço:");
gets(numstr);
lista_livros[n++].preco = atof(numstr);
printf("\n_______________________________\n");
}

/***** FUNÇÃO LISTATOT - lista os dados de todos os livros *****/
void listatot(void)
{
int i;
if( !n)
printf("\n\nLista vazia!!\n");
else
for( i=0; i<n; i++)
{ printf("\n Registro %d.\n", i+1);
printf("Titulo: %s. \n", lista_livros[i].titulo);
printf("Autor: %s.\n", lista_livros[i].autor);
printf("Numero do registro: %3d.", lista_livros[i].regnum);
printf("Preço: %4.2f. \n\n", lista_livros[i].preco);
}
printf("\n_______________________\n");
}

/***** FUNÇÃO BUSCA - lista os dados de todos os livros *****/
struct livro * busca(char tit[30])
{ PtrAtual = PtrIni;
while (strcmp(PtrAtual->titulo, tit) && (PtrAtual <= PtrFim))
PtrAtual ++;
if(PtrAtual <= PtrFim) return PtrAtual;
else return (struct livro *)NULL;
}

/************************************************************/
/*** PROGRAMA TABELA - Demonstra como criar estruturas de */
/*** tabela dinâmica em C */
/*************************************************************/
#include <stdlib.h> /* para as funções atoi() e atof() */
#include <stdio.h>
#include <conio.h>
#define TRUE 1

struct livro /* estrutura básica da lista */
{ char titulo[30]; //CHAVE do nó
char autor[30];
int regnum;
double preco;
struct livro *ptrprox;
struct livro *ptrant;
};

void novolivro(void);
void listatot(void);
struct livro * buscalivro(char [81]);

struct livrod *primlivro, *atuallivro, *novono;
// declara ponteiros de estruturas livrod p/ montar lista

void main (void)
{ char ch;

primlivro = (struct livrod *) NULL; /* lista vazia */
for(;ch != 's';)
{ printf("\nDigite: 'e' para adicionar um livro\n");
printf("\t'l ' para listar os livros\n");
printf("\t's' para sair:\n");
ch = getche();
printf("\n");
switch(ch)
{ case 'e' : novolivro(); break;
case 'l' : listatot(); break;
case 's' : printf("Fim do programa"); break;
default : puts("\nDigite somente opções válidas: ");
}
}
}

/***** FUNÇÃO NOVOLIVRO - adiciona um novo nó à lista ***/
void novolivro(void)
{ char numstr[81];

/******* ALOCANDO NOVO NÓ NA MEMÓRIA ********************/
novono = (struct livrod *) malloc (sizeof(struct livrod));

/******* INSERINDO NOVO NÓ NO FINAL DA LISTA **************/
if (primlivro == (struct livrod *) NULL) //se lista vazia
primlivro = atuallivro = novono;
else
{ atuallivro = primlivro; /*posiciona ptr atual para começar a percorrer a lista */
while(atuallivro->ptrprox != (struct livrod *) NULL) // procura ultimo nó da lista
atuallivro = atuallivro->ptrprox; //ptr aponta p/ próx nó
atuallivro->ptrprox = novono;
//faz ptr do último nó da lista apontar p/ o novo nó
atuallivro = novono; //deixa ptr apontando p/ final lista
}

/******* DANDO CONTEÚDO AO NOVO NÓ DA LISTA ****************/
printf(" Digite titulo: ");
gets (atuallivro -> titulo);
printf(" Digite autor: ");
gets(atuallivro -> autor);
printf(" Digite o número do livro (3 digitos): ");
gets(numstr);
atuallivro -> regnum = atoi(numstr); /* função atoi() converte uma string para inteiro */
printf(" Digite preço:");
gets(numstr);
atuallivro -> preco = atof(numstr);
printf("\n_______________________________\n");
atuallivro -> ptrprox = (struct livrod *) NULL; /* último nó aponta para 0 */
}

/** FUNÇÃO LISTATOT - lista os dados de todos os livros *****/
void listatot(void)
{
if(primlivro == (struct livrod *) NULL)
{ printf("\n\nLista vazia!!\n");
return;
}
atuallivro = primlivro;
do
{ printf("Titulo: %s. \n", atuallivro -> titulo);
printf("Autor: %s.\n", atuallivro -> autor);
printf("Numero do registro: %3d.", atuallivro -> regnum);
printf("Preço: %4.2f. \n\n", atuallivro -> preco);
atuallivro = atuallivro -> ptrprox;
}while(atuallivro != (struct livrod *) NULL);

printf("\n_______________________\n");
}

/************************************************************/
/*** PROGRAMA TABELA - Demonstra como criar estruturas de */
/*** tabela dinâmica em C */
/*************************************************************/
#include <stdlib.h> /* para as funções atoi() e atof() */
#include <stdio.h>
#include <conio.h>
#define TRUE 1

struct livro /* estrutura básica da lista */
{ char titulo[30]; //CHAVE do nó
char autor[30];
int regnum;
double preco;
struct livro *ptrlin;
struct livro *ptrcol;
};

void novolivro(void);
void listatot(void);
struct livro * buscalivro(char [81]);
void inseretabela

struct livrod *primlivro, *atuallivro, *novono;
// declara ponteiros de estruturas livrod p/ montar lista

void main (void)
{ char ch;

primlivro = (struct livrod *) NULL; /* lista vazia */
for(;ch != 's';)
{ printf("\nDigite: 'e' para adicionar um livro\n");
printf("\t'l ' para listar os livros\n");
printf("\t's' para sair:\n");
ch = getche();
printf("\n");
switch(ch)
{ case 'e' : novolivro(); break;
case 'l' : listatot(); break;
case 's' : printf("Fim do programa"); break;
default : puts("\nDigite somente opções válidas: ");
}
}
}

/***** FUNÇÃO NOVOLIVRO - adiciona um novo nó à lista ***/
void novolivro(void)
{ char numstr[81];

/******* ALOCANDO NOVO NÓ NA MEMÓRIA ********************/
novono = (struct livrod *) malloc (sizeof(struct livrod));

/******* INSERINDO NOVO NÓ NO FINAL DA LISTA **************/
if (primlivro == (struct livrod *) NULL) //se lista vazia
primlivro = atuallivro = novono;
else
{ atuallivro = primlivro; /*posiciona ptr atual para começar a percorrer a lista */
while(atuallivro->ptrprox != (struct livrod *) NULL) // procura ultimo nó da lista
atuallivro = atuallivro->ptrprox; //ptr aponta p/ próx nó
atuallivro->ptrprox = novono;
//faz ptr do último nó da lista apontar p/ o novo nó
atuallivro = novono; //deixa ptr apontando p/ final lista
}

/******* DANDO CONTEÚDO AO NOVO NÓ DA LISTA ****************/
printf(" Digite titulo: ");
gets (atuallivro -> titulo);
printf(" Digite autor: ");
gets(atuallivro -> autor);
printf(" Digite o número do livro (3 digitos): ");
gets(numstr);
atuallivro -> regnum = atoi(numstr); /* função atoi() converte uma string para inteiro */
printf(" Digite preço:");
gets(numstr);
atuallivro -> preco = atof(numstr);
printf("\n_______________________________\n");
atuallivro -> ptrprox = (struct livrod *) NULL; /* último nó aponta para 0 */
}

/** FUNÇÃO LISTATOT - lista os dados de todos os livros *****/
void listatot(void)
{
if(primlivro == (struct livrod *) NULL)
{ printf("\n\nLista vazia!!\n");
return;
}
atuallivro = primlivro;
do
{ printf("Titulo: %s. \n", atuallivro -> titulo);
printf("Autor: %s.\n", atuallivro -> autor);
printf("Numero do registro: %3d.", atuallivro -> regnum);
printf("Preço: %4.2f. \n\n", atuallivro -> preco);
atuallivro = atuallivro -> ptrprox;
}while(atuallivro != (struct livrod *) NULL);

printf("\n_______________________\n");
}

/** Estrutura de Dados em C ***************************/
/*** Tarefa 1 - Lista Duplamente Encadeada */

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

void novo_no(void);
void cadastro(void);
void mostra_cadastro();
char devolvemaiusc(char l);
int ordena(char nome[35], char novo_nome[35]);
void buscar();

struct no /** variável tipo estrutura básica da lista */
{
char nome[35];
char telefone[14];
char idade[3];
struct no *proximo;
struct no *anterior;
} *primeiro, *atual, *nova_estrutura;

int main(void)
{
char escolha;
while(escolha!='s')
{
printf("\nEscolha a opcao desejada:");
printf("\nC para cadastrar");
printf("\nB para buscar um cadastro");
printf("\nM para mostrar os cadastros registrados");
printf("\nS para sair");
printf("\n->");
escolha=getch();
switch(escolha)
{
case 'c' :
case 'C' : novo_no(); break;
case 'b' :
case 'B' : buscar(); break;
case 'm' :
case 'M' : mostra_cadastro(); break;
case 's' :
case 'S' : break;
default : printf("Digite somente opções válidas!");
}

}
}

/***** FUNÇÃO nova_estrutura - adiciona um novo nó à lista ***/

void novo_no(void)
{
int ordem=0;
/******* ALOCANDO NOVO NÓ NA MEMÓRIA ********************/
nova_estrutura = (struct no *) malloc (sizeof(struct no));
nova_estrutura->anterior = (struct no *) NULL;
nova_estrutura->proximo = (struct no *) NULL;

cadastro();
/******* INSERINDO NOVO NÓ NO FINAL DA LISTA **************/
if (primeiro == (struct no *) NULL)
primeiro = atual = nova_estrutura;
else
{
atual = primeiro;
while(atual != (struct no*) NULL)
{
ordem=ordena(atual->nome,nova_estrutura->nome);
if(ordem == -1)
{
nova_estrutura->proximo = atual;
nova_estrutura->anterior = atual->anterior;
if(atual->anterior == (struct no*) NULL)
{
primeiro = nova_estrutura;
}
else
{
atual->anterior->proximo=nova_estrutura;
}
atual->anterior = nova_estrutura;
return;
}
else
{
if(ordem == 1)
{
if(atual->proximo == (struct no*) NULL)
{
nova_estrutura->anterior=atual;
nova_estrutura->proximo=atual->proximo;
atual->proximo = nova_estrutura;
return;
}
else
{
if(ordena(atual->proximo->nome,nova_estrutura->nome)==-1)
{
nova_estrutura->anterior=atual;
nova_estrutura->proximo=atual->proximo;
atual->proximo->anterior = nova_estrutura;
atual->proximo = nova_estrutura;
return;
}
}
}
else
{
nova_estrutura->anterior = atual->anterior;
nova_estrutura->proximo = atual->proximo;
if(atual->anterior != (struct no*) NULL)
{
atual->anterior->proximo = nova_estrutura;
}
else
{
primeiro = nova_estrutura;
}
if(atual->proximo != (struct no*) NULL)
{
atual->proximo->anterior = nova_estrutura;
}
free(atual);
return;
}
}
atual = atual->proximo;
}
}
}

void buscar()
{
char nome_procurar[35];
printf("\nDigite o nome a procurar:\n>");
gets(nome_procurar);
if(primeiro == (struct no*)NULL)
{
printf("Lista vazia");
}
else
{
atual = primeiro;
while(atual != (struct no*)NULL)
{
if(!ordena(atual->nome,nome_procurar))
{
printf("Nome:%s\n",atual -> nome);
printf("Telefone:%s\n",atual -> telefone);
printf("Idade:%s\n",atual -> idade);
return;
}
atual = atual->proximo;
}
printf("Sem cadastro encontrado.");
}
}

void cadastro(void)
{
/******* DANDO CONTEÚDO AO NOVO NÓ DA LISTA ****************/
printf("\nDigite um nome:");
gets (nova_estrutura -> nome);
printf("Digite um numero de telefone:");
gets (nova_estrutura -> telefone);
printf("Digite a idade:");
gets (nova_estrutura -> idade);
printf("\n\n");

}
void mostra_cadastro()
{
/******* IMPRIME CONTEÚDO DO NOVO NÓ DA LISTA ****************/
if(primeiro == (struct no*)NULL)
{
printf("\n\nLista vazia");
}
else
{
atual = primeiro;
while(atual != (struct no*)NULL)
{
printf("\n\n");
printf("\nNome:%s\n",atual -> nome);
printf("Telefone:%s\n",atual -> telefone);
printf("Idade:%s\n",atual -> idade);
atual = atual->proximo;
}

}
}
int ordena(char nome[35], char novo_nome[35])
{
int flag = 0;
int i=0;
char n=1, nv=1;

while(!flag && i<35 && n && nv)
{
n = devolvemaiusc(nome[i]);
nv = devolvemaiusc(novo_nome[i]);
if( n < nv )
flag=1;
else if( n > nv )
flag = -1;
i++;
}
return flag;
}
char devolvemaiusc(char l)
{
if(l >= 97 && l<=122)
l-= 32;

return l;
}

← Edição anterior		Edição das 10h19min de 7 de outubro de 2016
Linha 1:		Linha 1:
	/*******************************************************************************/		/*******************************************************************************/

	/*** PROGRAMA LIVRARIA 2 - Demonstra como criar lista encadeada ordenada */		/*** PROGRAMA LIVRARIA 2 - Demonstra como criar lista encadeada ordenada */

	/*******************************************************************************/		/*******************************************************************************/

Linha 104:		Linha 102:
	}//fim else - lista já tem dados		}//fim else - lista já tem dados

	printf("\n_______________________________\n");		printf("\n_______________________________\n");

	}		}

	/*** FUNÇÃO LISTATOT - lista os dados de todos os livros ***/		/*** FUNÇÃO LISTATOT - lista os dados de todos os livros ***/
	void listatot(void)		void listatot(void)
	{		{
	if(ptrprim == (struct prs *) NULL)		if(ptrprim == (struct prs *) NULL)
	{ printf("\n\nLista vazia!!\n");		{ printf("\n\nLista vazia!!\n");
	return;		return;
	}		}
	ptratual = ptrprim;		ptratual = ptrprim;
	do		do
	{ printf("Titulo: %s. \n", ptratual -> titulo);		{ printf("Titulo: %s. \n", ptratual -> titulo);
	printf("Autor: %s.\n", ptratual -> autor);		printf("Autor: %s.\n", ptratual -> autor);
	printf("Numero do registro: %3d.", ptratual -> regnum);		printf("Numero do registro: %3d.", ptratual -> regnum);
	printf("Preço: %4.2f. \n\n", ptratual -> preco);		printf("Preço: %4.2f. \n\n", ptratual -> preco);
	ptratual = ptratual -> ptrprox;		ptratual = ptratual -> ptrprox;
	} while(ptratual != (struct prs *) NULL);		} while(ptratual != (struct prs *) NULL);
	printf("\n_______________________\n");		printf("\n_______________________\n");
	}		}

	--------------------		--------------------

Solucaoestdados - Histórico de revisão

imported>Fargoud em 14h15min de 7 de outubro de 2016

imported>Fargoud em 13h55min de 7 de outubro de 2016

imported>Fargoud em 13h54min de 7 de outubro de 2016

imported>Fargoud em 13h51min de 7 de outubro de 2016

imported>Fargoud em 13h39min de 7 de outubro de 2016

imported>Fargoud em 13h19min de 7 de outubro de 2016

imported>Fargoud em 13h18min de 7 de outubro de 2016

imported>Fargoud em 13h17min de 7 de outubro de 2016

imported>Fargoud em 13h00min de 7 de outubro de 2016

imported>Fargoud: Criou página com '/*****************************************************************************/ /*** PROGRAMA LIVRARIA - Demonstra como criar listas lineares */ /*** he...'

imported>Fargoud: Criou página com '/***************************************************************************/ /* PROGRAMA LIVRARIA - Demonstra como criar listas lineares */ /*** he...'