teste Estrutura de dados

Esta é uma pré-visualização de arquivo. Entre para ver o arquivo original

teste01/consultorio.c
struct consultorio {
	int id;
	int especialidade;
	Senha senhaAtendida;
};
typedef struct consultorio Consultorio;
	
Consultorio criaConsultorio(int id, int especialidade){
	Consultorio c;
	c.id = id;
	c.especialidade= especialidade;
	//c.senhaAtendida = (Senha*) malloc( sizeof(Senha));
	return c;
}
teste01/filaS.c
struct filaS{
	int id;
 int comprimento;
	Senha* senhas;
};
typedef struct filaS* FilaS;
FilaS criaFilaS(int id,int tam)
{
	
	FilaS f = (FilaS) malloc(sizeof(FilaS));
 f->senhas = (Senha*) malloc(tam * sizeof(Senha));
	f->id = id;
	f->comprimento = 0;
	
 return f;
}
void enfileiraS(FilaS f, Senha s)
{
 f->senhas[f->comprimento] = s;
 f->comprimento += 1;
}
Senha desenfileiraS(FilaS f)
{
	int i = 0;
	Senha aux;
	aux = f->senhas[0];
	while (i < f->comprimento)
	{
		f->senhas[i] = f->senhas[i + 1];
		i++;
	}
	f->comprimento--;
	return aux;
}
int estaVaziaF(FilaS f){
	
	if (f->comprimento == 0){
		return 1;
	}
	return 0;
}
teste01/main.c
//Bibliotecas
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
/* Na primeira parte do teste na definição das estruturas e TADs
errei pensando que todas as filas seriam estruturas do tipo FIFO,
então corrigindo o erro criei a TAD pilhaS que é uma estrutura
do tipo LIFO que servirá para empilhar as senhas nas filas das salas de espera.
E adicionei as funções para criar e retornar as estrutura.*/
#include "senha.c"	 //Estrutura que contem o codigo da senha.
#include "pilhaS.c"	 //Estrutura do tipo LIFO.
#include "filaS.c"	 //Estrutura do tipo FIFO.
#include "triagem.c" 	 //Estrutura que contem uma estrutura do tipo filaS.
#include "salaE.c"	 //Estrutura que contem uma estrutura do tipo pilhaS.
#include "consultorio.c" //Estrutura que contem a "senha/pessoa" que esta sendo consultada.
/* Na segunda parte do teste não expliquei muito bem os 
retornos e parâmetros recebidos pelas funções. 
Dessa vez vou explicar como cada funções funciona 
e na função main como cada função e chamada.*/
/* A função criaSenhas recebe a quantidade de senhas por consultorio a ser criadas.
Ao criar uma nova senha a mesma é enfileirada na fila
de forma que a fila seja criada em ordem crescente e a função
faz isso enquanto tiver senhas a ser criadas, finalizando ele retorna as senhas numa FilaS.*/
FilaS criaSenhas(int senhas, int consultorios);
/* A função criaConsultorios recebe a quantidade de consultorios a ser criadas.
 Ao criar um consultorio ele e adicionado no vetor e faz isso ate que não tenha
consultorios a ser criados, depois retorna o vetor com os escritorios. */
Consultorio* criaConsultorios(int consultorios);
/* A função encaminhaSalaEspera recebe a quantidade de senhas 
por consultorio, total de consultorios e a triagem com a fila de senhas.
Essa função desenfileira uma sequencia de senhas da triagem 
e as empilha na pilha da sala de espera, de forma que 
as senhas sejam desempilhada de ordem crescente ao 
ser chamada para o consultorio e faz isso enquanto tiver senhas na triagem, 
finalizando ela retorna o vetor com as salas de espera.*/
SalaE* encaminhaSalaEspera(Triagem t, int consultorios, int totalSenhasConsultorio);
/* A função chamaParaConsulta recebe os vetores com as salas de espera, 
consultorios e o total de consultorios. 
Essa função verifica se nas salas de espera ainda possuem senhas para ser consultadas e 
enquanto tiver senhas para ser consultadas ela chama uma senha de cada sala de espera 
para ser atendinda pelo consultorio da especialidade e so chama as senhas 
quando todos os consultorios estiverem "vazios".*/
void chamaParaConsulta(SalaE* s, Consultorio* c, int totalConsultorios);
void imprimiSenhasF(FilaS f); //apenas para ajudar a testar o codigo.
void imprimiSenhasP(PilhaS p); //apenas para ajudar a testar o codigo. 
//defines para agilizar os testes.
#define MAX_SENHA 10
#define MAX_CONSULTORIOS 4	//A,B,C,D...
//Main
int main(){
	FilaS f;
	Triagem t;
	SalaE* s;
	Consultorio* c;
	/* Nesse primeiro passo são criados todas as senhas para os atendimentos do dia
	e depois de criadas elas são passadas para o segundo passo.*/
	f = criaSenhas(MAX_SENHA, MAX_CONSULTORIOS, f);
	printf("\nTotal de senhas criadas: %d", MAX_SENHA * MAX_CONSULTORIOS);
	/* Neste segundo passo a triagem recebe a fila de senhas criadas no primeiro passo .*/
	t = criaTriagem(1, f);
	printf("\nTriagem recebeu a fila com sucesso!");
	/* No terceiro passo as senhas colocadas na triagem são emcaminhadas para as salas de espera especificas.*/
	s = encaminhaSalaEspera(t, MAX_CONSULTORIOS, MAX_SENHA);
	printf("\nSenhas encaminhadas com sucesso para salas de espera!");
	
	/* No quarto e ultimo passo as senhas são chamadas das salas de espera para os consultorios,
	 sempre que todos os consultorios estão livres e apenas uma senha por vez para cada consultorio*/
	
	printf("\nIniciando a chamada das senhas.");
	c = criaConsultorios(MAX_CONSULTORIOS);	
	
	chamaParaConsulta(s, c, MAX_CONSULTORIOS);
	
	printf("\nTodas as senhas atendidas!");
	getchar();
	
	return 0;
}
//Funções
FilaS f criaSenhas(int tam, int consultorios){
	int i = 0, j = 0, pos = 0;
	FilaS f = criaFilaS(1, MAX_SENHA * MAX_CONSULTORIOS); 
	for (i = 0; i < consultorios; i++){
		for (j = 0; j < tam; j++){
			Senha s = criaSenha(pos, (65 + i));
			enfileiraS(f, s);
			pos++;
		}
	}
	return f;
}
Consultorio* criaConsultorios(int consultorios){
	int i = 0;
	Consultorio* c = (Consultorio*) malloc(sizeof(Consultorio) * consultorios);
	for (i = 0; i < consultorios ; i++){
		c[i] = criaConsultorio(i, 65+i); 
	}
	return c;
}
void chamaParaConsulta(SalaE* s, Consultorio* c, int totalConsultorios){
	int i = 0,j = 0;
	while (!estaVaziaP(s[0].senhas)){
		
		for(i = 0; i < totalConsultorios; i++){
			Senha aux = desempilhaS(s[i].senhas);
			c[i].senhaAtendida = aux;
			printf("\n Senha: %d \n", c[i].senhaAtendida.id);
			printf("\n Por favor ir para o consultorio %c: \n", c[i].especialidade);
			
		}
		//Senha aux = desempilhaS(s[0].senhas);
		printf("Tecle enter para chamar as proximas senhas.");
		getchar();
	}
	
}
SalaE* encaminhaSalaEspera(Triagem t, int consultorios, int totalSenhasConsultorio){
	int i = 0, j = 0;
	SalaE* s = (SalaE*) malloc(sizeof(SalaE) * consultorios );
	for (i = 0; i < consultorios; i++){
		Senha* aux = (Senha*)malloc(sizeof(Senha)* totalSenhasConsultorio);
		PilhaS p = criaPilhaS(0, totalSenhasConsultorio);
		// Passo 1. Copia todas as senhas para um vetor auxiliar.
		for (j = 0; j < totalSenhasConsultorio; j++){
			aux[j] = desenfileiraS(t.senhas);
			
		}
		// Passo 2. Empilha todas as senhas na pilha para que sejam atendidas em ordem cresceste.
		for (j = 0; j < totalSenhasConsultorio; j++){
			empilhaS(p, aux[totalSenhasConsultorio-1 -j]);
		}
		//Passo 3. Coloca a pilha na Sala de Espera.
		s[i] = criaSalaE(i, 65 - i, p);
		
	}
	return s;
}
void imprimiSenhasP(PilhaS p){	
	while (!estaVaziaP(p)){
		Senha s = desempilhaS(p);
		printf("\nSenha: %d", s.id);
		printf("\nEspecialidade: %c \n", s.especialidade);
	}
}
void imprimiSenhasF(FilaS f){
	while (!estaVaziaF(f)){
		Senha s = desenfileiraS(f);
		printf("\nSenha: %d", s.id);
		printf("\nEspecialidade: %c \n", s.especialidade);
	}
}
teste01/pilhaS.c
struct pilhaS {
	int id;
	int topo;
	Senha* senhas;
};
typedef struct pilhaS* PilhaS;
PilhaS criaPilhaS(int id, int tam){
	PilhaS p = (PilhaS) malloc( sizeof(PilhaS) );
	p->senhas = (Senha*) malloc( sizeof(Senha) * tam);
	p->id = id;
	p->topo = 0;
	return p;
}
void empilhaS(PilhaS p, Senha s){
	p->senhas[p->topo] = s;
	p->topo++;
}
Senha desempilhaS(PilhaS p){
	p->topo--;
	return p->senhas[p->topo];
}
int estaVaziaP(PilhaS p){
	if (p->topo == 0) return 1;
	return 0;
}
teste01/salaE.c
struct salaE {
	int id;
	int especialidade;
PilhaS senhas;
};
typedef struct salaE SalaE;
	
SalaE criaSalaE(int id,int especialidade, PilhaS p){
	SalaE s;
	s.id = id;
	s.senhas = p;
	s.especialidade = especialidade;
	
	return s;
}
teste01/senha.c
struct senha{
	int id;
	int especialidade;
};
typedef struct senha Senha;
	
Senha criaSenha(int id, int especialidade){
	Senha s;
	s.id = id;
	s.especialidade = especialidade;
	return s;
}
teste01/triagem.c
struct triagem {
	int id;
	FilaS senhas;
};
typedef struct triagem Triagem; 
Triagem criaTriagem(int id, FilaS f){
	Triagem t;
	t.id = id;
	t.senhas = f;
	return t;
}