Árvore B com Arquivos, implementada no Mint por Marcos Augusto.

• Download 6919.ArvoreB0001.tar.gz
• Enviar nova versão

Esconder código-fonte

/*ArvoreB.h ========================================================================================================================*/

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

#define maximo 400 //401//401*400
#define minimo 200

struct atendimento{
    char paciente[100]; 
    char terapeuta[100]; 
    char dia[20]; 
    char horario[50]; 
    char sala[20]; 
    char situacao[50]; 
};typedef struct atendimento atendimentos; 

struct arvoreB{
    atendimentos relatorios[maximo+1]; 
    int contador; 
    struct arvoreB *ponteiros[maximo+1]; 
};typedef struct arvoreB arvoreB; 
struct arvoreB *raiz; 

arvoreB* criarNo(atendimentos relatorios, arvoreB *filho);
void inserirInterno(atendimentos relatorios, int posicao, arvoreB *no, arvoreB *filho);
void separarNo(atendimentos relatorios, atendimentos *ponteiroRelatorios, int posicao, arvoreB *no, arvoreB *filho, arvoreB **novoNo);
int inserirNo(atendimentos relatorios, atendimentos *ponteiroRelatorios, arvoreB *no, arvoreB **filho);
void insercao (atendimentos relatorios);
void imprimir(arvoreB *noAtual);
void verificarAtendimentos(arvoreB *noAtual,atendimentos relatorios, int* contador);
void sorteia(void);
void carregaArquivo(void);
/*Fim da ArvoreB.h =====================================================================================================================*/
/*ArvoreB.c ===========================================================================================================================*/

#include "ArvoreB.h"

arvoreB* criarNo(atendimentos relatorios, arvoreB *filho){
    arvoreB* novo;
    novo = (arvoreB*)malloc(sizeof(arvoreB));
    novo->contador = 1;
    novo->relatorios[1] = relatorios;
    novo->ponteiros[0] = raiz;
    novo->ponteiros[1] = filho;
    return novo;
}

void inserirInterno(atendimentos relatorios, int posicao, arvoreB *no, arvoreB *filho){
    int contador = no->contador;
    while(contador>posicao){
        no->relatorios[contador+1] = no->relatorios[contador];
        no->ponteiros[contador+1] = no->ponteiros[contador];
        contador--;
    }
    no->relatorios[contador+1] = relatorios;
    no->ponteiros[contador+1] = filho;
    no->contador++;
}

void separarNo(atendimentos relatorios, atendimentos *ponteiroRelatorios, int posicao, arvoreB *no, arvoreB *filho, arvoreB **novoNo){
    int media, contador;
    if(posicao > minimo)
        media = minimo + 1;
    else
        media = minimo;
    *novoNo = (arvoreB*)malloc(sizeof(arvoreB));
    contador = media + 1;
    while(contador <= maximo){
        (*novoNo)->relatorios[contador - media] = no->relatorios[contador];
        (*novoNo)->ponteiros[contador - media] = no->ponteiros[contador];
        contador++;
    }
    no->contador = media;
    (*novoNo)->contador = maximo - media;
    if(posicao <= minimo){
        inserirInterno(relatorios,posicao,no,filho);
    }else{
       inserirInterno(relatorios,posicao-media,*novoNo,filho);
    }
    *ponteiroRelatorios = no->relatorios[no->contador];
    (*novoNo)->ponteiros[0] = no->ponteiros[no->contador];
    no->contador--;
}

int inserirNo(atendimentos relatorios, atendimentos *ponteiroRelatorios, arvoreB *no, arvoreB **filho){
    int posicao;
    if(!no){
        *ponteiroRelatorios = relatorios;
        *filho = NULL;
        return 1;
    }
    if(strcasecmp(no->relatorios[1].paciente,relatorios.paciente)>0){
        posicao = 0;
    }else{
          while((strcasecmp(no->relatorios[posicao].paciente,relatorios.paciente)>0 && posicao > 1)){
             posicao--;
             }
            if(strcasecmp(no->relatorios[posicao].paciente,relatorios.paciente) == 0){
            }
    }
    if(inserirNo(relatorios,ponteiroRelatorios,no->ponteiros[posicao],filho)){
        if(no->contador < maximo){
            inserirInterno(*ponteiroRelatorios,posicao,no,*filho);
        }else{
            separarNo(*ponteiroRelatorios,ponteiroRelatorios,posicao,no,*filho,filho);
            return 1;
        }
    }
    return 0;
}

