patrickrudgeri / trabalho_ed2

Trabalho de Estrutura de Dados II - UFJF

Parte 1

Instruções para executar o programa

1. Colocar o dataset no diretório dataset/
2. executar o comando: cd bin && ./trabalho_ed2 [<nomeDataset>.csv].

Obs: trocar <nomeDataset>.csv pelo nome do dataset. Se o nome do dataset possui espaços colocar entre aspas duplas.

Métricas foram utilizadas:

• N° de comparações de chaves;
• N° de cópias de registros realizadas;
• Tempo total gasto (processamento);

Estrutura do projeto:

.
├── bin
│   └── trabalho_ed2
├── CMakeLists.txt
├── dataset
│   ├── authors.csv
│   └── dataset_simp_sem_descricao.csv
├── include
│   ├── csvLivros.hpp
│   ├── DataFrameLivros.hpp
│   ├── metricas.hpp
│   ├── Registro.hpp
│   ├── secao_2
│   │   ├── Autor.hpp
│   │   ├── HashAutor.hpp
│   │   ├── HashRegistro.hpp
│   │   └── Primo.hpp
│   ├── secao_3
│   │   ├── ArvoreB.h
│   │   ├── AVP.hpp
│   │   ├── NoB.h
│   │   └── noVP.hpp
│   └── txtLivros.hpp
├── io
│   ├── secao_1
│   │   ├── entrada.txt
│   │   ├── saida.txt
│   │   └── stats
│   │       ├── stats_comp.txt
│   │       ├── stats_tempo.txt
│   │       └── stats_trocas.txt
│   ├── secao_2
│   │   └── stats
│   │       └── freq_autores.txt
│   └── secao_3
│       ├── entrada.txt
│       ├── saidaBusca.txt
│       ├── saidaInsercao.txt
│       └── stats
│           ├── busca
│           │   ├── stats_comp.txt
│           │   ├── stats_tempo.txt
│           │   └── stats_trocas.txt
│           └── insercao
│               ├── stats_comp.txt
│               ├── stats_tempo.txt
│               └── stats_trocas.txt
├── README.md
└── src
    ├── csvLivros.cpp
    ├── DataFrameLivros.cpp
    ├── main.cpp
    ├── metricas.cpp
    ├── Registro.cpp
    ├── secao_2
    │   ├── Autor.cpp
    │   ├── HashAutor.cpp
    │   ├── HashRegistro.cpp
    │   └── Primo.cpp
    ├── secao_3
    │   ├── ArvoreB.cpp
    │   ├── AVP.cpp
    │   ├── NoB.cpp
    │   └── noVP.cpp
    └── txtLivros.cpp

Entrega:

• PARTE 1 (Seção 1): 23/10
• PARTE 2 (Seções 2 e 3): 25/11

Integrantes:

• Patrick Rudgéri Pilato Lemes
• Dauane Joice Nascimento de Almeida
• Larissa de Lima e Silva
• Luciana Paixão Motta

trabalho_ed2's Issues

verificar

verificar

trabalho_ed2/src/secao_2/HashRegistro.cpp

Line 44 in 59f45d4

//fixme: verificar

// --------------------- Métodos privados -------------------- //

/**
* Função calculaHash eh responsável por calcular o valor da hash com base na chave e no numero de colisoes ja ocorridas
* @param ch chave referente ao Registro
* @param numColisoes numero de colisoes ocorridas ate o momento
* @return valor encontrado
*/
int HashRegistro::calculaHash(int ch, int numColisoes) {
    //variável do tipo  long para calcular o valor obitido pela equação quadratica usada no segundo termo da equacao hash
    long valorQuadratica = pow(ch, 2) - 5 * ch + 7;

    //vari�vel do tipo inteira que recebe o valor calculado para a hash
    int valorHash = (int) (((long) ch + (long) numColisoes * valorQuadratica) % tamanhoTabela_);

    //se o valor da equacao para o numero de colisoes fornecida for igual ao numero da chave, isso implica na consulta
    //dos mesmos valores já testados logo retorna-se -1, que indica que não foi encontrada posicao
    if (valorHash == ch) return -1;
    //fixme: verificar
    //if (numColisoes == tamanhoTabela_)
    //    return -1;
    else
        return valorHash;
}

