Gravando Arvores Binarias Dinâmicas em arquivo.dat

[petalpusher]

Ola meus caros geeks...estou correndo contra o relógio... tenho 6 dias para entregar e travei... meu código tem muitas coisas desnecessárias, me perdi no meio do lixo todo, não estou conseguindo retornar ponteiro de um nó, não tenho a menor ideia de como implementar, estou praticamente f*****, continuar na facu depende desse trabalho, tive muitas provas e não tive tempo para trabalhar encima... é para fazer em grupo de 3 pessoas e eu não tenho grupo e sozinho não vou conseguir atender o prazo precisaria de umas 2 ou 3 semanas e tenho só 6 dias, trabalho e estudo dormindo 6hs por dia... peço ajuda ao veteranos que tem mais "pegada" para me ajudar com o código.

as vezes um pequeno esforço de um grande, se torna uma enorme ajuda para um pequeno...

agradeço de coração quem puder ajudar... tenho até terça para entregar... e estou f*****

 

eu tenho 5 arquivos e já estruturei varias funções menos a parte de arquivo....

são 2 arvores, uma partido e outra candidatos, vao salvando todos os dados em arquivo binario.

main,c
           tad.h
          tad.c
         candidatos.h
         candidatos.c

uma aplicação em C para cadastrar os partidos e candidatos às eleições. Os dados de um partido são os seguintes: número, sigla e nome. O número do partido deve ser um valor maior do que 10 e menor que 100. Os dados de um candidato são: número e nome. Os dois primeiros dígitos do número do candidato correspondem ao número do seu partido (faça uma entrada de dados consistente e sem redundância). O número do candidato também informa o cargo que ele pleiteia: se o número do candidato tiver apenas dois dígitos (correspondentes ao número de seu partido), então trata-se de um candidato a prefeito; se o número do candidato possui 5 dígitos, então trata-se de um candidato a vereador.

O programa deve ser conduzido por menu com as seguintes opções:

• Cadastrar partido: solicita o número, sigla e nome de um ou mais partidos, sem permitir dois ou mais partidos com o mesmo número;

• Alterar um partido: dado o número do partido, é possível alterar sua sigla ou nome;

• Excluir um partido: dado o número do partido, excluir o partido e todos os seus candidatos;

• Cadastrar candidato a prefeito: solicita o número do partido, mostra sua sigla, e depois solicita o nome do candidato, sem permitir dois ou mais candidatos com o mesmo número;

• Cadastrar candidato a vereador: solicita o número do partido, mostra sua sigla, e depois solicita o número e o nome de um ou mais candidatos desse partido, sem permitir dois ou mais candidatos com o mesmo número (lembre-se que os 2 primeiros dígitos no número do candidato são o número do seu partido);

• Alterar um candidato: dado o número de um candidato, permite alterar seu nome;

• Excluir um candidato: dado o número do candidato, excluí-lo do cadastro;

• Listar todos os partidos: deve permitir a listagem de todos os partidos cadastrado, exibindo em formato de tabela seu número, sigla e nome ordenados pelo número do partido;

• Listar candidatos a prefeito: deve permitir a listagem no formato de tabela de todos os candidatos a prefeito cadastrados ordenados pelo número, exibindo a sigla do partido, o número e o nome do candidato.

• Listar candidatos a vereador de um partido: deve solicitar o número do partido e exibir o nome do partido e uma listagem no formato de tabela contendo o número e o nome de todos os candidatos a vereador desse partido ordenados pelo seu número. Todas as informações a respeito dos partidos e candidatos devem ser armazenadas nos arquivos partidos.dat e candidatos.dat, respectivamente. Quando o programa é executado, ele cria automaticamente uma árvore binária de busca para cada arquivo, onde cada nó corresponde a um partido ou candidato. A partir daí, o único meio de acesso às informações deve ser através dessas árvores.

O programa deve permitir que o arquivo e a árvore sejam atualizados quando um novo candidato ou partido é cadastrado, alterado ou excluído. Para permitir a atualização dos arquivos nas operações sem a necessidade de uma busca sequencial nos arquivos, cada nó da árvore também deve armazenar a posição do registro correspondente no arquivo. A operação de exclusão não exclui fisicamente o registro do arquivo, apenas da árvore. Os registros excluídos devem ser sinalizados com 0 (zero) no número do partido ou candidato. Esses registros não devem ser carregados nas árvores.

#include <stdio.h>
#include <stdlib.h>
#include "candidatos.h"
#include "tad.h"

