/*
*Printa a matriz
*/
void print(Matriz* x) {
int i, j;
for (i = 0; i < x->numero_de_linhas; i++) {
if (x->i[i].numero_de_colunas != 0) {
printf("[ ");
for (j = 0; j < x->numero_de_linhas; j++) {
if (busca_binaria(i, j, x) == -1) {
printf("%f ", 0);
}
else {
printf("%f ", x->i[i].j[busca_binaria(i, j, x)].valor);
}
}
printf("] \n");
}
}
}
int busca_binaria(int inf, int sup)
{
int aux = verifica((inf+sup)/2);
//printf("%d %d\n", inf, sup );
if(inf >= sup)
return sup;
if(!aux)
return busca_binaria((inf+sup)/2+1, sup);
else if(aux)
return busca_binaria(inf, (sup+inf)/2);
}
//Realiza la búsqueda del nodo para insertar la llave y hace las subdivisiones cuando son necesarias
arbolB *insere(arbolB *raiz, int info, bool *h, int *info_retorno)
{
int i, j, pos,
info_mediano; //auxiliar para almacenar la llave que irá a subir para el padre
arbolB *temp, *filho_dir; //puntero para el hijo derecho de la llave
if (raiz == NULL)
{
//El nodo anterior es el ideal para insertar la nueva llave (llegó a un nodo hoja)
*h = true;
*info_retorno = info;
return(NULL);
}
else {
pos = busca_binaria(raiz,info);
if (raiz->num_llaves > pos && raiz->llaves[pos] == info)
{
printf("Llave ya contenida en el Árbol");
*h = false;
}
else {
//desciende en el árbol hasta encontrar el nodo hoja para insertar la llave.
filho_dir = insere(raiz->hijos[pos],info,h,info_retorno);
if (*h) //Si verdadero, debe insertar la info_retorno en el nodo.
{
if (raiz->num_llaves < MAX_CHAVES) //Tiene espacio en la página
{
insere_chave(raiz, *info_retorno, filho_dir);
*h = false;
}
else { //Overflow. Necesita subdividir
temp = (arbolB *) malloc (sizeof(arbolB));
temp->num_llaves = 0;
//inicializa hijos con NULL
for (i = 0; i < MAX_HIJOS; i++)
temp->hijos[i] = NULL;
//elemento mediano que va subir para el padre
info_mediano = raiz->llaves[MIN_OCUP];
//inserta mitad del nodo raíz en temp (efectua subdivisión)
temp->hijos[0] = raiz->hijos[MIN_OCUP+1];
for (i = MIN_OCUP + 1; i < MAX_CHAVES; i++)
insere_chave(temp, raiz->llaves[i], raiz->hijos[i+1]);
//actualiza nodo raíz.
for (i = MIN_OCUP; i<MAX_CHAVES; i++)
{
raiz->llaves[i] = 0;
raiz->hijos[i+1] = NULL;
}
raiz->num_llaves = MIN_OCUP;
//Verifica en cuál nodo será insertada la nueva llave
if (pos <= MIN_OCUP)
insere_chave(raiz, *info_retorno, filho_dir);
else insere_chave(temp, *info_retorno, filho_dir);
//retorna el mediano para insertarlo en el nodo padre y el temp como hijo derecho del mediano.
*info_retorno = info_mediano;
return(temp);
}
}
}
}
}
/*
* Multiplica um vetor por um escalar
* x >> O valor pelo qual você vai multiplica tudo no vetor
* v1 >> Vetor que vai ser usado como base para multiplicar
* v2 >> Resultado vai ser botado nesse vetor
* OBS: É nada mais que multiplicar um escalar por uma matriz.
* /\ Sim, você pode usar para fazer escalar vezes matriz
*/
void multiplicacao_escalar_vetor(double x, Matriz* v1, Matriz* v2)
{
int contadorLinha;
int contadorColuna;
int resposta_busca;
double multplicacao_temp;
for (contadorLinha = 0; contadorLinha < v1->numero_de_linhas; contadorLinha++) {
for (contadorColuna = 0; contadorColuna < v1->numero_de_linhas; contadorColuna++) {
// Resposta da busca binaria, se for 0 retorna -1, se não a posicao do vetor
resposta_busca = busca_binaria(contadorLinha, contadorColuna, v1);
// Caso não seja zero, salvar no segundo vetor
if (resposta_busca != -1) {
multplicacao_temp = v1->i[contadorLinha].j[resposta_busca].valor * x;
add_valor(contadorLinha, contadorColuna, multplicacao_temp, v2);
}
}
}
}
int main(int argc, const char *argv[])
{
int v[5000], x, n;
clock_t ti1, tf1, ti2, tf2;
printf("digite o tamanho do vetor:\n");
scanf("%d",&n);
array_creator(n, v);
printf("digite o termo a ser procurado:\n");
scanf("%d",&x);
ti1 = clock();
busca_binaria(x, n, v);
tf1 = clock();
printf("Tempo da busca binária: ");
tempo(ti1, tf1);
ti2 = clock();
busca_sequencial(n, v, x);
tf2 = clock();
printf("Tempo da busca sequencial: ");
tempo(ti2,tf2);
return 0;
}
int busca_binaria(int V[],int chave, int inicio, int fim){
int meio;
if(fim<inicio){
printf("numero nao encontrado\n");
return 0;
}
else{
meio=(inicio+fim)/2;
if(V[meio]>chave){
return busca_binaria(V,chave,inicio,meio-1);
}
else{
if(V[meio]<chave){
return busca_binaria(V,chave,meio+1,fim);
}
else
return meio;
}
}
}
bool busca(arbolB *raiz, int info)
{
arbolB *nodo;
int pos; //posición retornada por la búsqueda binaria.
nodo = raiz;
while (nodo != NULL)
{
pos = busca_binaria(nodo, info);
if (pos < nodo->num_llaves && nodo->llaves[pos] == info)
return(true);
else nodo = nodo->hijos[pos];
}
return(false);
}
/*
* Subtracao de vetores trata duas matrizes como se fossem um vetor.
* Bota a subtracao deles em outro terceiro vetor passado
* v1 >> primeiro vetor
* v2 >> segundo vetor
* v3 >> vetor com o resultado da subtracao de ambos
*/
void subtrai_vetores(Matriz* v1, Matriz* v2, Matriz *v3)
{
int contador;
int posicao;
if (DEBUG_adicao_vetores)
printf("#Adicao vetores \n");
// Criando o vetor novo que vai ser a soma dos dois
cria_linhas(v1->numero_de_linhas, v3);
if (DEBUG_adicao_vetores)
printf("copiar %d elementos \n", v1->i[0].numero_de_colunas);
// Copia o primeiro vetor
for (contador = 0; contador != v1->i[0].numero_de_colunas; contador++)
add_valor(0, v1->i[0].j[contador].numero_da_coluna, v1->i[0].j[contador].valor, v3);
if (DEBUG_adicao_vetores)
printf("somar %d elementos \n", v2->i[0].numero_de_colunas);
// Agora se a coluna existir somar se não, adicionar
for (contador = 0; contador != v2->i[0].numero_de_colunas; contador++) {
posicao = busca_binaria(0, v2->i[0].j[contador].numero_da_coluna, v3);
if (posicao == -1) {
add_valor(0, v2->i[0].j[contador].numero_da_coluna, -(v2->i[0].j[contador].valor), v3);
if (DEBUG_adicao_vetores)
printf("0 + %f = %f \n", v2->i[0].j[contador].valor, v3->i[0].j[contador].valor);
}
else {
add_valor(0, v2->i[0].j[contador].numero_da_coluna, v1->i[0].j[posicao].valor - v2->i[0].j[contador].valor, v3);
if (DEBUG_adicao_vetores)
printf("%f + %f = %f \n", v1->i[0].j[posicao].valor, v2->i[0].j[contador].valor, v3->i[0].j[contador].valor);
}
}
if (DEBUG_adicao_vetores)
printf("#Fim adicao vetores \n\n");
}
main()
{
int aux_l;
arbolB *root;
int x=0;
char opc;
root= (arbolB*) Inicia_Arbol();
while (1)
{
cout<<"\n Insertar (i) Eliminar (e) Imprimir (p) BusquedaBinaria (b) Sair (s) ";
cin>>opc;
if (opc == 'i')
{
cout<<"\n Ingrese el nuevo elemento entero ";
cin>>x;
insere_arvoreB(root,x);
}
/*
if (opc == 'e')
{
cout<<"\n Ingrese el número entero a buscar ";
cin>>x;
aux_l = Eliminar_Elemento(l,x);
if (aux_l == -1)
cout<<"Numero no encontrado\n";
}
*/
if (opc == 'p') {
cout<<"en_orden: ";//IRD
en_orden(root);
}
if(opc=='b'){
cout<<"\n Ingrese el número entero a buscar ";
cin>>x;
aux_l=busca_binaria(root,x);
if(aux_l==0)
cout<<"\nNo esta...";
else
cout<<"\nSi esta...";
}
void insere_chave(arbolB *raiz, int info, arbolB *filhodir)
{
int k, pos;
//busca para obtener la posición ideal para insertar la nueva llave
pos = busca_binaria(raiz, info);
k = raiz->num_llaves;
//realiza el reacomodo para mantener las llaves ordenadas
while (k > pos && info < raiz->llaves[k-1])
{
raiz->llaves[k] = raiz->llaves[k-1];
raiz->hijos[k+1] = raiz->hijos[k];
k--;
}
//inserta la llave en la posición ideal
raiz->llaves[pos] = info;
raiz->hijos[pos+1] = filhodir;
raiz->num_llaves++;
}
int main()
{
int c, soma;
scanf("%d", &c);
for(int i=0; i<c; i++)
{
scanf("%d %d %d\n", &nPaineis, &caminhoes, &frete );
soma = 0;
for(int j=0; j<nPaineis; j++)
{
scanf("%d", &vetor[j]);
soma +=vetor[j];
}
int aux = busca_binaria(0, soma);
printf("%d $%d\n", aux, aux*caminhoes*frete);
}
return 0;
}
int main(void){
int tam, num, cont;
scanf("%d %d",&tam, &num);
srand((unsigned)time(NULL));
int vetor[tam];
for(cont=0;cont<tam;cont++){
vetor[cont]=rand()%10;
}
for(cont=0;cont<tam;cont++){
printf("%d ",vetor[cont] );
}
printf("\n");
cont=busca_binaria(vetor,num,0,tam);
printf("%d\n",vetor[cont] );
return 0;
}
/*
* Adiciona um elemento a matriz
* linha >> linha onde o elemento vai ser adicionado
* coluna >> coluna onde o elemento vai ser adicionado
* valor >> valor do elemento vai ser adicionado
* m >> matriz que vai ter o elemento adicionado
* Caso tente adicionar um elemento que já existe, vai trocar o valor daquele elemento
*/
void add_valor(int linha, int coluna, double valor, Matriz* m)
{
int resposta_da_busca_binaria;
int contador;
if (DEBUG_add_valor)
printf("#Add valor \n");
// Apenas verificando se não esta tentando adicionar elemento em uma linha/coluna maior que a da matriz
if (linha >= m->numero_de_linhas)
{
if (DEBUG_add_valor) {
printf("Nao existe a linha %d que voce deseja botar elemento \n", linha);
printf("#Fim do add valor \n\n");
}
return;
} else if (coluna >= m->numero_de_linhas)
{
if (DEBUG_add_valor) {
printf("Nao existe a coluna %d que voce deseja botar elemento \n", coluna);
printf("#Fim do add valor \n\n");
}
return;
}
if (DEBUG_add_valor)
printf("Tentando inserir o valor %f em m[%d][%d]: \n", valor, linha, coluna);
// Se a coluna já existir você só vai querer atualizar o elemento dela
resposta_da_busca_binaria = busca_binaria(linha, coluna, m);
if (resposta_da_busca_binaria != -1) {
if (valor == 0) {
if (DEBUG_add_valor) {
printf("Tratando para quando um dos elementos se torna 0 \n");
printf("#Fim do add valor \n\n");
}
// Esse loop vai passar esse elemento com 0 pro final da coluna para que possamos depois dar realloc
for (; resposta_da_busca_binaria+1 < m->i[linha].numero_de_colunas; resposta_da_busca_binaria++) {
m->i[linha].j[resposta_da_busca_binaria].numero_da_coluna = m->i[linha].j[resposta_da_busca_binaria+1].numero_da_coluna;
m->i[linha].j[resposta_da_busca_binaria].valor = m->i[linha].j[resposta_da_busca_binaria+1].valor;
}
m->i[linha].numero_de_colunas--;
m->i[linha].j = (Coluna*)realloc(m->i[linha].j, sizeof(Coluna) * m->i[linha].numero_de_colunas);
return;
}
m->i[linha].j[resposta_da_busca_binaria].valor = valor;
if (DEBUG_add_valor) {
printf("Voce alterou o valor da linha %d e coluna %d para %f \n", linha, coluna, valor);
printf("#Fim do add valor \n\n");
}
return;
}
// Caso seja 0 você não precisa adicionar no vetor, nós sabemos que toda parte da matriz sem numero é zero
if (valor == 0) {
if (DEBUG_add_valor) {
printf("Voce tentou adicionar um elemento com zero, isso nao eh necessario \n");
printf("#Fim do add valor \n\n");
}
return;
}
// Caso não tenha nenhuma coluna com valor e caso já tenha
if (m->i[linha].numero_de_colunas == 0)
{
m->i[linha].numero_de_colunas = 1;
m->i[linha].j = (Coluna*)malloc(sizeof(Coluna));
m->i[linha].j->numero_da_coluna = coluna;
m->i[linha].j->valor = valor;
if (DEBUG_add_valor) {
// Informando como foi adicionado e onde
printf("- Foi o primeiro elemento do vetor a ser adicionado \n");
printf("- Numero de linha adicionada: %d \n", linha);
printf("- Numero de colunas com nao zero nessa linha: %d \n", m->i[linha].numero_de_colunas);
printf("- Numero da coluna adicionada: %d \n", m->i[linha].j->numero_da_coluna);
printf("- Valor nessa linha e coluna: %f \n", m->i[linha].j->valor);
}
} else {
m->i[linha].numero_de_colunas++;
m->i[linha].j = (Coluna*)realloc(m->i[linha].j, sizeof(Coluna) * m->i[linha].numero_de_colunas);
// Agora nos queremos que fique em ordem de colunas então temos que adicionar no local certo
contador = m->i[linha].numero_de_colunas;
do {
// Caso a coluna adicionada seja a menor de todas
if ( (contador - 2) < 0) {
m->i[linha].j[contador-1].numero_da_coluna = coluna;
m->i[linha].j[contador-1].valor = valor;
if (DEBUG_add_valor) {
// Informando como foi adicionado e onde
printf("- Se tornou o primeiro da lista \n");
printf("- Numero de linha adicionada: %d \n", linha);
printf("- Numero de colunas com nao zero nessa linha: %d \n", m->i[linha].numero_de_colunas);
printf("- Numero da coluna adicionada: %d \n", m->i[linha].j[contador - 1].numero_da_coluna);
printf("- Valor nessa linha e coluna: %f \n", m->i[linha].j[contador - 1].valor);
}
break;
}
// Caso a coluna da esquerda seja menor, já pode salvar
if (m->i[linha].j[contador-2].numero_da_coluna < coluna) {
m->i[linha].j[contador-1].numero_da_coluna = coluna;
m->i[linha].j[contador-1].valor = valor;
if (DEBUG_add_valor) {
// Informando como foi adicionado e onde
printf("- Ele ficou ou no meio de alguma coluna ou eh a ultima \n");
printf("- Numero de linha adicionada: %d \n", linha);
printf("- Numero de colunas com nao zero nessa linha: %d \n", m->i[linha].numero_de_colunas);
printf("- Numero da coluna adicionada: %d \n", m->i[linha].j[contador - 1].numero_da_coluna);
printf("- Valor nessa linha e coluna: %f \n", m->i[linha].j[contador - 1].valor);
}
break;
} else {
// Caso a coluna do contador-2 seja maior, você tem que mover a coluna do contador-2 para direita e continuar procurando onde botar a coluna nova
m->i[linha].j[contador-1].numero_da_coluna = m->i[linha].j[contador-2].numero_da_coluna;
m->i[linha].j[contador-1].valor = m->i[linha].j[contador-2].valor;
contador--;
}
// Essa condicao do while não é recomendada
} while (1);
}
if (DEBUG_add_valor) {
printf("#Fim do add valor \n\n");
}
}
/*
* Multiplicação de matriz por vetor
* Bota o resultado no segundo vetor passado
* m >> matriz que vai ser usada
* v1 >> vetor que vai multiplicar a matriz
* v3 >> vetor que vai armazenar o resultado
* OBS: Na verdade multiplica matriz por matriz mas quando a matriz só tem uma linha, não é nada mais que um vetor.
* /\ Entenda isso como um "Você pode usar para multiplicar matriz por matriz tranquilamente"
* OBS2: Ordem faz diferença no resultado
*/
void multiplicacao_matriz_vetor(Matriz* m, Matriz* v1, Matriz* v2)
{
int contadorLinha; // Contador da linha
int contadorColuna; // Contador da coluna
int contador; // Contador que vai de 0 até numero de linha/coluna para pegar os elementos
double soma; // Armazena a soma de um dos elementos que vai ficar numa posicao [i][j] do novo vetor
int pos_da_busca_1; // Guarda a posicao da coluna que vai retornar da busca binaria
int pos_da_busca_2; // Guarda a posicao da coluna que vai retornar da busca binaria (para a segunda matriz)
if (DEBUG_multiplicacao_matriz_vetor)
printf("#Multiplicacao matriz por vetor \n");
// Vai linha por linha e coluna por coluna para fazer o calculo de matriz por vetor
for (contadorLinha = 0; contadorLinha < m->numero_de_linhas; contadorLinha++) {
if (DEBUG_multiplicacao_matriz_vetor)
printf("-----Linha: %d \n", contadorLinha);
for (contadorColuna = 0; contadorColuna < m->numero_de_linhas; contadorColuna++) {
if (DEBUG_multiplicacao_matriz_vetor)
printf("-----Coluna: %d \n", contadorColuna);
soma = 0;
for (contador = 0; contador < m->numero_de_linhas; contador++) {
if (DEBUG_multiplicacao_matriz_vetor) {
printf("-Andou uma coluna do primeiro \n");
printf("-Andou uma linha do segundo \n");
printf("-Para %d \n", contador);
printf("-Estado do somatorio: %f \n", soma);
}
pos_da_busca_1 = busca_binaria(contadorLinha, contador, m);
// Caso seja zero o valor do elemento, a multiplicação da zero
if (pos_da_busca_1 == -1) {
add_valor(contadorLinha, contadorColuna, soma, v2);
if (DEBUG_multiplicacao_matriz_vetor) {
printf("-Um dos elementos eh 0 (1) \n");
printf("-Somatorio %f \n", soma);
}
continue;
}
pos_da_busca_2 = busca_binaria(contador, contadorColuna, v1);
// Caso seja zero o valor do elemento, a multiplicação da zero
if (pos_da_busca_2 == -1) {
add_valor(contadorLinha, contadorColuna, soma, v2);
if (DEBUG_multiplicacao_matriz_vetor) {
printf("-Um dos elementos eh 0 (2) \n");
printf("-Somatorio %f \n", soma);
}
continue;
}
// Caso ambos não sejam zero, multiplicar e somar ao somatorio para botar naquela linha e coluna
soma = soma + (m->i[contadorLinha].j[pos_da_busca_1].valor * v1->i[contador].j[pos_da_busca_2].valor);
add_valor(contadorLinha, contadorColuna, soma,v2);
if (DEBUG_multiplicacao_matriz_vetor) {
printf("%f \n", m->i[contadorLinha].j[pos_da_busca_1].valor);
printf("%f \n", v1->i[contador].j[pos_da_busca_2].valor);
printf("-Nenhum dos elementos eh 0 \n");
printf("-Somatorio %f \n", soma);
}
}
}
}
if (DEBUG_multiplicacao_matriz_vetor) {
printf("#Fim da multiplicacao matriz por vetor \n");
}
}