/**
* Função recursiva funcaoHash eh responsável por encontrar uma posicao na Tabela Hash com base na chave referente ao Registro
* @param ch chave referente ao Registro
* @param numColisoes numero de colisoes ocorridas ate o momento
* @return posicao encontrada
*/
int HashRegistro::funcaoHash(int ch, int numColisoes) {
    //variável do tipo inteira que recebe a posicao calculada para os valores passados
    int indiceTabela = calculaHash(ch, numColisoes);

    //se não há registro
    if (indiceTabela == -1)
        return -1;

    //variavel do tipo Registro que axilia a saber se a posicao já se encontra ocupada
    Registro *aux;
    aux = &tabelaRegistros_[indiceTabela];

    if (aux->getId() == -1) { //Se essa posição está vazia_
        return indiceTabela;

    } else {
        //Senao calcula nova posiçãoo na tabela
        return funcaoHash(ch, numColisoes + 1);
    }
}

/**
* Função calculaChave eh responsável por calcular a chave utilizada na funcao hash
 * @param id id do livro
 * @return ch chave a ser utilizada na funcao hash
*/
int HashRegistro::calculaChave(long long id) {
    long long ch = 0;
    for (int i = 1; i <= 4; i++) {

5225d41e90d37a902b54b5b0b40150fab160905b

corrigir

corrigir

trabalho_ed2/src/csvLivros.cpp

Line 161 in 2654364

randomNumeros[numRegistro] = gerarRandomNum(++seed, 0, tamArq - 1); //fixme: corrigir

            replace(linhaTemp.begin(), linhaTemp.end(), (char) 13, ' ');

            inserido = processarLinhaRegistro(df, linhaTemp, numRegistro);

            //Se o registro foi inserido incrementa o contador, caso contrário busca um novo registro aleatório
            if (inserido) {//TODO: quando inserção estiver ok, descomentar
//
                numRegistro++;
            }else{
                cout << linhaTemp << " " << numRegistro <<endl; // fixme: debug
                randomNumeros[numRegistro] = gerarRandomNum(++seed, 0, tamArq - 1); //fixme: corrigir
            }
        }
        //fechando o arquivo
        arquivo.close();
//        delete [] randomNumeros;
    }

    //TODO question: processar authors.csv
ndex 90a7b29..7ac4f05 100755
++ b/src/main.cpp

69780a46684883502a31d6bf1fcbc409cb2b340b

debug

debug

trabalho_ed2/src/secao_2/HashRegistro.cpp

Line 18 in 59f45d4

//cout << "Tamanho da tabela hash de registros: " << tamanhoTabela_ << endl; //fixme:debug

#include "../../include/secao_2/HashRegistro.hpp"
#include "../../include/secao_2/Primo.hpp"

using namespace std;

/**
    * Cria a tabela Hash com preenchimento m�ximo de 80% com base no n�mero de dados. Escolhesse o menor primo que atende esse requisito.
    * @param n Tamanho da tabela Hash a ser criada
    */
HashRegistro::HashRegistro(int n) {
    tamanhoTabela_ = (int) (n / 0.8);
    tamanhoTabela_ = Primo::proxPrimo(tamanhoTabela_);

    //se == -1 então deu erro. Para o programa e lança um erro
    assert(tamanhoTabela_ != -1);

    //cout << "Tamanho da tabela hash de registros: " << tamanhoTabela_ << endl; //fixme:debug
    tabelaRegistros_ = new Registro[tamanhoTabela_];
}

27ff46f2caa48ba6432874c5927052304429bc12

debug

debug

if (registrosTable[i].getId() == -1) continue;

trabalho_ed2/src/DataFrameLivros.cpp

Line 107 in 59f45d4