void insercao (atendimentos relatorios){
    int flag;
    arvoreB *filho;
    atendimentos i;
    flag = inserirNo(relatorios,&i,raiz,&filho);
    if(flag)
        raiz = criarNo(i,filho);
}

void imprimir(arvoreB *noAtual){
    if(noAtual){
        int i = 0;
       while(i < noAtual->contador){
            imprimir(noAtual->ponteiros[i]);
            printf("Paciente = %s",noAtual->relatorios[i+1].paciente);
            printf("Terapeuta = %s",noAtual->relatorios[i+1].terapeuta);
            printf("Horario = %s",noAtual->relatorios[i+1].horario);
            printf("Situacao = %s",noAtual->relatorios[i+1].situacao);
            printf("Sala = %s",noAtual->relatorios[i+1].sala);
            printf("\n");
            i++;
        }
        imprimir(noAtual->ponteiros[i]);
    }
}


void verificarAtendimentos(arvoreB *noAtual,atendimentos relatorios, int* contador){
    if(noAtual){
         int i = 0;
         while(i < noAtual->contador){
            verificarAtendimentos(noAtual->ponteiros[i],relatorios,contador);
            if(strcasecmp(noAtual->relatorios[i+1].paciente,relatorios.paciente) == 0){
                (*contador)++;
            }
            i++;
        }
        verificarAtendimentos(noAtual->ponteiros[i],relatorios, contador);  
    }
}

void sorteia(void){
    int aleatorio;
    int contador = 1;
    char paciente[50];
    char terapeuta[50];
    char dia[50];
    char horario[50];
    char situacao[50];
    char sala[10];
    FILE *arquivoTerapeutas;
    FILE *arquivoPacientes;
    FILE *arquivoDias;
    FILE *arquivoHorarios;
    FILE *arquivoSituacoes;
    FILE *arquivoSalas;
    FILE *arquivoAtendimentos;

    arquivoAtendimentos = fopen("ArquivosAtendimentos.txt","r");

    aleatorio = rand()%30+1;
    arquivoPacientes = fopen("Pacientes.txt", "r");
   arquivoAtendimentos = fopen("ArquivosAtendimentos.txt", "a");

    while(fgets(paciente, sizeof paciente, arquivoPacientes) != NULL){
      if(aleatorio == contador){
       fgets(paciente, sizeof paciente, arquivoPacientes);
       fprintf(arquivoAtendimentos,"Paciente = %s",paciente);
       break;
      }
      ++contador;
    }
        aleatorio = rand()%59+1;
   contador = 1;

   arquivoTerapeutas = fopen("Terapeutas.txt", "r");
   while(fgets(terapeuta, sizeof terapeuta, arquivoTerapeutas) != NULL){
      if(aleatorio == contador){
      fgets(terapeuta, sizeof terapeuta, arquivoTerapeutas);
      fprintf(arquivoAtendimentos,"Terapeuta = %s",terapeuta);
       break;
      }
      ++contador;
   }

   aleatorio = rand()%100+1;
   contador = 1;

   arquivoDias = fopen("Dias.txt", "r");
   
    while(fgets(dia, sizeof dia, arquivoDias) != NULL){
         if(aleatorio == contador){
             fgets(dia, sizeof dia, arquivoDias);
             break;
         }
         ++contador;
   }

      aleatorio = rand()%4+1;
      contador = 1;

      arquivoHorarios = fopen("Horarios.txt", "r");
   
      while(fgets(horario, sizeof horario, arquivoHorarios) != NULL){
         if(aleatorio == contador){
             fgets(horario, sizeof horario, arquivoHorarios);
            fprintf(arquivoAtendimentos,"Horario = %s",horario);
             break;
         }
         ++contador;
      }

      aleatorio = rand()%11+1;
      contador = 1;

      arquivoSituacoes = fopen("Situacoes.txt", "r");
      while(fgets(situacao, sizeof situacao, arquivoSituacoes) != NULL){
         if(aleatorio == contador){
             fgets(situacao, sizeof situacao, arquivoSituacoes);
            fprintf(arquivoAtendimentos,"Situacao = %s",situacao);
             break;
         }
         ++contador;
      }

      aleatorio = rand()%3+1;
      contador = 1;

      arquivoSalas = fopen("Salas.txt", "r");
      while(fgets(sala, sizeof sala, arquivoSalas) != NULL){
         if(aleatorio == contador){
             fgets(sala, sizeof sala, arquivoSalas);
            fprintf(arquivoAtendimentos,"Local = %s",sala);
             break;
         }
         ++contador;
      }

    fprintf(arquivoAtendimentos, "--------------------------\n");
   fclose(arquivoSalas);
   fclose(arquivoSituacoes);
   fclose(arquivoDias);
   fclose(arquivoHorarios);
   fclose(arquivoPacientes);
   fclose(arquivoTerapeutas);
   fclose(arquivoAtendimentos);   
}