int main()
{
    BinTree* treeParty = init_bintree();
    int op;
    do
    {
        printf("\n\n\t [ CANDIDATOS A ELEICAO v1.0 ]\n\n");
        printf("\t <1> Cadastrar Partido\n"); //add_Party
        printf("\t <2> Alterar Partido\n"); // mod_Party
        printf("\t <3> Excluir Partido\n"); // del_Party
        printf("\t <4> Cadastrar candidato a Prefeito\n"); // add_Mayor
        printf("\t <5> Cadastrar candidato a Vereador\n"); // add_Alderman
        printf("\t <6> Alterar um candidato\n"); //mod_Candidate
        printf("\t <7> Excluir candidato\n"); // del_Candidate
        printf("\t <8> Listar todos os partidos\n"); // print_Partys
        printf("\t <9> Listar candidatos a prefeito\n"); // print_Mayors
        printf("\t<10> Listar candidatos a vereador de um partido\n"); // print_Aldermans_party
        printf("\t <0> Sair\n");
        printf("\n\t Opcao: ");
        scanf("%d", &op);
        switch (op)
        {
        case 1:
            add_Party();
//            struct NODE* newNode = (node*) malloc(sizeof(newNode));
//            newNode->dat_pos= 1;
//            break;
        case 2:
            mod_Party();
            break;
        case 3:
            del_Party();
            break;
        case 4:
            add_Mayor();
            break;
        case 5:
            add_Alderman();
            break;
        case 6:
            mod_Candidate();
            break;
        case 7:
            del_Candidate();
            break;
        case 8:
            print_Partys();
            break;
        case 9:
            print_Mayors();
            break;
        case 10:
            print_Alderman_party();
            break;
        case 0:
            break;
        default:
            system("cls");
            printf("\nOpcao invalida!");
        }
    }
    while (op != 0);
    return 0;
}

 

#ifndef _TAD_H
#define _TAD_H
#include <stdbool.h>

typedef struct NODE* BinTree;
typedef struct NODE node;
BinTree* init_bintree();
struct NODE* init_node();
void free_BinTree(BinTree *);
int isempty_BinTree(BinTree *);
int depth_BinTree(BinTree *);
int howMany_nodes(BinTree *);
int ins_node_bintree(BinTree *, struct NODE*);
int ins_BinTree(BinTree *,int);
int del_node_bintree(BinTree *,int);
struct NODE* remove_node(struct NODE*);

#endif

 

 

#include "tad.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

struct NODE
{
    int num;
    char initials[7];
    char name[35];
    int dat_pos;
    struct NODE *left;
    struct NODE *right;
};

BinTree* init_bintree()
{
    BinTree* root = (BinTree*) malloc(sizeof(BinTree));
    if(root != NULL)
        *root = NULL;
    return root;
}

struct NODE* init_node()
{
    struct NODE* newNode = (struct NODE*) malloc(sizeof(struct NODE));
    return newNode;
};

void free_node(struct NODE* node)
{
    if(node == NULL)
    {
        return;
    }
    free_node(node->left);
    free_node(node->right);
    free(node);
    node = NULL;
}

void free_BinTree(BinTree* root)
{
    if(root == NULL)
        return;
    free_node(*root);
    free(root);
}

int isempty_BinTree(BinTree *root)
{
    if(root == NULL)
        return 1;
    if(*root == NULL)
        return 1;
    return 0;
}

int depth_BinTree(BinTree *root)
{
    if(root == NULL)
        return 0;
    if(*root == NULL)
        return 0;
    int depth_left = depth_BinTree(&((*root)->left));
    int depth_right = depth_BinTree(&((*root)->right));
    if(depth_left > depth_right)
        return(depth_left + 1);
    else
        return(depth_right + 1);
}

int howMany_nodes(BinTree *root)
{
    if(root == NULL)
        return 0;
    if(*root == NULL)
        return 0;
    int depth_left = howMany_nodes(&((*root)->left));
    int depth_right = howMany_nodes(&((*root)->right));
    return(depth_left + depth_right + 1);
}

int ins_node_bintree(BinTree* root, struct NODE* newNode)
{
    if(root == NULL)
        return 0;
    if(newNode == NULL)
        return 0;
    newNode->right = NULL;
    newNode->left = NULL;
    if(*root == NULL)
        *root = newNode;
    else
    {
        struct NODE* current = *root;
        struct NODE* previous = NULL;
        while(current != NULL)
        {
            previous = current;
            if(newNode->num == current->num)
            {
                free(newNode);
                return 0; //elemento já exite
            }
            if(newNode->num > current->num)
                current = current->right;
            else
                current = current->left;
        }
        if(newNode->num > previous->num)
            previous->right = newNode;
        else
            previous->left = newNode;
    }
    return 1;
}

int ins_BinTree(BinTree* root,int value)
{
    if(root == NULL)
        return 0;
    struct NODE* newNode;
    newNode = (struct NODE*) malloc(sizeof(struct NODE));
    if(newNode == NULL)
        return 0;
    newNode->num = value;
    newNode->right = NULL;
    newNode->left = NULL;
    if(*root == NULL)
        *root = newNode;
    else
    {
        struct NODE* current = *root;
        struct NODE* previous = NULL;
        while(current != NULL)
        {
            previous = current;
            if(value == current->num)
            {
                free(newNode);
                return 0; //elemento já exite
            }
            if(value > current->num)
                current = current->right;
            else
                current = current->left;
        }
        if(value > previous->num)
            previous->right = newNode;
        else
            previous->left = newNode;
    }
    return 1;
}