// cout << registrosTable[i].getId() << endl;//fixme: debug

    armazInterno_ = armazInterno;

    // se a ED interna é hash table então aloca a tabela hash
    if (armazInterno_ == ED::HASH_TABLE) {

        hashRegistros_ = new HashRegistro(numLinhas_);

    } else if (armazInterno_ == ED::VETOR) {
        // se ED interna é vetor aloca um vetor de Registros de tamanho `numLinhas`
        registros_ = new Registro[numLinhas_];

    } else if (armazInterno_ == ED::ARVORE) {
        // se ED interna é arvore aloca um vetor de Registros de tamanho `numLinhas`
        arvoreVP_ = new AVP();
        arvoreB_ = new ArvoreB();
    }
    //preenche o data frame com os valores lidos do csv
    csv::lerRegistros(this, nomeArquivo, numLinhas, aleatorio, seed);

    if (armazInterno_ == ED::HASH_TABLE) {
        //Com o dataframe, hashRegistros_ e a quantidade de autores preenchidos, podemos criar a hash de autores

        hashAutores_ = new HashAutor(countTotalAutores_);
//        int tamHashRegistros;
//        Registro *registrosTable;
//        int *autoresIds;
//        int qtAutores;
//
//        tamHashRegistros = Primo::proxPrimo(numLinhas_);
//        registrosTable = hashRegistros_->getTabelaRegistros();
//
//        for (int i = 0; i < tamHashRegistros; i++) {
            // se é uma posição vazia, então passa para a proxima posição
//            cout << registrosTable[i].getId() << endl;//fixme: debug
//            if (registrosTable[i].getId() == -1) continue;
//
//            Registro reg = registrosTable[i];
//            autoresIds = reg.getAutores();
//            qtAutores = reg.getQtAutores();
//            cout << reg.getQtAutores() << endl; //fixme: debug
//            for (int j = 0; j < qtAutores; j++) {
//                int autorId = autoresIds[j];
//                if(autorId != -1) {
//                    auto *autor = new Autor();
//                    autor->setId(autorId);
//                    cout << autor->getId() << endl; //fixme: debug
////                    hashAutores_->inserir(autor);
//                    delete autor;
//                }
//            }
//        }
        //TODO: Dentro dessa função, percorrer csv e adicionar nome dos autores da tabela hash
//        csv::lerAutores("../dataset/authors.csv", hashAutores_);
    }
    else if (armazInterno_ == ED::ARVORE) {
        //Obtendo as quantidades de comparações e trocas realizadas pelas arvores
        contComparacoes1_ = arvoreVP_->getQtdComparacoes();
        contTrocas1_ = arvoreVP_->getQtdTrocas();

//        contComparacoes2_ = arvoreB_->getQtdComparacoes();
//        contTrocas2_ = arvoreB_->getQtdTrocas();
    }
}

