int buscar(no_hash *t, int k, int i)
{
if((i < tamanhoHash))//Garante a comparação com todos elementos
{
int j = gerar_pesos(k, i);
if(t[j].chave == k){
return 1;//Se for encontrado a função recebe o valor da pesquisa, e invalidando a 1º condicional
}
else
return buscar(t, k, ++i);//Se não encontrar ocorre há recursão
}
else
{
return 0;//Quando o elemento é encontrado j!=0, invalidando a 1º condicional
}
}
bool insertar (tListaCorreos &correos, const tCorreo &correo) {
bool inserCorrecta = false;
int pos, cont = correos.cont;
if (correos.cont < MAX_CORREOS) {
if (!buscar(correos, correo.id_correo, pos)) {
for (int i = cont; pos < i; i--)
correos.correo[i] = correos.correo[i - 1];
correos.correo[pos] = correo;
correos.cont++;
inserCorrecta = true;
}
}
return inserCorrecta;
}
Pagina* buscar(Pagina* actual, tipoClave cl, int* indice)
{
if (actual == NULL)
{
return NULL;
}
else
{
int esta;
esta = buscarNodo(actual,cl,indice);
if (esta)
return actual;
else
return buscar(actual -> ramas[*indice],cl,indice);
}
}
int main(){
CONTRATO c[10];
for(int i=0;i<10;i++)
{
c[i].fecha.dia = i;
}
buscar(c);
}
bool insertar (tListaUsuarios &usuarios, const tUsuario &usuario) {
bool inserCorrecta = false;
int pos, cont = usuarios.cont;
if (usuarios.cont < MAX_USUARIOS) {
if (!buscar(usuarios, usuario.identificador, pos)) {
for (int i = cont; pos < i; i--)
usuarios.usuario[i] = usuarios.usuario[i - 1];
usuarios.usuario[pos] = usuario;
usuarios.cont++;
inserCorrecta = true;
}
}
return inserCorrecta;
}
int main() {
int i;
//criar a lista
LISTA_LIGADA lista;
criar(&lista);
//inserir itens na &lista
for (i = 0; i < 10; i++) {
ITEM item;
item.chave = 9-i;
item.valor = rand();
inserir(&lista, &item);
}
imprimir(&lista);
printf("---\n");
ITEM item1;
if (buscar(&lista, 4, &item1)) {
printf("encontrado: %d - %d\n---\n", item1.chave, item1.valor);
}
remover_posicao(&lista, 5);
imprimir(&lista);
printf("---\n");
ITEM item2;
item2.chave = 4;
item2.valor = 333;
inserir(&lista, &item2);
imprimir(&lista);
printf("---\n");
remover_fim(&lista);
remover_fim(&lista);
remover_fim(&lista);
imprimir(&lista);
printf("---\n");
apagar_lista(&lista);
return 0;
}
template <typename T> void lista_nodo<T>::agregar(T id) {
if (buscar(id)) return;
nodo<T> *_nodo = new nodo<T>;
_nodo->id_nodo = id;
_nodo->bandera = 0;
_nodo->ruta_corta = 0;
_nodo->ant = NULL;
_nodo->saliente = new lista_arco<T>;
if (donde == MIFA) {
_nodo->sig = anterior->sig;
anterior->sig = _nodo;
} else {
_nodo->sig = principio;
principio = _nodo;
}
agregado = _nodo;
}
bool insertar(tListaUsuarios & usuarios, const tUsuario & usuario, int &pos) {
bool insertando;
if (usuarios.contador < N) {
pos = 0;
insertando = buscar(usuarios, usuario.identificador, pos);
if (!insertando) {
desplazarDerecha(usuarios, pos);
usuarios.usuario[pos] = usuario;
usuarios.contador++;
}
}
return insertando;
}
void baja (parbol ** r, int valor)
{
parbol *ant, *act, *aux;
buscar (*r, valor, &ant, &act);
if (act == NULL)
printf ("\aNo existe %d en el árbol \n", valor);
else {
aux = act;
if ((act->d == NULL) && (act->i == NULL)) /* nodo hoja */
if (ant == NULL)
*r = NULL;
else if (ant->d == act)
ant->d = NULL;
else
ant->i = NULL;
else if ((act->d != NULL) && (act->i != NULL)) { /* 2 hijos */
ant = act;
aux = ant->i;
while (aux->d) {
ant = aux;
aux = aux->d;
}
act->clave = aux->clave;
if (ant == act)
ant->i = aux->i;
else
ant->d = aux->i;
}
else /* 1 hijo */ if (act->d == NULL) /* hijo izquierdo */
if (ant == NULL)
*r = act->i;
else if (ant->d == act)
ant->d = act->i;
else
ant->i = act->i;
else /* act-> i = null. TIENE HIJO DERECHO */ if (ant == NULL)
*r = act->d;
else if (ant->d == act)
ant->d = act->d;
else
ant->i = act->d;
free (aux);
}
} /* baja */
void baja (struct nodo **cl, int valor)
{
struct nodo *ant, *act;
int hallado;
buscar (*cl, valor, &hallado, &ant, &act);
if (!hallado)
printf ("No existe el dato en la lista \n");
else {
if (ant == NULL)
*cl = act->sig;
else
ant->sig = act->sig;
if (act->sig)
act->sig->ant2 = ant;
free (act);
}
} /* baja */
/*
Remove um valor de uma tabela hash.
*/
bool remover( TabelaHash *tabelaHash, int valor ) {
int posicao = buscar( tabelaHash, valor );
if ( posicao != -1 ) {
tabelaHash->valores[posicao].status = LIVRE;
tabelaHash->valores[posicao].valor = 0;
return true;
} else {
return false;
}
}
int menuCrud(int opcE){
int opcO, //var que recebe a oopc do menu crud
bolinho = 0; //var de controle pra voltar ao menu de ent
//aqui vai o menu crud
printf("Insira a operacao desejada:\n");
printf("\t1 - Inserir\n\t2 - Excluir\n\t3 - Atualizar\n\t4 - Buscar\n\t\t\t\t -1 - VOLTAR\n\t: ");
scanf("%d", &opcO);
getchar();
//fflush(stdin);
switch(opcO){
case 1:
inserir(opcE);
break;
case 2:
excluir(opcE);
break;
case 3:
atualizar(opcE);
break;
case 4:
buscar(opcE);
break;
case -1:
bolinho = 1;
printf("Bolinho com mostarda\n");
break;
default:
printf("Opção invalida!");
break;
}
system("clear");
if(bolinho == 1){
return 1;
}else{
menuCrud(opcE);
}
return 0;
}
main(){
incluir_teste();
mostrar();
/*
printf("Digite a matricula procurada: ");
scanf("%d",&matricula);
int posicao = buscar(matricula);
system("cls");
if(posicao != -1){
printf("Item procurado:\n");
printf("Matricula: %d\n",aluno[posicao].matricula);
printf("Nome: %s\n",aluno[posicao].nome);
printf("Idade: %d",aluno[posicao].idade);
}else{
printf("Nenhum dado encontrado");
}
*/
int i;
for(i = 0;i < 2;i++){
int mat;
printf("Digite a matricula a remover: ");
scanf("%d",&mat);
int pos_aluno = buscar(mat);
remover2(pos_aluno);
}
int id_maior = obtem_nota("maior");
printf(" ALUNO COM MAIOR NOTA\n");
printf("------------------------\n");
printf(" Matricula: %d \n",aluno[id_maior].matricula);
printf("------------------------\n");
printf(" Nome: %s\n",aluno[id_maior].nome);
printf("------------------------\n");
printf(" Idade: %d\n",aluno[id_maior].idade);
printf("------------------------\n");
printf(" Nota: %d\n",aluno[id_maior].nota);
}
void main() {
clrscr();
cprintf("Dato:\n");
while(x<9) {
kbhit();
n = buscar(getch());
ci[x] = abc[n];
cf[x] = abc[n+1];
x++;
}
printf("%s", cf);
printf("\n\n");
printf("%s", ci);
getch();
}
int main() {
FILE* arquivo;
TNo* raiz = NULL;
int id, opcao;
char nome[255];
float av1, av2, av3;
criaNovoArquivoModificado();
if ((arquivo = fopen("ALTERADO.DAT", "r")) == NULL) {
printf("Erro ao tentar abrir o arquivo.\n\n");
exit(1);
}
arquivo = fopen("ALTERADO.DAT", "r");
while (!feof(arquivo)) {
fscanf(arquivo, "%d;%[^;]s", &id, nome);
fscanf(arquivo, ";%f", &av1);
fscanf(arquivo, ";%f", &av2);
fscanf(arquivo, ";%f;", &av3);
if (!feof(arquivo)) {
raiz = cadastrar(raiz, raiz, id, nome, av1, av2, av3);
}
}
opcao = usaMenu();
if(opcao == 1) {
printf("Opção 1 Escolhida");
imprimirEmOrdem(raiz);
} else {
printf("Opção 2 Escolhida\n");
printf("Digite o id do aluno:\n");
scanf("%d", &id);
buscar(raiz, id);
}
return 0;
}
//Remover todas as ocorrências de 'num', retornando o total de ocorrências.
//Logo, se o valor zero for retornado, indicará que o elemento não se
//encontrava na lista
int remover (TLista *L, int num)
{
int maior, qtd, pos = buscar(*L, num, &maior);
if(pos == -1) //se "num" não está na lista
{
qtd = 0;
}
else
{
qtd = quantDeOcorren(L, pos, maior-1);
//quantas vezes "num" aparece na lista
dimPosNaFila(L, qtd, maior,L->quant-1);
//anda com a lista, copiando o conteúdo dos índices que estavam
//depois de "num" para as posições que "num" ocupava
L->quant = L->quant - qtd;
//diminui "qtd" índices válidos no total da lista
}
return qtd;
}
int main(){
double tiempo;
printf("La expresion de los datos a nivel de pantalla podria contener errores\n");
printf("Debido a que las bases de datos algunas tienen acentos, y c no las imprime\n");
printf("Presione Enter para continuar\n");
getchar();
time_t inicio,final;
THash *thash = inicializarTHash();
time(&inicio);
c_Archivo(thash);
time(&final);
tiempo = difftime(final,inicio);
printf("El tiempo de carga fue de %f segundos\n",tiempo);
genera_ArchivoTabla(thash);
printf("Archivo de dispersion generado\n");
buscar(thash);
getchar();
getchar();
getchar();
return 0;
}
/*
* Función que borra un nodo y libera la memoria.
*/
lista* borrar(int id){
lista* temporal = head;
if(buscar(id) == true){
while(temporal != NULL){
if(temporal-> identificador == id && temporal->cantidad > 1){
temporal->cantidad -= 1;
return head;
}
temporal = temporal->siguiente;
}
lista* borrando = buscarNodo(id);
lista* previo = buscarAnterior(id);
previo->siguiente = borrando->siguiente;
borrando->siguiente = NULL;
free(borrando);
borrando = NULL;
return head;
}
else{
return head;
}
}
/*
* eliminar es una función que dado un elemento de la lista, lo elimina y hace
* free para liberar memoria.
* Argumentos: list, es un apuntador a la lista.
* codigo, es un entero que representa el código de la pregunta a eliminar.
* Retorna: 1 si elimina la pregunta exitosamente, 0 en caso contrario.
*/
int eliminar(LISTA **list, int codigo){
LISTA **temp;
temp = buscar(list,codigo);
if (temp != NULL){
//Cuando hay un solo elemento en la lista.
if((*temp)->sig == NULL && (*temp)->ant == NULL){
*list = NULL;
free(*temp);
}
//Aquí estamos eliminando el último nodo.
else if((*temp)->sig == NULL && (*temp)->ant != NULL){
**list = *(*list)->ant; //Situamos el último en el anterior.
(*list)->sig = NULL;
free(*temp);
}
//Aquí estamos eliminando el primer nodo.
else if((*temp)->sig != NULL && (*temp)->ant == NULL){
(*temp)->sig->ant = NULL;
free(*temp);
}
//Aquí estamos en un caso del medio.
else{
(*temp)->ant->sig = (*temp)->sig;
(*temp)->sig->ant = (*temp)->ant;
free(*temp);
}
return 1;
}
else
return 0;
}
/*
* Función que incerta ordenadamente en la lista
*/
lista* insertar(int id){
if(head == NULL){ //si la lista esta vacia, cree un nodo cabeza.
(crearLista(id));
}
lista* temporal = //head; creo un puntero temporal a la cabeza de la lista.
if(buscar(id) == true){ //busco si el nodo existe
while(temporal != NULL){ //si es así debo solamente aunemtar el contador de la cantidad del nodo
if(temporal-> identificador == id){
temporal->cantidad += 1;
return head; //termina la ejecucuón
}
temporal = temporal->siguiente;
}
}
// si el nodo no existe, debo asignar la memoria para el almacenamiento de este.
lista* ptr = (lista*)malloc(sizeof(lista));
if(NULL == ptr){
return NULL;
printf("Error al asignar la memoria\n");
}
//asigno los valores que concervan la información del puntero
ptr->identificador = id;
ptr->cantidad = 1;
ptr->siguiente = NULL;
//me preparo para insertar el nodo nuevo
lista *previo;
temporal = head->siguiente; //asigno 2 punteros, 1 al head y otro al siguiente
previo = head;
//digo que mientras no termine y no encuentre un id mayor al q voy a insertar
while(temporal != NULL && temporal->identificador < id) {
previo = temporal;
temporal = temporal->siguiente;
}
//inserto el nodo.
ptr->siguiente = temporal;
previo->siguiente = ptr;
return head;
}
void Arbol::eliminar(QString valor)
{
if(!inicio)
{
return;
}
Arbol* borrar = buscar(valor, this->inicio);
if(!borrar->hijo_derecho && !borrar->hijo_izquierdo)
{
return delete borrar;
}
Arbol* temp;
if(borrar && !borrar->hijo_derecho)
{
temp = borrar;
borrar = borrar->hijo_izquierdo;
return delete temp;
}
else if(borrar && !borrar->hijo_izquierdo)
{
temp = borrar;
borrar = borrar->hijo_derecho;
return delete temp;
}
else
{
Arbol* temp_hijos = borrar->hijo_derecho;
borrar = borrar->hijo_izquierdo;
Arbol* temp_hijo_der = getMaxDer(borrar);
temp_hijo_der->hijo_derecho = temp_hijos;
}
}
int inserirOrdenado(TLista *L, char *palavra){
TLista aux = buscar(*L,palavra);
TLista atual,anterior;
if (aux){ //se o elemento existe na lista
return 0;
}
aux = malloc(sizeof(TNo)); //alocacao da memoria.
if (!aux){ //não houver memoria disponivel
return 0;
}
strcpy(aux->palavra,palavra); //copia da palavra
if (!*L){ //lista vazia
*L = aux;
aux->prox = NULL;
return 1;
}
else{ //lista não vazia
atual = *L; //aponta para o primeiro da lista.
//antes do primeiro
if (strcmp(palavra,atual->palavra)<0){ //<0 = esq < dir
aux->prox = *L;
*L = aux;
return 2;
}
else{ //depois do primeiro
while(atual && (strcmp(palavra,atual->palavra)>0)){
anterior = atual;
atual = atual->prox;
}
aux->prox = atual;
anterior->prox = aux;
return 3;
}
}
}
main()
{
int i;
enlace l;
l=NULL;
insertar(&l, 1);
insertar(&l, 2);
insertar(&l, 4);
insertar(&l, 3);
i = buscar(l, 3);
printf("Esta el 3? : %d\n",i);
printf("IMPRIME\n");
listar(l);
eliminar(&l, 4);
printf("IMPRIME\n");
listar(l);
}
void alta (parbol ** r, int valor)
{
parbol *ant, *act;
buscar (*r, valor, &ant, &act);
if (act)
printf ("\a\aLa clave %d ya existe \n", valor);
else {
act = (parbol *) malloc (sizeof (parbol));
if (act == NULL)
printf ("NO EXISTE ESPACIO DISPONIBLE \n");
else {
act->clave = valor;
act->i = NULL;
act->d = NULL;
if (ant == NULL)
*r = act;
else if (ant->clave > valor)
ant->i = act;
else
ant->d = act;
}
}
} /* alta */
Entrada *buscar_ht(char *key)
{
return buscar(hashTable[hash(key)], key);
}
//----------------------------Implementação da Main-----------------------------
int main ()
{
int opcao, num1, num2;
int pos, cap;
TLista lista;
printf ("Capacidade da lista: ");
scanf ("%d", &cap); getchar();
lista = inicializar (cap);
//Um menu será exibido ao usuário até que este opte pela saída do sistema
do {
//é exibido o menu ao usuário e retornada a alternativa escolhida
opcao = menu ();
switch (opcao) {
//Inserir
case 1: printf ("Entre com o número a ser inserido: ");
scanf ("%d", &num1); getchar();
if (inserir (&lista, num1) == TRUE) {
printf ("Elemento inserido com sucesso!\n");
} else {
printf ("ERRO: Elemento não inserido!\n");
}
break;
//Remover
case 2: printf ("Entre com o número a ser removido: ");
scanf ("%d", &num1); getchar();
if (remover (&lista, num1)) { //o mesmo que remover (&lista, num1) > 0
printf ("Elemento removido com sucesso!\n");
} else {
printf ("ERRO: Elemento não removido!\n");
}
break;
//Alterar
case 3: printf ("Entre com o número a ser alterado: ");
scanf ("%d", &num1); getchar();
printf ("Entre com o novo número: ");
scanf ("%d", &num2); getchar();
if (alterar (&lista, num1, num2)) {
printf ("Elemento alterado com sucesso!\n");
} else {
printf ("ERRO: Elemento não alterado!\n");
}
break;
//Buscar
case 4: printf ("Entre com o número a ser buscado: ");
scanf ("%d", &num1); getchar();
//"cap" não é mais usada nesse momento
pos = buscar (lista, num1, &cap);
//O elemento foi encontrado e retornada a posição de sua
//primeira ocorrência
if (pos >= 0) {
printf ("Elemento encontrado na lista (posicao %d)!\n", pos);
} else {
printf ("ERRO: Elemento não encontrado!\n");
}
break;
//Exibir
case 5: exibir (lista);
break;
//Tamanho
case 6: printf ("Há %d elementos na lista!\n", tamanho(lista));
break;
//Sair
case 7: printf ("Fim do programa!\n");
break;
//Opção inválida!
default: printf ("Opção inválida! Tente novamente!\n");
}
getchar();
} while (opcao != 7);
}
int main(int argc, char **argv) {
/* inicializa os alunos */
Aluno *aluno1 = inicializarAluno("Andre", 10.0f);
Aluno *aluno2 = inicializarAluno("Bruno", 9.0f);
Aluno *aluno3 = inicializarAluno("Carlos", 6.0f);
Aluno *aluno4 = inicializarAluno("Denis", 8.0f);
Aluno *aluno5 = inicializarAluno("Roberto", 4.5f);
Aluno *aluno6 = inicializarAluno("Anderson", 7.0f);
Aluno *aluno7 = inicializarAluno("Anwerzig", 9.9f);
Aluno *aluno8 = inicializarAluno("Ankrutzonh", 5.9f);
Aluno *aluno9 = inicializarAluno("Ankrutzonhxsdt", 3.9f);
Aluno *aluno10 = inicializarAluno("Andri", 9.5f);
Aluno *aluno11 = inicializarAluno("Andri", 9.2f);
Aluno *aluno12 = inicializarAluno("Andri", 9.0f);
Aluno *aluno13 = inicializarAluno("Joaozao", 2.0f);
/* inicializa a tabela hash */
int m = 256;
Hash *hashTable = inicializarHash(m);
/* insere valores na tabela hash */
inserir(hashTable, aluno1, m);
inserir(hashTable, aluno2, m);
inserir(hashTable, aluno3, m);
inserir(hashTable, aluno4, m);
inserir(hashTable, aluno5, m);
inserir(hashTable, aluno6, m);
inserir(hashTable, aluno7, m);
inserir(hashTable, aluno8, m);
inserir(hashTable, aluno9, m);
inserir(hashTable, aluno10, m);
inserir(hashTable, aluno11, m);
inserir(hashTable, aluno12, m);
/* remove elementos da tabela hash */
remover(hashTable, aluno10, m);
//remover(hashTable, aluno11, m);
//remover(hashTable, aluno12, m);
/* percorre a tabela Hash */
percorrerTabelaHash(hashTable, m);
/* procura por um elemento */
Aluno *enderecoBusca = buscar(hashTable, aluno3, m);
if(enderecoBusca == NULL) {
printf("Elemento nao encontrado!\n");
} else {
printf("Elemento %s com nota %.1f encontrado!\n",
enderecoBusca->nome, enderecoBusca->nota);
}
/* libera os alunos e a tabela hash da memoria */
destruirAluno(&aluno1);
destruirAluno(&aluno2);
destruirAluno(&aluno3);
destruirAluno(&aluno4);
destruirAluno(&aluno5);
destruirAluno(&aluno6);
destruirAluno(&aluno7);
destruirAluno(&aluno8);
destruirAluno(&aluno9);
destruirAluno(&aluno10);
destruirAluno(&aluno11);
destruirAluno(&aluno12);
destruirHash(&hashTable);
return 0;
}
size_t ConjuntosDisjuntosMod::buscar(size_t p) const {
if (id[p] < 0) // es una raíz
return p;
else
return id[p] = int(buscar(id[p]));
}
string Buscador::buscarPorNombre(string username, string nombre) {
auto predicate = [&] (MetadatoArchivo& metadato) -> bool {return match(metadato.nombre, nombre);};
map<string, string> estructuraPermisos = buscar(username, predicate);
string jsonEstructuraFileSystem = obtenerEstructuraCarpeta(username, true, predicate);
return ParserJson::estructurasMerge(estructuraPermisos, jsonEstructuraFileSystem);
}
int main(){
TLista L[10] = {NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL,NULL};
int opcao,i,controle=1,controle1=1;
char palavra[50],palavra1[50];
//TLista pos;
do {
opcao = menu ();
switch (opcao) {
//Inserir
case 1:
while (1){
//system("clear");
printf("\n\n");
printf("Escreva a palavra a Inserir (0 para sair): ");
scanf("%s",palavra);
if (!strcmp(palavra,"0")){
break;
}
else{
minuscula(palavra);
if (inserirOrdenado(&L[hash(palavra)],palavra)){
printf("Inserção OK");
}
else{
printf("Falha ao inserir");
}
}
}
break;
//Remover
case 2:
printf("escreva a palavra a remover: ");
scanf("%s",palavra);
minuscula(palavra);
if (remover(&L[hash(palavra)],palavra)){
printf("remover OK!");
}
else{
printf("remover FALHOU!");
}
break;
//Alterar
case 3:
printf("Escreva a palavra que sera removida: ");
scanf("%s",palavra);
minuscula(palavra);
printf("Escreva a palavra que sera inserida: ");
scanf("%s",palavra1);
minuscula(palavra1);
if (remover(&L[hash(palavra)],palavra)){
printf("remover OK!\n");
if (inserirOrdenado(&L[hash(palavra1)],palavra1)){
printf("Inserção OK\n");
}
else{
printf("Falha ao inserir\n");
}
}
else{
printf("remover FALHOU!\n");
}
break;
//Buscar
case 4:
printf("insira a palavra a buscar: ");
scanf("%s",palavra);
minuscula(palavra);
if (buscar(L[hash(palavra)],palavra)){
printf("A Palavra %s, EXISTE!\n",palavra);
}
else{
printf("A Palavra %s, NAO EXISTE!\n",palavra);
}
break;
//Exibir
case 5:
system("clear");
for (i=0;i<10;i++){
exibir(L[i],i);
}
scanf("%d",&i);
break;
//Exibir lista
case 6:
printf("insira a linha a exibir: ");
scanf("%d",&i);
system("clear");
i--;
exibir(L[i],i);
scanf("%d",&i);
break;
//Sair
case 7: printf ("Fim do programa!\n");
controle = 0;
break;
//Op??o inv?lida!
default:
printf ("opcao invalida! Tente novamente!\n");
break;
}
} while (controle);
}
