Ir ao conteúdo
  • Cadastre-se
petaLtek

Gravando arvores binarias dinâmicas em arquivo.dat

Recommended Posts

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 em cima... é 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 tô 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, vão 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 ja 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 ja 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.

Compartilhar este post


Link para o post
Compartilhar em outros sites

Crie uma conta ou entre para comentar

Você precisar ser um membro para fazer um comentário

Criar uma conta

Crie uma nova conta em nossa comunidade. É fácil!

Crie uma nova conta

Entrar

Já tem uma conta? Faça o login.

Entrar agora





Sobre o Clube do Hardware

No ar desde 1996, o Clube do Hardware é uma das maiores, mais antigas e mais respeitadas publicações sobre tecnologia do Brasil. Leia mais

Direitos autorais

Não permitimos a cópia ou reprodução do conteúdo do nosso site, fórum, newsletters e redes sociais, mesmo citando-se a fonte. Leia mais

×