bool DataFrameLivros::inserirRegistro(std::string *camposStrVet, int index) {
    bool statusInsercao;
    if (armazInterno_ == ED::HASH_TABLE) {
        auto *reg = new Registro();
        reg->setTodosAtributosStr(camposStrVet);

        // será true se registro é unico, ou false se 'repetido
        statusInsercao = hashRegistros_->buscar(reg->getId()) == -1;

        //se for livro único então inserir na tabela hash de registros, busca e os autores na tabela hash de autores
        if (statusInsercao) {
            countTotalAutores_ += reg->getQtAutores();
            hashRegistros_->inserir(reg);
        }

551441772de917c6573950a30b439eb1af263587

verificar

verificar

delete[] autores_;

delete[] categorias_;

trabalho_ed2/src/Registro.cpp

Line 20 in 59f45d4

//fixme: verificar

// --------------- Construtores e Destrutores ---------------- //

Registro::Registro() {
    autores_ = nullptr;
    categorias_ = nullptr;
    id_ = -1;
    regQtAutores_ = -1;
    regQtCategorias_ = -1;
}

Registro::~Registro() {
    //fixme: verificar
//    delete[] autores_;
//    delete[] categorias_;
}

// -------------------------- Sets --------------------------- //

55663f4efde96665f5e9e30f28b9e7fc4c17909f

Testando issue automation

Testando issue automation

trabalho_ed2/src/TxtLivros.cpp

Line 31 in 2d52019

//fixme: Testando issue automation

}

//fixme: Testando issue automation
// labels: bug, enhancement
void TxtLivros::lerSaida(Stats *&stats, const std::string &nomeArqSaida) {
    string linha, strExec, strStats;
    ifstream arq("../io/" + nomeArqSaida);

90fe21a2ee4ed2a9acba91b640c31326fa4f4ae7

Dúvida sobre tipo correto de variável

@larissalimaa: (essa variável maior) seria do tipo inteiro ou do tipo string?

debug

debug

trabalho_ed2/src/secao_2/HashRegistro.cpp

Line 119 in 2654364

cout << "Tabela vazia" << endl; //fixme: debug

#include "../../include/secao_2/Primo.hpp"

using namespace std;

//Larissa: (TODO) Luci, justifique por favor porque você fez "n/0.75"
/**
* Cria a tabela Hash fazendo (...)
* @param n Tamanho da tabela Hash a ser criada
*/
HashRegistro::HashRegistro(int n) {
    tamanhoTabela = (int) (n / 0.75);
    tamanhoTabela = Primo::proxPrimo(tamanhoTabela);
    cout << "Tamanho da tabela hash de registros: " << tamanhoTabela << endl;
    tabelaRegistros = new Registro[tamanhoTabela];
}

HashRegistro::~HashRegistro() {
    delete[] tabelaRegistros;
}

// --------------------- Métodos privados -------------------- //

/**
* TODO: Descreva o que esse método faz
*
*/
int HashRegistro::calculaHash(int ch, int i) {

    //vari�vel do tipo inteira para calcular a melhor funcao quadratica
    int valorQuadratica = pow(ch, 2) - 5 * ch + 7;

    //vari�vel do tipo ...
    int valorHash = (ch + i * valorQuadratica) % tamanhoTabela;
    //question (Larissa): Porque essa verificacao?
    //para ver se j� foi dada uma volta completa. Ela chegar no mesmo valor da chave original, implica em ela repetir o mesmo caminho depois.
//    if (valorHash == ch)
    if (i == tamanhoTabela) //question (Patrick): não seria essa a forma correta de dar uma volta completa?
        return -1;
    else
        return valorHash;
}

/**
* question (Larissa): Luci, funcaoHash retorna um indice baseada se eh um Registro ou não?
* TODO: Descrever o que esse método faz
*/
int HashRegistro::funcaoHash(int ch, int i) {
    //variável do tipo ...
    int indiceTabela = calculaHash(ch, i);

    //se não há registro ou autor no indice?
    if (indiceTabela == -1)
        return -1;

    //question (Larissa): Ponteiro auxiliar do tipo Registro
    Registro *aux;
    //question (Larissa): Aux aponta para a tabela no indice calculado?
    aux = &tabelaRegistros[indiceTabela];
    //question (Larissa): Se aux eh null retorna o indice???? Achei estranho
//    cout << ">>> " << aux->getId() << endl;
    if (aux->getId() == -1) { //Se essa posição está vazia
        cout << indiceTabela << endl;
        return indiceTabela;

    } else {
        //Senao calcula nova posiçãoo na tabela
        return funcaoHash(ch, i + 1);
    }
}

//Larissa: Luci, calculachave eh a fun��o hash de divis�o Para livro? N�o, ela s� retorna um n�mero para ser usado na hash
int HashRegistro::calculaChave(long long id) {
    long long ch = 0;
    for (int i = 1; i <= 4; i++) {
        ch += id % 10000;
        id /= 10000;
    }
    return (int) ch;
}

// --------------------- Métodos públicos -------------------- //

/**
* Função inserir eh responsável por colocar um Registro na Tabela Hash de Livros
*
*/
void HashRegistro::inserir(Registro *p) {

    //Variavel do tipo inteira que recebe a chave a ser utilizada na hash
    if (p != nullptr) {
        int ch = calculaChave(p->getId());

        int pos = funcaoHash(ch, 0);

        //question (Larissa): Luci, tem duas variaveis para receber a posicao? Por que?

        // Essa função é a que retorna a posição candidata

        if (pos == -1) {
            cout << "Não foi possivel inserir o valor" << endl;
        }else {
            if (vazia) {
                vazia = false;
            }
            tabelaRegistros[pos] = *p;
        }
    }
}


int HashRegistro::buscar(long long id) {
    int pos; //variavel do tipo...
    int ch; //variavel do tipo...
    int i;
    Registro *aux;

    if (vazia) {
        cout << "Tabela vazia" << endl; //fixme: debug
        return -1;
    }
    ch = calculaChave(id);

    i = 0;
    while (true) {
        pos = calculaHash(ch, i);
        aux = &tabelaRegistros[pos];
        if (i == tamanhoTabela || aux->getId() == id) {
            break;
        }
        i++;
    }
    if (aux->getId() == -1) { //não encontrou, retorna -1
        return -1;
    } else {
        return pos; // caso contrário retorna a posição encontrada
    }
}

ndex 2736351..50d5e7f 100644
++ b/src/secao_2/Primo.cpp

3f9f4033ffada1521d9850934280a3af6a01f7b4

debug

debug

hashAutores_->inserir(autor);

delete autor;

}

}

}

trabalho_ed2/src/DataFrameLivros.cpp

Line 119 in 59f45d4

