UmPrograma

Boa tarde, tudo bem? Gostaria de saber se a biblioteca conio.h é da linguagem C ou C++, e tambem da biblioteca sys/types.h. Alguem sabe me informar. (estava estudando uns algoritmos na internet e me deparei com essas bibliotecas, elas sao exclusivas da linguagem C.

Nao vou menti que meu cerebro bug um pouco quando tenho que fazer essas mudancas de letra para numero. Nao entendo estão bem. Mas valeu... nessa parte quer dizer que o alfabeto com as letras maiuscalas comeca com o numero 65, ne?! legal

nao conheco ascii. mas vou ver

@Flávio Pedroza Gente, não sabia. E o que eu faço? Uso a posicao da letra na string como valor para minha equação? adicionado 4 minutos depois Assim me retorna a posição, mas tenho a leve sensação que quem escolheu a posição fui eu. Fora que teve colisões #include <stdio.h> #include <string.h> int tamanhoTabela = 16; void convert (char *dado){ int i, vet[strlen(dado)], a=0; for(i=0;i<strlen(dado);i++){ a++; vet[a]= 11*i/tamanhoTabela; printf("A letra %c ocupa na tabela a posicao %d.\n", dado[i], vet[a]); } } int main() { int i=0; char *dado = "UNIVERSIDADE"; printf("\nA palavra a ser guardada na tababela hash sera UNIVERSIDADE.\n"); convert(dado); }

Oi, como vão? Alguem poderia olhar a seguinte funcao e me dizer porque nao esta retornando, ficaria grato. Algo me intui que estou usando a funcao 'atoi' errado, mas nao sei se é somente isso. Esse exercicio se trata de uma funcao hash, onde cada letra da palavra UNIVERSIDADE tem que ser transformada em um indice da tabela hash. Segue a funcao. #include <stdio.h> #include <string.h> int tamanhoTabela = 16; void convert (char *dado){ int i, vet[strlen(dado)]; for(i=0;i<strlen(dado);i++){ vet[i]= 11*atoi(dado[i])/tamanhoTabela; printf("A letra %s ocupa na tabela a posicao %d.\n", dado[i], vet[i]); } } int main() { int i=0; char *dado = "UNIVERSIDADE"; printf("\nA palavra a ser guardada na tababela hash sera UNIVERSIDADE.\n"); convert(dado); }

uiii adicionado 1 minuto depois kali esta ligado a pentest. ja que quero para o mesmo fim.

@loumier que isso? nao entendi adicionado 0 minutos depois que variaveis seriam essas? adicionado 44 minutos depois pensei que sei atualizar com aquelas linhas de comando ja meio que conhecidas no linux, terminal do linux. Mas nao funciona (NAO SEI O QUE FAZER) Aproveitando o embalo, o que acham do Kali Linux? (meu objetivo é realmente entender sobre pentest, segurança na internet, forense...)

Oi pessoal. estava querendo iniciar meus estudos em pentest e tal. Ai nao queria mudar para alguma distribuição linux, entao baixei o pentestbox no Windows mas não funciona. Nenhuma funcao é encontrada. e pede para atualizar e quando tento dar erro. Alguem ja passou por isso aqui? podem me ajudar?

@r_Tray nao sei exatamente como seria otimizado. Mas agradeço. Valeu...a todos.

estou tendo que transformar uma funcao c++ para c, ai to me perdendo em tudo. Pois nao conheco c++ :-( adicionado 6 minutos depois alias, a funcao puclic em c++ é o que?

Oi Incluindo a biblioteca windows, isso permite que se use a funcao Sleep, que faz com que acha uma pausa/demora no tempo. porém achava que ele funciona com segundos, mas os valores que coloco la dentro nao surtem tantos efeitos. So se for valores maiores. Ela funciona com segundos, milisegundos? com o que? alguem sabe?

todos os nos folhas (aqueles que nao tem filho) devem esta no mesmo nivel (na mesma altura) adicionado 7 minutos depois Está otimo, perfeito diria. So que é uma arvore balanceada, acho que essa seja nao seja balanceada... Nesse algortimo que fiz, nao sei se chegou a roda-lo, mas nele nao consigo passar para a funcao insere. Ai eu passei os valores no proprio main, e depois imprimir. (so que nem o meu é uma arvore 2-3) Não sei... adicionado 14 minutos depois Mas eu posso mudar de tal forma que tenha a aparencia de uma arvore 2-3.

difícil ne?!

#include <stdio.h> #include <stdlib.h> typedef struct no{ int key1; int key2; int nkey; struct no *left; struct no *middle; struct no *right; }No; No *CriaNovo(){ No *aux; aux = malloc(sizeof(No)); return aux; } No *criaNo(int ch1, int ch2, int nchaves, No *pl, No *pc, No *pr){ No *n; n->key1=ch1; n->key2=ch2; n->nkey=nchaves; n->left=pl; n->middle=pc; n->right=pr; return n; } int isLeaf(No *no){ if(no==NULL){ return 1; } } void adicionaChave(No *no,int val, No* pon){ no->key1 =val; no->key2=pon->key1; } No *quebraNo(No *no, int val, int *rval, No *subarvore){ No *paux; if (val > no->key2) { // val esta mais a direita *rval = no->key2; // promove a antiga maior paux = no->right; no->right = NULL; // elimina o terceiro filho no->nkey = 1; // atualiza o número de chaves return criaNo(val, 0, 1, paux, subarvore, NULL); } else if (val >= no->key1){ // val esta no meio *rval = val; // continua sendo promovido paux = no->right; no->right = NULL; no->nkey = 1; return criaNo(no->key2, 0, 1, subarvore, paux, NULL); } else { // val esta a mais a esquerda *rval = no->key1; // primeiro cria o nó a direita paux = criaNo(no->key2, 0, 1, no->middle, no->right, NULL); no->key1 = val; // em seguida arruma o nó a esquerda no->nkey = 1; no->right = NULL; no->middle = subarvore; return paux; } } No *busca(No *raiz, int chave){ if(raiz==NULL){ printf("Árvore vazia!\n"); return NULL; } if(chave == raiz->key1){ return raiz; } if((raiz->nkey == 2) && chave == raiz->key2){ return raiz; } if(chave < raiz->key1){ return busca(raiz->left, chave); } else if((raiz->nkey == 2)&& chave < raiz->key2){ return busca(raiz->middle, chave); } else if((raiz->nkey == 2)&& chave > raiz->key2){ return busca(raiz->right, chave); } } No *insere( No **no, int val, int *rval){ No *paux, *paux2; int vaux, promov; if (*no == NULL) { // arvore vazia *no = (No *) malloc (sizeof(No)); *no = criaNo(val, 0, 0, NULL, NULL, NULL); // cria no folha com um valor return NULL; // nada a fazer depois } if (isLeaf(*no)){ // chegou a folha if ((*no)->nkey == 1){ // caso fácil adicionaChave(*no, val, NULL); return NULL; } else { paux = quebraNo(*no, val, &vaux, NULL); *rval = vaux; return paux; } } else { // continua a procura if (val < (*no)->key1) paux = insere( &((*no)->left), val, &vaux); else if (((*no)->nkey == 1) || (val < (*no)->key2)) paux = insere( &((*no)->middle), val, &vaux); else paux = insere( &((*no)->right), val, &vaux); if (paux == NULL) // nao promoveu return NULL; else if ((*no)->nkey == 1){ adicionaChave(*no, vaux, paux); return NULL; } else { paux2 = quebraNo(*no, vaux, &promov, paux); *rval = promov; return paux2; } } } void imprimir(No *no){ No* ajuda=no; if(no==NULL){ printf("Arvore vazia!\n"); } else if(no!=NULL){ if(no->nkey==1){ printf("%d, ", no->key1); if(no->left!=NULL){ printf("%d, ", no->left); return imprimir(no->left); } else if(no->right!=NULL){ printf("%d, ", no->right); return imprimir(no->right); } } if(no->nkey==2){ printf("%d, ", no->key1); printf("%d, ", no->key2); if(no->left!=NULL){ do{ printf("%d, ", no->left); }while (no->left==NULL); } if(no->middle!=NULL){ do{ printf("%d, ", no->middle); }while (no->middle==NULL); } if(no->right!=NULL){ do{ printf("%d, ", no->right); }while (no->right==NULL); } } } } int main(){ int key1, key2; No* aux, *a, *b, *c; aux = (No*)malloc(sizeof(No)); a=5;b=17;c=22; key1=10;key2=20; aux->key1 = key1;aux->key2 = key2;aux->nkey=2; aux->left = a;aux->middle = b;aux->right = c; imprimir(aux); return 0; }

Como assim? o que a de errado? A funcao busca é recursiva adicionado 0 minutos depois kkk agora que fui entender que tu disse que nao esta errada. entao ta certa kkkkk ooo vida Tambem acho que é na funcao. Mas nao sei o que posso fazer

@Flávio Pedroza É find Mas ai é so um exemplo adicionado 1 minuto depois Estava tentando usar isso para printar na tela se encontrou ou nao. Mas nao funcionou adicionado 5 minutos depois Ela so funciona para um caso. Se eu mudar o valor que entra, por exemplo tirando o "valor" e colocando outra coisa que nao esteja na estrutura o algoritmo na funcao principal nao printa na tela que "Não achou" adicionado 7 minutos depois Desse jeito: No* res; res = busca(aux, valor); if(res==0 || res ==NULL){ printf("Nao achou"); } else printf("Achou");

hm

Como faço para printar na tela se encontrei ou nao...

Pessoal, como eu sei o que a funcao esta retornando, se é verdadeiro ou falso. Em C nao tem booleano, e sim 0 e 1. Ai na seguinte funcao é para me retornar se encontrou ou não o valor. porém não esta funcionando. segue a funcao no23 *find(no23 *raiz, int key) { if (raiz==NULL) return NULL; // não encontrou if (key == raiz->lkey) return raiz; // é a chave esquerda if ((raiz->nkeys == 2) && (key == raiz->rkey)) return raiz; // é a chave direita if (key < raiz->lkey) return find(raiz->left, key); else if (raiz->nkeys == 1) return find(raiz->center, key); else if (key < raiz->rkey) return find(raiz->center, key); else return find(raiz->right, key); } Ai eu tento fazer o seguinte if(busca(aux, valor)!=NULL) printf("Encontrado"); Mas não funciona. adicionado 16 minutos depois 0 é verdadeiro e 1 é falso?

Transformar algoritmo de java em c Import Java . Util . ArrayList ; classe pública T23Map < K extends Comparável <? super K >, V > { // K: tipo de chave, V: tipo de valor //////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /////// definição comum ////////////////////////////////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / private class Par { // tipo de elemento K key = null ; // chave V value = null ; // value Par () {} par ( K chave , V x ) { este . Key = tecla ; este . Valor = x ; } } private class Node { // tipo de nó int nways ; // tipo de nó // 2: nó bidirecional // 3: nó tridirecional // -2: nó bidirecional (nó ativo na inserção) // -1: ramificação sem nós (nó activo quando a exclusão) Par e1 = nulo ; // elemento 1 do nó Par e2 = nulo ; // (nulo se a um elemento) elemento 2 do nó do nó lst = null ; // subárvore esquerda nó mst = nulo ; // subárvore intermediária Nó primeiro = nulo ; // subárvore direita Node () { Nways = 0 ; } // fazer provisória nó Node ( Par e ) { Nways = - 2 ; e1 = e ; } fazer // nó ativo 2 ramos // reutilização de memória nó de idade para criar um novo nó do nó Reutilização ( Int N , Par E1 , Par E2 , Nó G , Nó H , Nó R ) { Este . Nways = N ; Este . E1 = E1 ; Este . e2 = E2 ; este . lst = l ; este . mst = m ; este .rst = r ; devolva isto ; } // reutilizar memória nó inferior velha criação de um novo nó Node reutilização ( int n , Par e ) { isso . Nways = n ; isso . E1 = e ; isso . E2 = nulo ; retornar este ; } // converte o nó ativo para o nó normal de Node um deactivate () { Nways = Math . Abs ( Nways ); retornar este ; } } privado Nó raiz = nulo ; // 2-3 raízes privada Par aux ; // DeleteMax Variável auxiliar para // Se t é um nó ativo verdadeiro privada boolean ativa ( Node t ) { return t =! Null && t . Nways < 0 ; } // apara ramos extras estendidos void trim () { if ( ativo ( root )) root = root . Mst ; } ////////////////////////////////////////////////// ///////////////////////// // insero (insert) /////////////////// ////////////////////////////////////////////////// /////// // insere o valor x na raiz da árvore com a chave pública public void insert ( tecla K , V x ) { root = insert ( raiz , novo par ( chave , x )). Deactivate (); } // inserir uma entrada e na árvore t private Node inserção ( nó t , Par e ) { um if ( t == nulo ) retornar new new Node ( e ); // inserir um nó ativo int CMP1 = e . Key . CompareTo ( t . e1 . key ), cmp2 ; : interruptor ( t . Nways ) { caso 2 : uma se ( cmp1 < 0 ) { t . lst = inserir ( t . lst , e ); retornar equilíbrio2Li ( t ); } else if ( cmp1 == 0 ) { t . e1 = e ; retorno t ; } else / * cmp1> 0 * / { t . Rst = inserir ( t . Rst , e); Retorno Balance2Ri ( t ); } Caso 3 : cmp2 = e . Key . CompareTo ( t . E2 . Key ); um caso ( CMP1 < 0 ) { t . Lst = inserção ( t . Lst , e ); retornar Balance3Li ( t ); } else if ( cmp1 == 0 ) { T . E1 = E ; retorno t ; } else um se ( cmp2 < 0 ) { t . Mst = inserção ( t . Mst , e ); retornar Balance3Mi ( t ); } else um se ( cmp2 == 0 ) { t . e2 = e ; return t ; } else / * Cmp2> 0 * / { t . Rst = inserção ( t . Rst , e ); retornar Balance3Ri ( t ); } padrão : Buggy ( "inserir" ); } return nula ; } / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// // de equilíbrio no tempo de padrão de ajuste inserção //////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ////////// Privado Nó Balance2Li ( Node T ) { Node A = T . Lst ; Se (! Ativo ( A )) Retorno T ; Retorno A . Reuse ( 3 , A . E1 , T . E1 , A . Lst , A . Rst , T . rst ); } Privado Nó Balance2Ri ( Node T ) { Node A = T . Rst ; Se (! Ativo ( A )) Retorno T ; Retorno A . Reuse ( 3 , T . E1 , A . E1 , T . Lst , A . Lst , A . rst ); } Privado Nó Balance3Li ( Node T ) { Node A = T . Lst ; Se (! Ativo ( A )) Retorno T ; Nó R = New Node (); R . Reutilizar ( 2 , T . E2 , Null , T . Mst , Null , T . Rst ); Retorno T . Reuse(- 2 , t . E1 , nulo , um . Um desactivar (), nulo , r ); } Privado Nó Balance3Mi ( Node T ) { Node A = T . Mst ; Se (! Ativo ( A )) Retorno T ; Nó R = New Node (); A . Rst = R . Reutilizar ( 2 , T . E2 , Null , Um . Rst , nulo , T . Rst ); um . lst = t . reutilizar ( 2 , t . e1 , nulo , t . lst , nulo , uma . lst ); retornar um ; } Privado Nó Balance3Ri ( Node T ) { Node A = T . Rst ; Se (! Ativo ( A )) Retorno T ; Nó L = New Node (); L . Reutilizar ( 2 , T . E1 , Null , T . Lst , Null , T . mst ); Retorno T . Reuse(- 2 , t . E2 , nulo , l , nulo , um . Um desactivar ()); } / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// // delete (excluir) /////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / /////// // delete o nó da chave da raiz da árvore public void delete ( tecla K ) { root = delete ( raiz , chave ); trim (); } // excluir a chave chave nó da árvore t privado Nó apagar ( Node t , K key ) { um if ( t == nulo ) de retorno nulo ; int CMP1 = chave . CompareTo ( t . E1 . Key ), cmp2 ; : Interruptor ( t . nways ) { caso 2 : if ( cmp1 < 0 ) { t. Lst = excluir ( t . Lst , chave ); retornar Balance2Ld ( t ); } else um if ( CMP1 == 0 ) { um if ( t . Lst == nulo ) retorno t . Reuse (- 1 , nulo ); // remoção da camada inferior t . lst = DeleteMax ( t . lst ); // suprimido internamente t. E1 = aux ; retornar Balance2Ld ( t ); } else / * CMP1> 0 * / { t . Rst = excluir ( t . Rst , chave ); retornar Balance2Rd ( t ); } Caso 3 : cmp2 = chave . CompareTo ( T . E2 . Key ); Se ( CMP1 < 0 ) { T. Lst = excluir ( t . Lst , chave ); retornar Balance3Ld ( t ); } else um if ( CMP1 == 0 ) { um if ( t . Lst == nulo ) retorno t . Reutilizar ( 2 , t . E2 ); / / camada inferior de exclusão t . lst = DeleteMax ( t . lst ); // eliminada internamente t . E1 = aux ; retornar Balance3Ld ( t ); } else um if ( cmp2 < 0 ) { t . Mst = excluir ( t . Mst , chave ); retornar Balance3Md ( t ); } else um if ( cmp2 == 0 ) { if ( t . mst == null ) retornar t . reutilizar ( 2 , t . e1 ); // deleção na camada inferior t . MST = DeleteMax ( t . mst ); // suprimido internamente t . e2 = AUX ; retornar Balance3Md ( t ); } else / * cmp2> 0 * / { t . rst = excluir ( t . primeiro , chave ); retornar Balance3Rd ( t); } Padrão : Buggy ( "excluir" ); } return nula ; } // exclui o nó do máximo valor chave da árvore t // retorna madeira valor modificado, eliminando retorna o valor máximo e o valor da chave // Árvore t do aux privada Nó DeleteMax ( Node t ) { um if ( T . Rst =! Null ) { T . Rst = DeleteMax ( T . Rst ); interruptor ( T . Nways ) { Caso 2 : Retorno Balance2Rd ( T ); Caso 3 : Retorno Balance3Rd( T ); padrão : Buggy ( "DeleteMax" ); } } else { : Interruptor ( t . Nways ) { Caso 2 : aux = t . E1 ; retorno t . Reutilizar (- 1 , nulo ); Caso 3 : aux = t . E2 ; Retorno T . Reuse ( 2 , T .e1 ); padrão : Buggy ( "DeleteMax" ); } } retorno nulo ; } / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// // de equilíbrio no momento do padrão de ajuste eliminação //////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ////////// Privado Nó Balance2Ld ( Node T ) { Node A = T . Lst ; Se (! Ativo ( A )) Retorno T ; Nó R = T . Rst ; interruptor ( R . Nways ) { Caso 2 : A . Mst = T . Reuse ( 3 , t . E1 , r. E1 , uma . Mst , r . Lst , r . Rst ); retornar um ; Caso 3 : Par de e = r . E1 ; um . Reutilizar ( 2 , t . E1 , nulo , uma . Mst , nulo , r . Lst ); R . Reutilização ( 2 , R .e2 , nula , r . mst , nula , r . primeiro ); retorno t . reutilizar ( 2 , e , nula , um , nulo , r ); padrão : Buggy ( "Balance2Ld" ); } return nula ; } Privado Nó Balance2Rd ( Node T ) { Node A = T . Rst ; Se (! Ativo ( A )) Retorno T ; Nó L = T . Lst ; interruptor ( L . Nways ) { Caso 2 : A . Mst = T . Reuse ( 3 , l . E1 , t. E1 , l . Lst , l . Rst , um . Mst ); retornar um ; Caso 3 : Par de e = l . E2 ; um . Reutilizar ( 2 , t . E1 , nulo , l . Rst , nulo , uma . Mst ); l . reutilizar ( 2 , l .e1 , nula , l . lst , nula , l . mst ); retorno t . reutilizar ( 2 , e , nula , l , nula , a ); padrão : Buggy ( "Balance2Rd" ); } return nula ; } private Node Balance3Ld ( Node t ) { Node a = t . lst ; um se (! ativo ( a )) retorno t ; Nó m = t . mst ; : Interruptor ( m . Nways ) { Caso 2 : a . reutilizar ( 3 , t . E1 , M . E1 , Uma .MST , m . lst , m . rst ); retorno T . reutilizar ( 2 , t . e2 , nulo , um , nulo , t . rst ); Caso 3 : Par de e = m . e1 ; um . reutilizar ( 2 , t . E1 , Null , A . mst , Null, H . Lst ); m . Reutilizar ( 2 , m . E2 , nulo , m . Mst , nulo , m . Rst ); retorno T . Reutilizar ( 3 , e , t . E2 , um , m , t . Rst ) ; padrão : Buggy ( "Balance3Ld" ); } return nula; } Privado Nó Balance3Md ( Node T ) { Node A = T . Mst ; Se (! Ativo ( A )) Retorno T ; Nó R = T . Rst ; interruptor ( R . Nways ) { Caso 2 : A . Reutilizar ( 3 , T . E2 , R . E1 , A .MST , r . lst , r . rst ); retorno T . reutilizar ( 2 , t . e1 , nulo , t . lst , nulo , um ); Caso 3 : Par de e = r . e1 ; um . reutilizar ( 2 , t . E2 , Null , A . mst , Null, R . Lst ); r . Reutilizar ( 2 , r . E2 , nulo , r . Mst , nulo , r . Rst ); retorno T . Reutilizar ( 3 , t . E1 , e , t . Lst , um , r ) ; padrão : Buggy ( "Balance3Md" ); } return nula; } private Node Balance3Rd ( Node t ) { Node a = t . primeiro ; uma se (! ativo ( a )) retorno t ; Nó m = t . mst ; : Interruptor ( m . Nways ) { Caso 2 : a . reutilizar ( 3 , m . E1 , T . E2 , M .lst , m . primeiro , um . mst ); retorno T . reutilizar ( 2 , t . e1 , nulo , t . lst , nulo , um ); Caso 3 : Par de e = m . e2 ; um . reutilizar ( 2 , t . E2 , Null , M . Rst , Null, Um . Mst ); m . Reutilizar ( 2 , m . E1 , nulo , m . Lst , nulo , m . Mst ); retorno T . Reutilizar ( 3 , t . E1 , e , t . Lst , m , um ) ; padrão : Buggy ( "Balance3Rd" ); } return nula; } / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// // pesquisa, etc. ///////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///// // Pesquisa por chave. Se o sucesso verdadeiro, falso necessidade de Public booleana Membro ( K Key ) { Nó T = Raiz ; Enquanto ( T =! Null ) { Int CMP1 = Key . CompareTo ( T . E1 . Key ), Cmp2 ; interruptor ( T . nways ) { caso 2 : if ( cmp1 < 0 ) t = T . Lst ; Else Se ( CMP1 == 0 ) Retorno verdadeira ; Else / * CMP1> 0 * / T = T . Rst ; Quebre ; Caso 3 : Cmp2 = Key . CompareTo ( T . E2 . Key ); Se ( CMP1 < 0 ) t = t . Lst ; else if ( cmp1 == 0 ) Retorno verdadeira ; Else Se ( Cmp2 < 0 ) T = T . Mst ; Else Se ( Cmp2 == 0 ) Retorno verdadeira ; Else / * Cmp2> 0 * / T = T . Rst ; Pausa ; padrão : Buggy ( " membro " ); } } Voltar Falso ; } // obtém o valor da chave Se a chave não é para bater retornar um nulo Pública V Lookup ( K Key ) { Nó T = Raiz ; Enquanto ( T =! Null ) { Int CMP1 = Key . CompareTo ( T . E1 . Key ), Cmp2 ; interruptor ( T . nways ) { caso 2 : if ( cmp1 < 0 ) t = T . Lst ; Else Se ( CMP1 == 0 ) Retorno T . E1 . Valor ; Else / * CMP1> 0 * / T = T . Rst ; Quebre ; Caso 3 : Cmp2 = Key . CompareTo ( T . E2 . Key ) ; Se ( CMP1 < 0 ) T = T . Lst ; Else Se ( CMP1 == 0 ) Retorno T . E1 . Valor ; Else Se ( Cmp2 < 0 ) T = T . Mst ; Else Se ( Cmp2 == 0 ) Retorno T . E2 . Valor ; Else / * Cmp2> 0 * / T = T . Rst ; Pausa ; padrão : Buggy ( "Lookup"); } } Retorno nulo ; } // Se o mapa está vazio verdade, se não está vazio falso pública boolean isEmpty () { return raiz == nulo ; } // Esvazie o mapa public void clear () { root = null ; } // lista de chaves públicas ArrayList < K > keys () { ArrayList < K > al = new new ArrayList < K > (); chaves ( raiz , al ); retornar al ; } // lista de valores pública ArrayList < V > valores () { ArrayList < V > al = new new ArrayList < V > (); valores ( raiz , al ); retornar al ; } // Tamanho do mapa public int size () { return keys (). Tamanho (); } // valor mínimo da chave pública K min () { Nó t = raiz ; um caso ( t == nulo ) de retorno nulo ; o tempo ( t . Lst =! Null ) t = t . Lst ; retorno t . E1 . Key ; } // valor máximo de chave pública K Max () { Nó T = Raiz ; Se ( T == nulo ) Retorno nulo ; Enquanto ( T . Rst =! Null ) T = T . Rst ; Retorno T . Nways == 2 ? T . E1 . Key : T . E2 . Key ; } Privadas Vácuo Chaves ( Node T , ArrayList < K > Al ) { Se ( T =! Null ) { interruptor ( T . Nways ) { Caso 2 : Chaves ( T . Lst , Al ); Al . Adicionar ( T . E1 . Key ); Chaves ( t . Rst , Al ); Quebre ; Caso 3 : Chaves ( T . Lst , Al ); Al . Adicionar ( T . E1 . Key ;) Chaves ( T . Mst , Al ;) Al . Adicionar ( T . E2 . Key ); Chaves ( T . Rst , al ); break ; padrão : buggy ( "chaves" ); } } }} Privadas Vácuo Valores ( Node T , ArrayList < V > Al ) { Se ( T =! Null ) { interruptor ( T . Nways ) { Caso 2 : Valores ( T . Lst , Al ); Al . Adicionar ( T . E1 . Valor ); Valores ( t . Rst , Al); Pausa ; Caso 3 : Valores ( T . Lst , Al ); Al . Adicionar ( T . E1 . Valor ); Valores ( T . Mst , Al ); Al . Adicionar ( T . E2 . Valor ); Valores ( T . Rst , Al ); Pausa ; padrão : Buggy ("valores" ); } } } / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// // Debug para a rotina //////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ////// // converte a árvore 2-3 representar graficamente corda pública de Cordas toString () { retornar TOGRAFIA ( "" , "" , raiz ). ReplaceAll ( "\\ s + $" , "" ); } // Verifique se a árvore 2-3 está equilibrada public boolean balanced () { return balanceado ( root ); } // checar se é provavelmente uma árvore de busca booleana pública mstValid () { return mstValid ( root ); } privada estática final de Cordas nl = Sistema . getProperty ( "line.separator" ); privada Cordas TOGRAFIA ( Cordas cabeça , Cordas bar , Nó t ) { um if ( t == nulo ) return "" ; Cordas gráfico ` = "" ; : Interruptor ( t . nways ) { caso 2 : gráfico + = TOGRAFIA ( Chefe Tasu "" , "/" , T . Rst ); Graph Tasu = Chefe Tasu Bar Tasu T . E1 . Key Tasu Nl ; Graph Tasu = TOGRAFIA ( Chefe Tasu "" , "\" , T . Lst ); quebre ; Caso 3 : Cordas Hb = Chefe Tasu Bar ; Cordas Hs = cabeça + "" ; Cordas k1 , k2 , um caso ( bar . equals ( "/" )) { k1 = hb + t . e1 . chave ; K2 = hs + t . e2 . chave ; } else um if ( bar . equals ( "over" )) { K1 = Hs Tasu T . E1 .chave ; K2 = hb + t . e2 . chave ; } else um if ( bar . equals ( "\" )) { k1 = hs + t . e1 . chave ; K2 = hb + t . e2 . chave ; } else { k1 = "" + t . e1 . key ; k2 = "" + T . E2 . Chave ; } `gráfico + = TOGRAFIA ( cabeça + "" , "/" , t . Rst ); ` gráfico + = K2 + nl ; `gráfico + = TOGRAFIA ( cabeça + "" , "por cima" , T . mst ); Gráfico Tasu = K1 Tasu Nl ; Gráfico Tasu = TOGRAFIA ( Cabeça Tasu "" , "\" , T . Lst ); Pausa ; padrão : Buggy ( "Print" ); } Retorno Graph ; } private boolean equilibrado ( Node t ) { um if ( t == nulo ) retornar verdadeiro ; boolean flag ; : Interruptor ( t . Nways ) { Caso 2 : flag = altura ( t . lst ) == altura ( t . primeiro ); retorno flag && equilibrado ( t . lst ) && equilibrada ( t . Rst ); Caso 3 : int hl = altura ( t . Lst ); int hm = altura ( t . Mst ); int h = altura ( t . Rst ); bandeira = hl == hm && hm = = Hr ; Bandeira = Bandeira Andoando equilibrada ( t . Lst); Flag = bandeira && equilibrada ( t . Mst ); flag = Bandeira && equilibrada ( t . Rst ); retorno bandeira ; padrão : Buggy ( "equilibrada" ); } retornar falso ; } // Retorna a altura da árvore private int altura ( Node t ) { um if ( t == nulo ) return 0 ; int sh = Math . Max ( altura ( t . Lst ), altura ( t . Rst )); um caso ( T . Nways == 2 ) Retorno 1 Tasu Sh ; Retorno 1 Tasu Math .max ( sh , altura ( t . mst )); } private boolean MstValid ( Node t ) { um if ( t == nulo ) retornar verdadeiro ; boolean flag ; : Interruptor ( t . Nways ) { Caso 2 : flag = pequeno ( t . e1 . chave , t . lst ) && grande ( t . E1 . Key , T .rst ); bandeira = bandeira && MstValid ( t . lst ) && MstValid ( t . rst ); retorno bandeira ; Caso 3 : bandeira = pequeno ( t . e1 . chave , t . lst ); bandeira = bandeira && Entre ( t . E1 . Key , T . E2 . Key, T . Mst ); bandeira = bandeira && grande ( t . E2 . Chave , t . Rst ); bandeira = bandeira && MstValid ( t . Lst ); bandeira = bandeira && MstValid ( t . Mst ); bandeira = bandeira && MstValid ( T . Rst ); Retorno Bandeira ; padrão: Buggy ( "MstValid" ); } Voltar Falso ; } private boolean pequeno ( K -chave , Nó t ) { um if ( t == nulo ) retornar verdadeiro ; boolean flag = chave . compareTo ( t . e1 . key ) > 0 ; : Interruptor ( t . Nways ) { Caso 2 : flag = Bandeira && pequeno ( chave , t. Lst ) && pequena ( de chave , t . Rst ); retorno bandeira ; Caso 3 : flag = Bandeira && chave . CompareTo ( t . E2 . Key ) > 0 ; flag = Bandeira && pequena ( de chave , t . Lst ); flag = flag && small ( chave , t. Mst ); flag = Bandeira && pequena ( de chave , t . Rst ); retorno bandeira ; padrão : Buggy ( "pequeno" ); } retornar falso ; } private boolean Entre ( K key1 , K key2 , Nó t ) { um if ( t == nulo ) retornar verdadeiro ; boolean flag = key1 . compareTo ( t . e1 . key ) < 0 ; flag = Bandeira && key2 . compareTo ( t . e1 . chave ) > 0; : Interruptor ( t . Nways ) { Caso 2 : bandeira = bandeira && Entre ( Key1 , Key2 , t . Lst ); bandeira = bandeira && Entre ( Key1 , Key2 , t . Rst ); retorno bandeira ; Caso 3 : bandeira = bandeira && key1 . compareTo ( t .E2 . Key ) < 0 ; bandeira = Flag Andoando Key2 . CompareTo ( T . E2 . Key ) > 0 ; bandeira = Flag Andoando Entre ( Key1 , Key2 , T . Lst ); bandeira = Flag Andoando Entre ( Key1 , Key2 , T . mst ); Bandeira = Bandeira Andoando Entre ( key1 , key2 , t . Primeiro ); retorno bandeira ; padrão : Buggy ( "entre" ); } retornar falso ; } private boolean grande ( K -chave , Nó t ) { um if ( t == nulo ) retornar verdadeiro ; boolean flag = chave . compareTo ( t . e1 . key ) < 0 ; : Interruptor ( t . Nways ) { Caso 2 : flag = Bandeira && grande ( chave , t. Lst ) && grande ( chave , t . Rst ); retorno bandeira ; Caso 3 : flag = Bandeira && chave . CompareTo ( t . E2 . Key ) < 0 ; flag = Bandeira && grande ( chave , t . Lst ); flag = flag && large ( chave , t. Mst ); flag = Bandeira && grande ( chave , t . Rst ); retorno bandeira ; padrão : Buggy ( "grande" ); } retornar falso ; } buggy void estático privado ( local String ) { System . err . println ( lugar + ": Este programa é buggy" ); System . exit ( 1 ); } / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///////////////////////// // rotina principal ///////////////////// / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / / ///// public static void main ( String [] args ) { final int n = 30 ; T23Mapa < Integer , Integer > m = novo T23Map <> (); ArrayList < Integer > keys = novo ArrayList <> (); para ( int i = 0 ; i < n ; i ++) chaves . Adicionar ( i); Java . Util . Coleções . Aleatórias ( Chaves ); Para ( Int I = 0 ; I < N ; I Tasutasu) M . Inserir ( Chaves . Get ( I ), I ); Sistema . Fora . Println ( M ) ; Sistema . Fora . println (); Sistema . Fora . println( "Tamanho:" Tasu M . Tamanho ()); Sistema . Fora . Println ( "Chaves:" Tasu M . Teclas ()); definitiva int N = 1000000 ; java . util . aleatório RNG = novo novo java . util . Aleatório (); m . claro (); java . util . TreeMap < Integer , Integer > resposta = novo novo java . util . TreeMap <> () ; Int InsertErrors = 0 ; Int DeleteErrors = 0; Para ( int i = 0 ; i < N ; i ++) { int chave = rng . NextInt ( N ); m . Inserção ( chave , i ); resposta . O posto ( chave , i ); } para ( int tecla : resposta . keySet ()) { int x = m . pesquisa( Key ); Int Y = Resposta . Get ( Key ); Se ( X =! Y ) InsertErrors Tasutasu; } Int Meio = Resposta . Tamanho () / 2 ; Para ( Int Key : Resposta . KeySet ()) { Se ( metade - == 0 ) quebrar ; m . excluir ( chave ); } Metade = resposta . Tamanho () / 2 ; para ( int chave : resposta . KeySet ()) { um if ( meia - == 0 ) quebrar ; um caso ( m . Membro ( chave )) DeleteErrors ++; } Sistema . out . println (); System . out . println ( "saldo:" + (M . Equilibrado () ? "OK" : "NG" )); Sistema . Fora . Println ( "Talvez procurar árvore:" Tasu ( M . MstValid () ? "OK" : "NG" )); Sistema . Fora . println ( "insert:" + ( insertErrors == 0 ? "OK" : "NG" )); Sistema . out . println ( "delete:" + ( deleteErrors == 0 ? "OK" : "NG" )); para ( tecla int : m . keys ()) m . delete ( tecla ); System . out . println ( "Apagar tudo:" + ( m . isEmpty () ? "OK" : "NG" )); } } adicionado 15 minutos depois http://wwwa.pikara.ne.jp/okojisan/t23-java/index.html

estou a uma vida tentando achar livros e assuntos sobre arvores, em especial a 2-3, e nao acho nada....

@Flávio Pedroza do tipo int Mas eu tentei so como o "*" antes mas nao deu certo adicionado 1 minuto depois A nao, acabei de notar aqui que ele não é ponteiro, mas sim uma estrutura tambem adicionado 8 minutos depois Ai se eu fizer *no = paux, funciona. SO que eu nao sei o que estou atribuindo, se é tudo. Acredito que sim. É isso? @Flávio Pedroza voce sabe sobre arvores 2-3?

Olá, mundo. Estava aqui pensando num problema que tenho a resolver, pois bem se trata de cast Estava aparecendo que eu nao podia realizar a operacao de atribuicao pois de um lado tinha inteiro e do outro um ponteiro. Logo, eu astuto pensei. Vou fazer um cast aqui, e fiz. ficou assim (*no)->key = (int) paux; sendo o no uma estrutura, o key o inteiro dessa estrutura e o paux um ponteiro. Esta errado isso? Pode dar problema?

Oi, beleza? Não to conseguindo fazer com que o metodo main "converse" com o funcao insere. Poderiam me ajudar a ver o que esta acontecendo? Segue o código No *insere( No **no, int val, int *rval){ No *paux, *paux2; int vaux, promov; if (*no == NULL) { // arvore vazia *no = (No *) malloc (sizeof(No)); *no = criaNo(val, 0, 0, NULL, NULL, NULL); // cria no folha com um valor return NULL; // nada a fazer depois } if (isLeaf(*no)){ // chegou a folha if ((*no)->nkey == 1){ // caso fácil adicionaChave(*no, val, NULL); return NULL; } else { paux = quebraNo(*no, val, &vaux, NULL); *rval = vaux; return paux; } } else { // continua a procura if (val < (*no)->key1) paux = insere( &((*no)->left), val, &vaux); else if (((*no)->nkey == 1) || (val < (*no)->key2)) paux = insere( &((*no)->middle), val, &vaux); else paux = insere( &((*no)->right), val, &vaux); if (paux == NULL) // nao promoveu return NULL; else if ((*no)->nkey == 1){ adicionaChave(*no, vaux, paux); return NULL; } else { paux2 = quebraNo(*no, vaux, &promov, paux); *rval = promov; return paux2; } } } int main(){/* No **aux; aux = (No**)malloc(sizeof(No*)); aux = insere(aux, 5, );*/ int valor = 5, *val; No *a1; a1= insere(&a1,valor, val); /* sub-árvore 'b' */ // No* a2= insere(a1,valor,a1->key2); /* sub-árvore 'e' */ imprimir(a1); } Se acharem necessário ver o codigo todo, eu envio. Okay. Obrigado desde já adicionado 0 minutos depois Acho que o fato de ser ponteiro para ponteiro esta me deixando confuso adicionado 12 minutos depois nao sei passar um struct ponteiro de ponteiro......

Ja mudei de novo