int buscarNaArvore(arvoreBMais *arvore, int chave)
{
int i;
noDaArvore *no = arvore->raiz;
paginaInterna *naoFolha;
paginaFolha *folha;
while (no != NULL) {
switch (no->tipo) {
case 0: //folha
folha = (paginaFolha*)no;
i = buscaBinaria(folha->chaves, folha->registros, chave);
if (i >= 0) {
return folha->dados[i];
} else {
return 0;
}
case 1: //não folha
naoFolha = (paginaInterna*)no;
i = buscaBinaria(naoFolha->chaves, naoFolha->filhos-1, chave);
if (i >= 0) {
no = naoFolha->subPtr[i+1];
} else {
i = -i - 1;
no = naoFolha->subPtr[i];
}
break;
default:
assert(0);
}
}
return 0;
}
int buscaBinaria(indicePrimario Lista[], char valor[], int inicio, int fim)
{
int meio;
meio = (fim-inicio)/2 + inicio;//pega o elemento central
if(inicio>fim)//não encontrou o elemento
return -1;
else
{
if (strcmp(Lista[meio].pk, valor) == 0)
return(meio);
else
{
if (strcmp(Lista[meio].pk, valor) > 0)
{
fim = meio-1;
return buscaBinaria(Lista,valor,inicio,fim);
}
else
{
inicio = meio+1;
return buscaBinaria(Lista,valor,inicio,fim);
}
}
}
}
int remocao(char pk[9], indicePrimario p_l[], int tam_p) {
int rrn;
int i = buscaBinaria(p_l, pk, 0, tam_p);
if (i == -1)
return 0;
else
{
rrn = p_l[i].rrn;
p_l[i].rrn = -1;
FILE *file = fopen("matches.dat", "r+");
fseek(file, rrn, SEEK_SET);
fprintf(file, "%s", "*|");
fclose(file);
int flag = 0;
FILE *primarioFile = fopen("iprimary.idx", "r+");
fprintf(primarioFile, "%d\n", flag);
fclose(primarioFile);
return 1;
}
}
Register* slowQuery(FILE *ft,int key)
{
int offset,page,nreg,busca = -1;
TerminalNode tnode;
Register *reg_aux = malloc(sizeof(Register));
fseek(ft,0,SEEK_SET);
page = fread(&tnode,sizeof(TerminalNode),1,ft);
if(page == 1)
{
nreg = numberRegisters(ft,'t');
page = 0;
while(page < nreg)
{
busca = buscaBinaria(tnode.reg,key);
if(busca != -1)
{
*reg_aux = tnode.reg[busca];
return reg_aux;
}
if(tnode.next_node != 0)
{
offset = sizeof(TerminalNode) * (tnode.next_node - 1);
fseek(ft,offset,SEEK_SET);
fread(&tnode,sizeof(TerminalNode),1,ft);
}
page++;
}
}
return NULL;
}
// Busca Binária (recursiva)
bool buscaBinaria(int v[], int n, int num, int *cont) {
// índice do elemento mais pŕoximo do meio e o valor dele
int i = n/2;
int y = v[i];
(*cont)++; // quantidade de comparações
// se o arranjo estiver vazio ou não tiver achado
if (n == 0)
return 0;
// se achou o número retorna a posição
else if (num == y)
return 1;
// senão vê se está na primeira metade do vetor ou na segunda
else if (num < y) // primeira metade
return buscaBinaria(v, i, num, cont);
else // segunda metade num > y
return buscaBinaria(&v[i+1], n-(i+1), num, cont);
}
/* algoritmo que realiza busca binaria
Parametros:
int * vet : vetor com os numeros
int n : tamanho do vetor
int chave : chave a procurar em 'vet'
Retorno: long int
(0, n-1) : se a chave existir em 'vet'
-1 : busca sem sucesso
*/
long int buscaBinaria(int * vet, int ini, int fim, int chave) {
if (ini > fim) {
return -1;
}
long int centro = (int)((ini+fim)/2.0);
// busca com sucesso
if (vet[centro] == chave) {
return centro;
}
if (chave < vet[centro]) {
return buscaBinaria(vet, ini, centro-1, chave);
// fim = centro-1; // iterativa
}
if (chave > vet[centro]) {
return buscaBinaria(vet, centro+1, fim, chave);
// ini = centro+1; // iterativa
}
}
void inserePalavra (char *pal, Dicionario d) {
int i, j;
i = buscaBinaria (pal, d);
/* d->dic[i] > i lexicograficamente caso i<d->n */
if (i >= d->n || strcmp (d->dic[i], pal) > 0) {
if (d->n == d->N)
expandeDicionario (d);
for (j = d->n - 1; j >= i; j--)
d->dic[j + 1] = d->dic[j];
d->dic[i] = pal;
d->n += 1;
} else free (pal);
}
int main(int argc, char* argv[]) {
if (argc < 4) {
printf("Numero de argumentos insuficiente\n");
printf("Uso: ./prog <tam_vetor> <chave> <tipo_busca>\n");
printf("\t<tipo> = 1 sequencial, 2 binaria\n\n");
return 0;
}
int n = atoi(argv[1]); // tamanho do vetor
int chave = atoi(argv[2]); // numero a buscar nos dados
int op = atoi(argv[3]);
int * vet = geraVetorAleatorio(n);
printf("exemplos: %d, %d\n", vet[n-2], vet[n-1]);
long int pos;
clock_t c1, c2;
c1 = clock();
if (op == 1) {
fprintf(stdout,"Realizando busca...\n");
fflush(stdout);
pos = buscaSequencial(vet, n, chave);
} else if (op == 2) {
fprintf(stdout,"Ordenando...\n");
fflush(stdout);
// bubbleSort(vet, n); // nao usar - dica do Obama
insertionSort(vet, n);
fprintf(stdout,"Realizando busca...\n");
fflush(stdout);
pos = buscaBinaria(vet, 0, n-1, chave);
}
c2 = clock();
double time_diff = (c2-c1)/((double) CLOCKS_PER_SEC);
printf("Tempo de execucao: %.4lf\n", time_diff);
if (pos == -1) {
printf("Valor nao encontrado\n\n");
} else {
printf("Valor encontrado na posicao: %ld\n\n", pos);
}
free(vet);
return 0;
}
void testesBuscas() {
int dados[] = { 1, 3, 5, 6, 7, 9, 10, 12, 14, 20 };
int i;
printf( "Busca Sequencial ou Linear:\n" );
for ( i = 0; i < 10; i++ ) {
printf( "%d %s\n", i, buscaSequencial( i, dados, TAMANHO_ARRAY_BUSCA ) ? "***" : "" );
}
printf( "\nBusca Binaria:\n" );
for ( i = 0; i < 10; i++ ) {
printf( "%d %s\n", i, buscaBinaria( i, dados, TAMANHO_ARRAY_BUSCA ) ? "***" : "" );
}
}
void alterar(char pk[], indicePrimario p_l[], int tam_p, Partida p[]) {
int flag, rrn, posicao;
char duracao[6];
FILE *dado;
Partida *part;
dado = fopen("matches.dat", "r+");
posicao = buscaBinaria(p_l, pk, 0, tam_p); //busca binaria retorna a posicao do vetor
if (posicao == -1) {
printf("Registro não encontrado!\n");
return;
}
rrn = p_l[posicao].rrn;
part = (Partida *)malloc(sizeof(Partida));
fseek(dado, rrn, SEEK_SET);
fscanf(dado, "%[^@]@", part->codigo);
fscanf(dado, "%[^@]@", part->nomeAzul);
fscanf(dado, "%[^@]@", part->nomeVermelha);
fscanf(dado, "%[^@]@", part->data);
if(rrn != -1) {
flag = 0;
while(flag == 0) {
scanf("%[^\n]%*c", duracao);
if (strlen(duracao) != 5 || duracao[2] != ':') {
printf("Campo Inválido!\n");
flag = 0;
}
else {
flag = 1;
duracao[5] = '\0';
//escrever diretamente no arquivo de dados
fprintf(dado, "%s", duracao);
}
}
} else {
printf("Registro não encontrado!\n");
}
fclose(dado);
}
int removeOrdenadoTnode(Register *set_keys,int key)
{
int pos,i;
pos = buscaBinaria(set_keys,key);
if(pos == -1) return pos;
else
{
if(pos == REGS_POR_PAGINA-1) set_keys[pos].key = 0;
else
{
for(i = pos; i < REGS_POR_PAGINA-1;i++)
{
set_keys[i].key = set_keys[i+1].key;
}
set_keys[i].key = 0;
}
}
return 1;
}
aluno * consultaRA (arvoreb * arvore, int ra)
{
int indice;
pagina * atual = arvore->raiz;
while (1)
{
/* busca na página */
indice = buscaBinaria( atual->chave, atual->chaves, ra);
if (indice < atual->chaves && atual->chave[indice].ra == ra)
/* encontrou o registro */
return atual->chave + indice;
if (atual->filho != NULL)
/* desce para o filho certo */
atual = (atual->filho)[indice];
else
/* não achou */
return NULL;
}
}
Register* consultaRegistro(FILE *fi,FILE *ft,int key)
{
int i,offset,busca,page;
IndexNode inode;
TerminalNode tnode;
Register *reg_aux = malloc(sizeof(Register));
page = fread(&inode,sizeof(IndexNode),1,fi);
if(page == 1)
{
while(!inode.leaf)
{
for(i=0;i < 2*ORDEM && inode.keys[i] != 0;i++)
{
if(key <= inode.keys[i]) break;
}
offset = sizeof(IndexNode) * (inode.pointers[i] - 1);
fseek(fi,offset,SEEK_SET);
fread(&inode,sizeof(IndexNode),1,fi);
}
for(i=0;i < 2*ORDEM && inode.keys[i] != 0;i++)
{
if(key <= inode.keys[i]) break;
}
if(inode.pointers[i] != 0)
{
offset = sizeof(TerminalNode) * ((inode.pointers[i] * -1)-1);
fseek(ft,offset,SEEK_SET);
fread(&tnode,sizeof(TerminalNode),1,ft);
busca = buscaBinaria(tnode.reg,key);
if(busca != -1)
{
*reg_aux = tnode.reg[busca];
return reg_aux;
}
}
}
return NULL;
}
// Main
int main () {
int i = 0;
int vQuickSort[20] = {30, 21, 10, 44, 23, 14, 3, 1, 20, 55, 32, 13, 32, 99, 442, 33, 22, 76, 54, 32};
int vBuscaBinaria[10] = {10, 20, 30, 40, 50, 60, 70, 80, 90, 100};
int vMergeSort[11] = {1, 4, 3, 56, 74, 34, 23, 6, 7, 8, 9};
quicksort(vQuickSort, 0, 20);
printf("Busca binaria: \n");
printf("%d", buscaBinaria(vBuscaBinaria, 80, 10));
printf("\n");
printf("Quick Sort: \n");
for(i = 0; i < 20; i++){
printf("%d ", vQuickSort[i]);
}
mergeSort(vMergeSort, 0, (sizeof(vMergeSort) / sizeof(int)));
printf("\n");
imprime(vMergeSort, 11);
return 0;
}
int inserirNaArvore(arvoreBMais *arvore, int chave, int dado)
{
int i;
noDaArvore *no = arvore->raiz;
paginaInterna *naoFolha;
paginaFolha *folha, *raiz;
while (no != NULL) {
switch (no->tipo) {
case 0:
folha = (paginaFolha*)no;
return inserirNaFolha(arvore, folha, chave, dado);
case 1:
naoFolha = (paginaInterna*)no;
i = buscaBinaria(naoFolha->chaves, naoFolha->filhos - 1, chave);
if (i >= 0) {
no = naoFolha->subPtr[i+1];
} else {
i = -i - 1;
no = naoFolha->subPtr[i];
}
break;
default:
assert(0);
}
}
raiz = criarFolha();
raiz->chaves[0] = chave;
raiz->dados[0] = dado;
raiz->registros = 1;
arvore->cabeca[0] = (noDaArvore*)raiz;
arvore->raiz = (noDaArvore*)raiz;
return 0;
}
_Bool insereRegistro(FILE *fi,FILE *ft,Register *reg)
{
int i,offset,busca,nreg,page;
IndexNode inode;
TerminalNode tnode,tnode_aux;
StackTop stack;
stack.top = NULL;
page = fread(&inode,sizeof(IndexNode),1,fi);
//Arquivo vazio - Inserir Raiz.
if(page != 1)
{
//Inicializa Index Node
initIndexNode(&inode);
inode.idNode = 1;
inode.keys[0] = (*reg).key;
inode.pointers[0] = -1;
inode.leaf = true;
inode.qtdeKeys = 1;
fwrite(&inode,sizeof(IndexNode),1,fi);
//Inicializa Terminal Node
initTerminalNode(&tnode);
tnode.reg[0] = *reg;
tnode.qtdeReg = 1;
tnode.next_node = 0;
fwrite(&tnode,sizeof(TerminalNode),1,ft);
}
//Há registros
else
{
while(!inode.leaf)
{
for(i=0;i < 2*ORDEM && inode.keys[i] != 0;i++)
{
if((*reg).key <= inode.keys[i]) break;
}
//Coloca na pilha
pushStack(&stack,&inode);
offset = sizeof(IndexNode) * (inode.pointers[i] - 1);
fseek(fi,offset,SEEK_SET);
fread(&inode,sizeof(IndexNode),1,fi);
}
for(i=0;i < 2*ORDEM && inode.keys[i] != 0;i++)
{
if((*reg).key <= inode.keys[i]) break;
}
//Nó terminal não existe
if(inode.pointers[i] == 0)
{
//Inicializa Terminal Node - uso nreg só pra não criar uma nova variável de controle
initTerminalNode(&tnode);
tnode.reg[0] = *reg;
tnode.qtdeReg = 1;
nreg = numberRegisters(ft,'t');
inode.pointers[i] = (nreg+1) * -1;
offset = sizeof(IndexNode) * (inode.idNode - 1);
//Atualiza o nó de índice
fseek(fi,offset,SEEK_SET);
fwrite(&inode,sizeof(IndexNode),1,fi);
offset = sizeof(TerminalNode) * ((inode.pointers[i-1] * -1) - 1);
//tnode_aux é o terminal anterior ao ser inserido
fseek(ft,offset,SEEK_SET);
fread(&tnode_aux,sizeof(TerminalNode),1,ft);
tnode.next_node = tnode_aux.next_node;
tnode_aux.next_node = nreg + 1;
//Atualizar nó anterior
offset = sizeof(TerminalNode) * ((inode.pointers[i-1] * -1) - 1);
fseek(ft,offset,SEEK_SET);
fwrite(&tnode_aux,sizeof(TerminalNode),1,ft);
//Gravar o novo nó
fseek(ft,0,SEEK_END);
fwrite(&tnode,sizeof(TerminalNode),1,ft);
return true;
}
//Nó Terminal Já existente
else
{
offset = sizeof(TerminalNode) * ((inode.pointers[i] * -1)-1);
fseek(ft,offset,SEEK_SET);
fread(&tnode,sizeof(TerminalNode),1,ft);
busca = buscaBinaria(tnode.reg,(*reg).key);
//Insiro normalmente
if(busca == -1 && tnode.qtdeReg < REGS_POR_PAGINA)
{
inserirOrdenadoTnode(tnode.reg,reg);
tnode.qtdeReg++;
fseek(ft,offset,SEEK_SET);
fwrite(&tnode,sizeof(TerminalNode),1,ft);
return true;
}
//Chave já existente
else if(busca != -1) return false;
//Caso de split
else
{
tnode_aux = splitTerminal(tnode.reg,reg,&tnode.qtdeReg);
nreg = numberRegisters(ft,'t');
//Insere o novo nó gerado pelo split
tnode_aux.next_node = tnode.next_node;
fseek(ft,0,SEEK_END);
fwrite(&tnode_aux,sizeof(TerminalNode),1,ft);
//Atualiza o nó que ocorreu o overflow
tnode.next_node = nreg+1;
offset = sizeof(TerminalNode) * ((inode.pointers[i] * -1) - 1);
fseek(ft,offset,SEEK_SET);
fwrite(&tnode,sizeof(TerminalNode),1,ft);
//Split apenas no nó terminal
if(inode.qtdeKeys < 2*ORDEM)
{
//Atualizar o nó do índice
inserirOrdenadoInode(inode.keys,tnode.reg[tnode.qtdeReg - 1].key);
shiftPointers(inode.pointers,i+1,(nreg+1) * -1);
inode.qtdeKeys++;
offset = sizeof(IndexNode) * (inode.idNode - 1);
fseek(fi,offset,SEEK_SET);
fwrite(&inode,sizeof(IndexNode),1,fi);
}
//split no nó de índice
else
{
//busca é a chave promovida do split
pushStack(&stack,&inode);
busca = tnode.reg[tnode.qtdeReg - 1].key;
createSplitIndex(&stack,nreg+1,busca,fi);
}
}
}
}
return true;
}
int inserirNaFolha(arvoreBMais *arvore, paginaFolha *folha, int chave, int dado)
{
int i, j, split = 0;
paginaFolha *sibling;
int auxInserir = buscaBinaria(folha->chaves, folha->registros, chave);
if (auxInserir >= 0) {
return -1;
}
auxInserir = -auxInserir - 1;
if (folha->registros == arvore->registros) {
split = (arvore->registros + 1) / 2;
sibling = criarFolha();
sibling->proximo = folha->proximo;
folha->proximo = sibling;
folha->registros = split;
if (auxInserir < split) {
for (i = split - 1, j = 0; i < arvore->registros; i++, j++) {
sibling->chaves[j] = folha->chaves[i];
sibling->dados[j] = folha->dados[i];
}
sibling->registros = j;
for (i = folha->registros; i > auxInserir; i--) {
folha->chaves[i] = folha->chaves[i-1];
folha->dados[i] = folha->dados[i-1];
}
folha->chaves[i] = chave;
folha->dados[i] = dado;
} else {
i = split, j = 0;
while (i < arvore->registros) {
if (j != auxInserir - split) {
sibling->chaves[j] = folha->chaves[i];
sibling->dados[j] = folha->dados[i];
i++;
}
j++;
}
if (j > auxInserir - split) {
sibling->registros = j;
} else {
sibling->registros = auxInserir - split + 1;
}
j = auxInserir - split;
sibling->chaves[j] = chave;
sibling->dados[j] = dado;
}
} else {
for (i = folha->registros; i > auxInserir; i--) {
folha->chaves[i] = folha->chaves[i-1];
folha->dados[i] = folha->dados[i-1];
}
folha->chaves[i] = chave;
folha->dados[i] = dado;
folha->registros++;
}
if (split) {
paginaInterna *pai = folha->pai;
if (pai == NULL) {
pai = criarPagina();
pai->chaves[0] = sibling->chaves[0];
pai->subPtr[0] = (noDaArvore*)folha;
pai->subPtr[1] = (noDaArvore*)sibling;
pai->filhos = 2;
arvore->raiz = (noDaArvore*)pai;
arvore->cabeca[1] = (noDaArvore*)pai;
folha->pai = pai;
sibling->pai = pai;
} else {
sibling->pai = pai;
return inserirNaPagina(arvore, pai, (noDaArvore*)sibling, sibling->chaves[0], 1);
}
}
return 0;
}
int inserirNaPagina(arvoreBMais *arvore, paginaInterna *pagina, noDaArvore *noArv, int chave, int nivel)
{
int i, j, split_chave;
int split = 0;
paginaInterna *sibling;
int auxInserir = buscaBinaria(pagina->chaves, pagina->filhos - 1, chave);
assert(auxInserir < 0);
auxInserir = -auxInserir - 1;
if (pagina->filhos == arvore->ordem) {
split = (arvore->ordem + 1) / 2;
sibling = criarPagina();
sibling->proximo = pagina->proximo;
pagina->proximo = sibling;
pagina->filhos = split + 1;
if (auxInserir < split) {
i = split - 1;
j = 0;
split_chave = pagina->chaves[i];
sibling->subPtr[j] = pagina->subPtr[i+1];
pagina->subPtr[i+1]->pai = sibling;
i++;
while (i < arvore->ordem - 1) {
sibling->chaves[j] = pagina->chaves[i];
sibling->subPtr[j+1] = pagina->subPtr[i+1];
pagina->subPtr[i+1]->pai = sibling;
i++;
j++;
}
sibling->filhos = j + 1;
for (i = pagina->filhos - 1; i > auxInserir; i--) {
pagina->chaves[i] = pagina->chaves[i-1];
pagina->subPtr[i+1] = pagina->subPtr[i];
}
pagina->chaves[i] = chave;
pagina->subPtr[i+1] = noArv;
} else if (auxInserir == split) {
i = split;
j = 0;
split_chave = chave;
sibling->subPtr[j] = noArv;
noArv->pai = sibling;
i++;
while(i < arvore->ordem - 1){
sibling->chaves[j] = pagina->chaves[i];
sibling->subPtr[j+1] = pagina->subPtr[i+1];
pagina->subPtr[i+1]->pai = sibling;
i++;
j++;
}
sibling->filhos = j + 1;
} else {
i = split;
j = 0;
split_chave = pagina->chaves[i];
sibling->subPtr[j] = pagina->subPtr[i+1];
pagina->subPtr[i+1]->pai = sibling;
i++;
while (i < arvore->ordem - 1) {
if (j != auxInserir - split) {
sibling->chaves[j] = pagina->chaves[i];
sibling->subPtr[j+1] = pagina->subPtr[i+1];
pagina->subPtr[i+1]->pai = sibling;
i++;
}
j++;
}
if (j > auxInserir - split) {
sibling->filhos = j+1;
} else {
sibling->filhos = auxInserir - split+1;
}
j = auxInserir - split - 1;
sibling->chaves[j] = chave;
sibling->subPtr[j+1] = noArv;
noArv->pai = sibling;
}
} else {
for (i = pagina->filhos - 1; i > auxInserir; i--) {
pagina->chaves[i] = pagina->chaves[i-1];
pagina->subPtr[i+1] = pagina->subPtr[i];
}
pagina->chaves[i] = chave;
pagina->subPtr[i+1] = noArv;
pagina->filhos++;
}
if (split) {
paginaInterna *pai = pagina->pai;
if (pai == NULL) {
if (++nivel >= arvore->nivel) {
fprintf(stderr, "!!Panic: Nivel exceeded, please expand the arvore nivel, non-leaf ordem or leaf registros for element capacity!\n");
pagina->proximo = sibling->proximo;
removerPagina(sibling);
return -1;
}
pai = criarPagina();
pai->chaves[0] = split_chave;
pai->subPtr[0] = (noDaArvore*)pagina;
pai->subPtr[1] = (noDaArvore*)sibling;
pai->filhos = 2;
arvore->raiz = (noDaArvore*)pai;
arvore->cabeca[nivel] = (noDaArvore*)pai;
pagina->pai = pai;
sibling->pai = pai;
} else {
sibling->pai = pai;
return inserirNaPagina(arvore, pai, (noDaArvore*)sibling, split_chave, nivel+1);
}
}
return 0;
}
int main(int argc, char* argv[]) {
if (argc < 7) {
printf("Numero de argumentos insuficiente\n");
printf("Uso: ./prog <tam_vetor> <chave> <tipo_busca>\n");
printf("\t<tipo> = 1 sequencial, 2 binaria\n\n");
printf("\t<sort> = 1 bubble, 2 insertion\n");
printf("\t<tipo_vetor> = 1 aleatorio, 2 sequencial\n");
printf("\t<tipo_op> = 1 leitura, 2 escrita\n");
return 0;
}
int n = atoi(argv[1]); // tamanho do vetor
int chave = atoi(argv[2]); // numero a buscar nos dados
int op = atoi(argv[3]);
int sort = atoi(argv[4]);
int tipovet = atoi(argv[5]);
int rw = atoi(argv[6]);
int * vet;
if(tipovet == 1)
vet = (int *)geraVetorAleatorio(n);
else if (tipovet == 2)
vet = (int *)geraVetorSequencial(n);
printf("exemplos: %d, %d\n", vet[n-2], vet[n-1]);
long int pos;
clock_t c1;
if (op == 1) {
fprintf(stdout,"Realizando busca...\n");
fflush(stdout);
c1 = clock();
pos = buscaSequencial(vet, n, chave);
printf("busca: %.6fs\n", (float)(clock()-c1)/CLOCKS_PER_SEC);
} else if (op == 2) {
fprintf(stdout,"Ordenando...\n");
fflush(stdout);
c1 = clock();
if(sort == 1)
bubbleSort(vet, n); // nao usar - dica do Obama
else if(sort == 2)
insertionSort(vet, n);
printf("sort: %.6fs\n", (float)(clock()-c1)/CLOCKS_PER_SEC);
fprintf(stdout,"Realizando busca...\n");
fflush(stdout);
c1 = clock();
pos = buscaBinaria(vet, 0, n-1, chave);
printf("busca: %.6fs\n", (float)(clock()-c1)/CLOCKS_PER_SEC);
}
if (pos == -1) {
printf("Valor nao encontrado\n\n");
} else {
printf("Valor encontrado na posicao: %ld\n\n", pos);
}
free(vet);
return 0;
}
promocao * insereRecursivo (pagina * atual, aluno * novo)
{
int indice;
promocao * promo, * propaga = NULL;
if (atual->filho != NULL)
{
/* não sendo folha, chame a recursão e no retorno lide com eventual promoção de registro */
indice = buscaBinaria( atual->chave, atual->chaves, novo->ra);
if (indice < atual->chaves && atual->chave[indice].ra == novo->ra)
return NULL;
propaga = insereRecursivo( atual->filho[indice], novo);
if (propaga == NULL)
return NULL;
novo = &(propaga->promovido);
}
/* se for necessário quebrar a página */
if (atual->chaves >= ordem - 1)
{
promo = (promocao *) malloc(sizeof(promocao));
atual->chaves /= 2;
/* copia registro a ser promovido */
promo->promovido = atual->chave[atual->chaves];
/* copia registros que vão pra nova página */
promo->dir = (pagina *) malloc (sizeof(pagina));
promo->dir->chave = (aluno *) malloc (sizeof(aluno)*atual->chaves);
promo->dir->chaves = atual->chaves;
memcpy(promo->dir->chave, atual->chave + atual->chaves + 1, promo->dir->chaves*sizeof(aluno));
/* copia status de folha, e ponteiros se necessário */
if (atual->filho != NULL)
{
promo->dir->filho = (pagina **) malloc (sizeof(pagina *)*(atual->chaves+1));
memcpy(promo->dir->filho, atual->filho + atual->chaves+1, (atual->chaves+1)*sizeof(pagina *));
}
else
promo->dir->filho = NULL;
/* ajusta tamanho dos vetores */
atual->chave = realloc (atual->chave, atual->chaves*sizeof(aluno));
if (atual->filho != NULL)
atual->filho = realloc (atual->filho, (atual->chaves+1)*sizeof(pagina *));
/* troca de página se for preciso */
if (novo->ra > promo->promovido.ra)
atual = promo->dir;
}
else
/* marca a promoção como desnecessária */
promo = NULL;
/* encontra a posicao do novo elemento na página */
indice = buscaBinaria( atual->chave, atual->chaves, novo->ra);
/* redimensiona o vetor e desloca para a direita */
atual->chave = realloc(atual->chave, (atual->chaves+1)*sizeof(aluno));
memmove(atual->chave + indice + 1, atual->chave+indice, (atual->chaves++ - indice)*sizeof(aluno));
/* coloca registro na posição */
atual->chave[indice] = *novo;
if (atual->filho != NULL)
{
/* redimensiona o vetor de ponteiros e desloca para a direita */
atual->filho = realloc(atual->filho, (atual->chaves+1)*sizeof(pagina *));
memmove(atual->filho + indice + 2, atual->filho+indice+1, (atual->chaves - (indice+1))*sizeof(pagina *));
/* coloca referências para as páginas resultantes da quebra */
atual->filho[indice + 1] = propaga->dir;
}
free (propaga);
return promo;
}