// cout << autor->getId() << endl; //fixme: debug

    // se a ED interna é hash table então aloca a tabela hash
    if (armazInterno_ == ED::HASH_TABLE) {

        hashRegistros_ = new HashRegistro(numLinhas_);

    } else if (armazInterno_ == ED::VETOR) {
        // se ED interna é vetor aloca um vetor de Registros de tamanho `numLinhas`
        registros_ = new Registro[numLinhas_];

    } else if (armazInterno_ == ED::ARVORE) {
        // se ED interna é arvore aloca um vetor de Registros de tamanho `numLinhas`
        arvoreVP_ = new AVP();
        arvoreB_ = new ArvoreB();
    }
    //preenche o data frame com os valores lidos do csv
    csv::lerRegistros(this, nomeArquivo, numLinhas, aleatorio, seed);

    if (armazInterno_ == ED::HASH_TABLE) {
        //Com o dataframe, hashRegistros_ e a quantidade de autores preenchidos, podemos criar a hash de autores

        hashAutores_ = new HashAutor(countTotalAutores_);
//        int tamHashRegistros;
//        Registro *registrosTable;
//        int *autoresIds;
//        int qtAutores;
//
//        tamHashRegistros = Primo::proxPrimo(numLinhas_);
//        registrosTable = hashRegistros_->getTabelaRegistros();
//
//        for (int i = 0; i < tamHashRegistros; i++) {
            // se é uma posição vazia, então passa para a proxima posição
//            cout << registrosTable[i].getId() << endl;//fixme: debug
//            if (registrosTable[i].getId() == -1) continue;
//
//            Registro reg = registrosTable[i];
//            autoresIds = reg.getAutores();
//            qtAutores = reg.getQtAutores();
//            cout << reg.getQtAutores() << endl; //fixme: debug
//            for (int j = 0; j < qtAutores; j++) {
//                int autorId = autoresIds[j];
//                if(autorId != -1) {
//                    auto *autor = new Autor();
//                    autor->setId(autorId);
//                    cout << autor->getId() << endl; //fixme: debug
////                    hashAutores_->inserir(autor);
//                    delete autor;
//                }
//            }
//        }
        //TODO: Dentro dessa função, percorrer csv e adicionar nome dos autores da tabela hash
//        csv::lerAutores("../dataset/authors.csv", hashAutores_);
    }
    else if (armazInterno_ == ED::ARVORE) {
        //Obtendo as quantidades de comparações e trocas realizadas pelas arvores
        contComparacoes1_ = arvoreVP_->getQtdComparacoes();
        contTrocas1_ = arvoreVP_->getQtdTrocas();

//        contComparacoes2_ = arvoreB_->getQtdComparacoes();
//        contTrocas2_ = arvoreB_->getQtdTrocas();
    }
}