void carregaArquivo(void){
  int linhas = 0;
  atendimentos relatorios;
  FILE *arquivoAtendimentos;

  arquivoAtendimentos = fopen("ArquivosAtendimentos.txt","r");
    char paciente[50];
    char terapeuta[50];
    char dia[50];
    char horario[50];
    char situacao[50];
    char sala[50];

    while(linhas < 12500){
     fgets(paciente, sizeof paciente,arquivoAtendimentos);
     strcpy(relatorios.paciente,paciente);
     fgets(terapeuta, sizeof terapeuta,arquivoAtendimentos);
     strcpy(relatorios.terapeuta,terapeuta);
     fgets(horario, sizeof horario,arquivoAtendimentos);
     strcpy(relatorios.horario,horario);
     fgets(situacao, sizeof situacao,arquivoAtendimentos);
     strcpy(relatorios.situacao,situacao);
     fgets(sala, sizeof sala,arquivoAtendimentos);
     strcpy(relatorios.sala,sala);
     fgets(dia, sizeof dia,arquivoAtendimentos);
     linhas ++;
     insercao(relatorios);
    }
    fclose(arquivoAtendimentos);   
}  
/*Fim da ArvoreB.c ======================================================================================================================*/

/*ArvoreBmain.c ========================================================================================================================*/
# include "ArvoreB.c"
int main(){
    int contador = 0;
    int *pContador = &contador;
    atendimentos relatorios;
    int opcao;
    char nome[100];
    carregaArquivo();
    while (10) {
                printf("1. Pesquisar total de atendimentos de paciente arquivados\n");
                printf("2. Imprimir Arvore\n");
                printf("3. Sair\nDigite uma opcao:");
                scanf("%d", &opcao);
                switch (opcao) {
                         case 1:
                                printf("Digite o nome do paciente que deseja verificar:");
                                __fpurge(stdin);
                                fgets(nome, sizeof(nome), stdin);
                                strcpy(relatorios.paciente,nome);
                                verificarAtendimentos(raiz,relatorios, pContador);
                                system("clear");
                                printf("\nO paciente %s foi atendido %d vezes\n",relatorios.paciente,contador);
                                contador = 0;
                                break;
                        case 2:
                                imprimir(raiz);
                                break;
                        case 3:
                                exit(0);
                         default:
                                printf("Opcao invalida!\n");
                                break;
                }
                printf("\n");
    }
}
/*Fim ArvoreBmain.c ===================================================================================================================*/

Mudando Cor da Letra e Fundo de Tela

Jantar dos Filósofos - Programação Paralela

Registro

Sudokou em C feito com matrizes e listas

Programa recursivo para obter raiz quadrada

Nenhum comentário foi encontrado.