int del_node_bintree(BinTree *root,int value)
{
    if(root == NULL) return 0;
    struct NODE* previous = NULL;
    struct NODE* current = *root;
    while(current != NULL)
    {
        if(value == current ->num)
        {
            *root = remove_node(current);
        }
        else
        {
            if(previous->right == current)
                current->right = remove_node(current);
            else
                previous->left = remove_node(current);
        }
        return 1;
    }
    previous = current;
    if(value > current->num)
    {
        current = current->right;
    }
    else
    {
        current = current->left;
    }
    return 0;
}

struct NODE* remove_node(struct NODE* current)
{
    struct NODE *node1, *node2;
    if(current->left == NULL)
    {
        node2 = current->right;
        free(current);
        return node2;
    }
    node1 = current;
    node2 = current->left;
    while(node2->right != NULL)
    {
        node1 = node2;
        node2 = node2->right;
    }
    if(node1 != current)
    {
        node1->right = node2->left;
        node2->left = current->left;
    }
    node2->right = current->right;
    free(current);
    return node2;
}

void preordem_bintree(BinTree *root)
{
    if(root == NULL)
        return;
    if(*root == NULL)
    {
        printf("%d\n",(*root)->num);
        preordem_bintree(&((*root)->left));
        preordem_bintree(&((*root)->right));
    }
}

void emordem_bintree(BinTree *root)
{
    if(root == NULL)
        return;
    if(*root != NULL)
    {
        emordem_bintree(&((*root)->left));
        printf("%d\n",(*root)->num);
        emordem_bintree(&((*root)->right));
    }
}


int query_bintree(BinTree *root, int value)
{
    if(root == NULL)
        return 0;
    struct NODE* current = *root;
    while(current != NULL)
    {
        if(value == current->num)
        {
            return 1;
        }
        if(value > current->num)
            current = current->right;
        else
            current = current->left;
   }
    return 0;
}

#ifndef _CANDIDATOS_H
#define _CANDIDATOS_H
#include <stdbool.h>


/* função que adiciona Partido solicita numero, sigla e nome  */
bool add_Party();

/* função que dado o numero do partido Altera sua Sigla ou Nome  */
bool mod_Party();

/* função que deleta Partido dado seu numero junto a todos seus candidatos  */
bool del_Party();

/* função que adiciona Prefeito solicita numero do partido,
 mostra a sigla e solicita o nome  */
bool add_Mayor();

/* função que adiciona Vereador solicita numero do partido,
 mostra a sigla e solicita o nome  */
bool add_Alderman();

/* função que dado o numero do candidato permite altera seu nome  */
bool mod_Candidate();

/* função que dado o numero do candidato, exclui dito candidato  */
bool del_Candidate();

/* função que mostra em tabela todos os partidos, seu numero,
sigla e nome ordenados pelo numero do partido  */
void print_Partys();

/* função que mostra em tabela todos os candidatos a prefeito
ordenados pelo numero, exibindo a sigla, o numero e o nome do candidato  */
void print_Mayors();

/* função que solicita o numero do partido e exibe nome do partido e
uma listagem no formato de tabela contendo o numero e o nome de
todos os vereadores desse partido ordenado por nome */
void print_Alderman_party();

#endif

#include "candidatos.h"
#include "tad.h"
#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

bool add_Party()
{
//            struct NODE* newNode = (struct NODE*) malloc(sizeof(struct NODE));

//            struct NODE* newNode = (node*) malloc(sizeof(newNode));

            newNode->dat_pos= 1;

            system("cls");
            printf("\n\n\t [ CANDIDATOS A ELEICAO v1.0 ]\n\n");
            printf("\t <1> Cadastrar Partido\n\n"); //add_Partido

            printf("\t     Inserir Numero: ");
//            scanf("%d", &newNode->num);
            printf("\t     Inserir Sigla: ");
//            scanf("%6s", &newNode->initials);
            printf("\t     Inserir Nome: ");
//            scanf("%34[^\n]s", &newNode->name);


//            ArvBin* node = init_node();
//            scanf("%d", );
//            printf("\t     Inserir Sigla: ");
//            scanf("%6s", &node->sigla);
//            scanf("%[^\n]s",a);
//            printf("\t     Inserir Nome: ");
//            scanf("%6s", &node->nome);

return false;}
bool mod_Party()
{return false;}
bool del_Party()
{return false;}
bool add_Mayor()
{return false;}
bool add_Alderman()
{return false;}
bool mod_Candidate()
{return false;}
bool del_Candidate()
{return false;}
void print_Partys()
{;}
void print_Mayors()
{;}
void print_Alderman_party()
{;}

desde já obrigado.