bool DataFrameLivros::inserirRegistro(std::string *camposStrVet, int index) {
    bool statusInsercao;
    if (armazInterno_ == ED::HASH_TABLE) {
        auto *reg = new Registro();
        reg->setTodosAtributosStr(camposStrVet);

        // será true se registro é unico, ou false se 'repetido
        statusInsercao = hashRegistros_->buscar(reg->getId()) == -1;

        //se for livro único então inserir na tabela hash de registros, busca e os autores na tabela hash de autores
        if (statusInsercao) {
            countTotalAutores_ += reg->getQtAutores();
            hashRegistros_->inserir(reg);
        }

b7de9e4917745c55e0cdcb38819e747534dc1f22

Dúvida sobre a contabilização de trocas do quicksort

@larissalimaa:

ERRO. corrigir

ERRO. corrigir

trabalho_ed2/src/secao_2/HashAutor.cpp

Line 129 in 2654364

//fixme: ERRO. corrigir

#include "../../include/secao_2/Primo.hpp"

using namespace std;

//Larissa: Luci, justifique por favor porque você fez "n/0.75"
/**
    * Cria a tabela Hash com preenchimento m�ximo de 75% com base no n�mero de dados. Escolhesse o menor primo que atende esse requisito.
    * @param n Tamanho da tabela Hash a ser criada
    */
HashAutor::HashAutor(int n) {
    //vari�vel do tipo ...
    tamanhoTabela = (int) (n / 0.75);
    tamanhoTabela = Primo::proxPrimo(tamanhoTabela);
    //vari�vel do tipo ... variavel de class
    tabelaAutores = new Autor[tamanhoTabela];
    vazia = true;


}

//Destrutor
HashAutor::~HashAutor() {
    delete[] tabelaAutores;
}

//Larissa: Luci, para que serve essa funcao calculaHash?
// retorna uma posi��o na tabela para que veja se � possivel inserir ou para realizar buscas.
/**
    * Descreva o que esse método faz (...)
    * @param ch
    * @param i
    */
int HashAutor::calculaHash(int ch, int i) {

    //vari�vel do tipo inteira para calcular a melhor funcao quadratica
    int valorQuadratica = pow(ch, 2) - 5 * ch + 7;

    //vari�vel do tipo ...
    int valorHash = (ch + i * valorQuadratica) % tamanhoTabela;

    //Larissa: Porque essa verificacao?
    //para ver se j� foi dada uma volta completa. Ela chegar no mesmo valor da chave original, implica em ela repetir o mesmo caminho depois.
    if (valorHash == ch)
        return -1;
    else
        return valorHash;
}


/**
    * Larissa: Luci, funcaoHash retorna um indice baseada se eh um Registro ou n�o? N�o, independe do dado, pq a funcao calcula chave j� passa para um int.
    * @param ch (...)
    * @param i (...)
    */
int HashAutor::funcaoHash(int ch, int i) {
    //variável do tipo ...
    int indiceTabela = calculaHash(ch, i);

    //se não há registro ou autor no indice?
    if (indiceTabela == -1)
        return -1;


    //Larissa: Ali em cima voc� colocou ponteiro, aqui nao deveria ser tamb�m? n�o sei pq s� rodou assim.. tb n�o entendi.
    Autor aux = tabelaAutores[indiceTabela];

    //Larissa: Se nao tem nome retorna o indice, porque? Porque assim eu insiro em uma posi��o vazia.
    if (aux.getNome() == "")
        return indiceTabela;
        //Senao calcula nova posição na tabela
    else
        return funcaoHash(ch, i + 1);


}


//Larissa: Luci, calculachave com essa assinatura eh a fun��o hash Para autor? Como voc� fez esse c�lculo? Sim, pegando valor da tabela ASCII
int HashAutor::calculaChave(string nome) {
    int ch = 0;
    int tamanhoString = nome.size();
    for (int i = 1; i < tamanhoString; i++) {
        if (nome[i] >= 'A' && nome[i] <= 'Z')
            ch += (nome[i] - 'A');
        else if (nome[i] >= 'a' && nome[i] <= 'z')
            ch += (nome[i] - 'a');
    }

    return ch;

}


/**
    * Função inserir eh responsável por colocar um Autor na Tabela Hash de Autores
    * @param a Autor a ser inserido
    */
void HashAutor::insere(Autor *a) {
    //Larissa: Luci, tem duas variaveis para receber a posicao? Porque? Uma calcula a chave e a outra a posi��o
    int ch = calculaChave(a->getNome());
    int pos = funcaoHash(ch, 0);

    if (pos == -1)
        cout << "N�o foi possivel inserir o valor" << endl;
    else {
        if (vazia)
            vazia = false;
        tabelaAutores[pos] = *a;
    }
}


/**
    * Função buscar eh responsável por procurar um Livro na Tabela Hash de Livros
    * @param id codigo unico do Livro a ser procurado
    */
int HashAutor::busca(string nome) {
    if (vazia) {
        cout << "Tabela vazia" << endl;
        return -1;
    }
    //variavel do tipo...
    int ch = calculaChave(nome);
    //variavel do tipo...
    int pos;

    Autor *aux;
    //fixme: ERRO. corrigir
    for (int i = 0; aux != NULL && aux->getNome() != nome; i++) {
        pos = calculaHash(ch, i);
        *aux = tabelaAutores[pos];
    }
    if (aux == NULL)
        return -1;
    else
        return pos;

}
ew file mode 100644
ndex 0000000..92f4562
++ b/src/secao_2/HashRegistro.cpp

2371da7ee56510e7dd59a1389d8ac1e3b4bba45e

corrigir

corrigir

trabalho_ed2/src/csvLivros.cpp

Line 125 in 2654364

randomNumeros[numRegistro] = gerarRandomNum(++seed, 0, tamArq - 1); //fixme: corrigir

                    break;
                }
                posRandom = randomNumeros[numRegistro];
                // acessa a posição, definida por `posRandom`, do arquivo
                arquivo.seekg(posRandom);
                //lê até o final da linha
                getline(arquivo, linha);
                /**
                 * se contem apenas um char ou não terminar com " então escolhe outra posição e inicia o loop novamente
                 * aleatória.
                 *se o if for falso a linha atual será ignorada
                */
                if (linha.length() < 2 || linha[linha.length() - 2] != '"') {
                    randomNumeros[numRegistro] = gerarRandomNum(++seed, 0, tamArq - 1); //fixme: corrigir
                    continue;
                }
            } else {

0bedc5cd2de2b174a38e7cb2c12f4606e153c422

debug

debug

trabalho_ed2/src/Registro.cpp

Line 172 in 59f45d4

// cout << cont << endl; //fixme: debug

}

int Registro::getQtAutores() const {
    return regQtAutores_;
}

// --------------------- Métodos privados -------------------- //

