/*
 *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");
		}

	}

}
Beispiel #2
0
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);
			}

		}

	}
}
Beispiel #5
0
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;
}
Beispiel #6
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++;
}
Beispiel #11
0
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;
}
Beispiel #12
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");
	}

}