void Registro::splitString(const std::string &str, int *&array, int *n, char delim) {
    int cont = 0;
    int itemInt;
    stringstream ss(str);
    string item;

    //se n > 0, então aloca um vetor de tamanho n
    if (*n > 0) {
        array = new int[*n];
    }
    // se *n==-1 então esse loop fará a contagem de elementos dentro da string `str`
    while (!ss.eof()) {
        getline(ss, item, delim);
        if (!item.empty() && item.length() > 1) {
            if (*n > 0) {
                //somente quando o array foi criado que os itens serão atribuidos
                itemInt = std::stoi(item);
                array[cont] = itemInt;
//                cout << cont << endl; //fixme: debug
            }
            cont++;
        }

    }
    // se não foi passado paramêtro nenhum para `n` então a função é chamada novamente contendo o valor de n que
    // foi contabilizado
    if (*n == -1) {
        *n = cont;
        splitString(str, array, n, delim);
    }
}

// ----------------- Sobrecarga de operadores ---------------- //

//função auxiliar. Apenas para debug por enquanto
std::ostream &operator<<(ostream &os, const Registro &reg) {
    // imprimindo 1 autor e 1 categoria, apenas para teste
    os << "qtAutores: " << reg.regQtAutores_ << " | ";
    os << "qtCategorias: " << reg.regQtCategorias_ << " || ";
    os << "1º Autor: " << reg.autores_[0] << " | ";
    os << "RankBestsellers: " << reg.rankBestsellers_ << " | ";
    os << "1ª Categoria: " << reg.categorias_[0] << " | ";
    os << "Edicao: " << reg.edicao_ << " | ";
    os << "Id: " << reg.id_ << " | ";
    os << "isbn10: " << reg.isbn10_ << " | ";
    os << "isbn13: " << reg.isbn13_ << " | ";
    os << "avaliacaoMedia: " << reg.avaliacaoMedia_ << " | ";
    os << "qtAvaliacoes: " << reg.qtAvaliacoes_ << " | ";
    os << "Titulo: " << reg.titulo_ << endl;
    return os;
}
ndex 3dc44ad..e51c3b6 100755
++ b/src/csvLivros.cpp

17c54105d5d6d8176b95c62362252cac2d3031ff

debug

debug

for (int j = 0; j < qtAutores; j++) {

int autorId = autoresIds[j];

if(autorId != -1) {

auto *autor = new Autor();

autor->setId(autorId);

trabalho_ed2/src/DataFrameLivros.cpp

Line 113 in 59f45d4

// cout << reg.getQtAutores() << endl; //fixme: debug

    // se a ED interna é hash table então aloca a tabela hash
    if (armazInterno_ == ED::HASH_TABLE) {

        hashRegistros_ = new HashRegistro(numLinhas_);

    } else if (armazInterno_ == ED::VETOR) {
        // se ED interna é vetor aloca um vetor de Registros de tamanho `numLinhas`
        registros_ = new Registro[numLinhas_];

    } else if (armazInterno_ == ED::ARVORE) {
        // se ED interna é arvore aloca um vetor de Registros de tamanho `numLinhas`
        arvoreVP_ = new AVP();
        arvoreB_ = new ArvoreB();
    }
    //preenche o data frame com os valores lidos do csv
    csv::lerRegistros(this, nomeArquivo, numLinhas, aleatorio, seed);

    if (armazInterno_ == ED::HASH_TABLE) {
        //Com o dataframe, hashRegistros_ e a quantidade de autores preenchidos, podemos criar a hash de autores

        hashAutores_ = new HashAutor(countTotalAutores_);
//        int tamHashRegistros;
//        Registro *registrosTable;
//        int *autoresIds;
//        int qtAutores;
//
//        tamHashRegistros = Primo::proxPrimo(numLinhas_);
//        registrosTable = hashRegistros_->getTabelaRegistros();
//
//        for (int i = 0; i < tamHashRegistros; i++) {
            // se é uma posição vazia, então passa para a proxima posição
//            cout << registrosTable[i].getId() << endl;//fixme: debug
//            if (registrosTable[i].getId() == -1) continue;
//
//            Registro reg = registrosTable[i];
//            autoresIds = reg.getAutores();
//            qtAutores = reg.getQtAutores();
//            cout << reg.getQtAutores() << endl; //fixme: debug
//            for (int j = 0; j < qtAutores; j++) {
//                int autorId = autoresIds[j];
//                if(autorId != -1) {
//                    auto *autor = new Autor();
//                    autor->setId(autorId);
//                    cout << autor->getId() << endl; //fixme: debug
////                    hashAutores_->inserir(autor);
//                    delete autor;
//                }
//            }
//        }
        //TODO: Dentro dessa função, percorrer csv e adicionar nome dos autores da tabela hash
//        csv::lerAutores("../dataset/authors.csv", hashAutores_);
    }
    else if (armazInterno_ == ED::ARVORE) {
        //Obtendo as quantidades de comparações e trocas realizadas pelas arvores
        contComparacoes1_ = arvoreVP_->getQtdComparacoes();
        contTrocas1_ = arvoreVP_->getQtdTrocas();

//        contComparacoes2_ = arvoreB_->getQtdComparacoes();
//        contTrocas2_ = arvoreB_->getQtdTrocas();
    }
}

bool DataFrameLivros::inserirRegistro(std::string *camposStrVet, int index) {
    bool statusInsercao;
    if (armazInterno_ == ED::HASH_TABLE) {
        auto *reg = new Registro();
        reg->setTodosAtributosStr(camposStrVet);

        // será true se registro é unico, ou false se 'repetido
        statusInsercao = hashRegistros_->buscar(reg->getId()) == -1;

        //se for livro único então inserir na tabela hash de registros, busca e os autores na tabela hash de autores
        if (statusInsercao) {
            countTotalAutores_ += reg->getQtAutores();
            hashRegistros_->inserir(reg);
        }

fb304af0fce48b431a014312bdcd9b72dfa33fa8

Dúvida sobre arquivo de saída que iremos utilizar para contabilizar as métricas

• Iremos escrever todas as métricas no(s) arquivo(s) e depois calcular as médias? ou iremos calcular no final da execução da ordenação e apenas escrever essas medidas resumos no arquivo?
• Como será a formatação desse arquivo?

debug

debug

trabalho_ed2/src/DataFrameLivros.cpp

Line 94 in 6b4e093

// cout << "Livro único: " << (statusInsercao ? "SIM" : "NÃO") << endl; //fixme: debug

void DataFrameLivros::lerCsv(const std::string &nomeArquivo, int numLinhas, bool aleatorio, unsigned int seed,
                             ED armazInterno) {
    numLinhas_ = numLinhas;
    seed_ = seed;
    armazInterno_ = armazInterno;

    // se é hashTable então aloca a tabela hash
    if (armazInterno_ == ED::HASH_TABLE) {

        hashRegistros_ = new HashRegistro(numLinhas_);

    } else if (armazInterno_ == ED::VETOR) {
        // aloca um vetor de Registros de tamanho `numLinhas`
        registros_ = new Registro[numLinhas_];

    } else if (armazInterno_ == ED::ARVORE) {
        // TODO: Alocar Arvore aqui
    }
    //preenche o data frame com os valores lidos do csv
    csv::lerRegistros(this, nomeArquivo, numLinhas, aleatorio, seed);
}

bool DataFrameLivros::inserirRegistro(std::string *camposStrVet, int index) {
    bool statusInsercao;
    if (armazInterno_ == ED::HASH_TABLE) {
        Registro reg;
        reg.setTodosAtributosStr(camposStrVet);

        // será true se registro é unico, ou false se 'repetido
        statusInsercao = hashRegistros_->buscar(reg.getId()) == -1;
//        cout << "Livro único: " << (statusInsercao ? "SIM" : "NÃO") << endl; //fixme: debug

        //se for livro único então inserir na tabela hash de registros, busca e os autores na tabela hash de autores
        if (statusInsercao) {
            hashRegistros_->inserir(&reg);
            //TODO: para cada registro inserido, adicionar cada autor tbm para a tabela hash de autores
            // e para cada autor repetido, incrementrar seu contador interno
            //        hashAutores_->inserir(); //estou ajustando essas funções
        }


    } else if (armazInterno_ == ED::VETOR && index >= 0 && index < numLinhas_) {

        registros_[index].setTodosAtributosStr(camposStrVet);
        statusInsercao = true;

    } else if (armazInterno_ == ED::ARVORE) {
        // cria um novo registro
        Registro reg;
        reg.setTodosAtributosStr(camposStrVet); // preenche o obj Registro

        //TODO: Inserir Nó na arvore aqui...
        //arvoreVP->insere(reg);  // adiciona obj na árvore

        statusInsercao = true; //se inserção na arvore deu tudo ok

    } else {
        cout << "Erro de index ou armazenamento não implementado na função DataFrameLivros::inserirRegistro()";
        exit(-1);
    }
    return statusInsercao; //se é hashTable, tenta inserir , se já existir retorna falso, caso contrario true;

90a92f43fbe44927c54920bb5bd6d7685cba5015