示例#1
0
void* removerComThread(void* ptr){
    char* message;
    message = (char*) ptr;
    pthread_mutex_lock(&count_mutex);

    printf("%s removendo da fila\n", message);
    remover(l, &reg);

    pthread_mutex_unlock(&count_mutex);
}
/**
* @brief Removes functions that are not reachable from the main function.
*
* @param[in,out] module Module in which the functions will be removed.
* @param[in] mainFuncName Name of the main function.
*
* @return Functions that were removed.
*
* If there is no function named @a mainFuncName, this function does nothing.
* Functions that are only declared (i.e. not defined) are never removed.
*
* @par Preconditions
*  - @a module is non-null
*  - @a mainFuncName is not empty
*/
FuncVector UnreachableFuncsRemover::removeFuncs(ShPtr<Module> module,
		const std::string &mainFuncName) {
	PRECONDITION_NON_NULL(module);
	PRECONDITION(!mainFuncName.empty(), "the name cannot be empty");

	ShPtr<UnreachableFuncsRemover> remover(new UnreachableFuncsRemover(
		module, mainFuncName));
	remover->performRemoval();
	return remover->removedFuncs;
}
示例#3
0
void main(){
  
  char source[]= "The quick brown fox jumps over the lazy dog";
  char substring[] = "brown fox jumps over the";
  char result[strlen(source)];
  remover(source, substring, result); 
  
  
  
}
示例#4
0
VectorI MeshCleaner::remove_short_edges(
        MatrixFr& vertices, MatrixIr& faces, Float tol) {
    ShortEdgeRemoval remover(vertices, faces);
    remover.run(tol);

    vertices = remover.get_vertices();
    faces = remover.get_faces();

    return remover.get_face_indices();
}
/*********************************MAIN************************************/
int main(int argc, char **argv) {
    criarArvore(&arvore);/*passa o endereco pra que a funcao crie*/
    FILE *arquivo, *arquivoremove, *arquivoentrada, *desenho_arvore, *fim;
    DIR *dir;
    struct dirent *lsdir;
    dir= opendir(argv[1]);/*Url passada dos arquivos dos alunos.dat*/
    char caminho[300], caminhosaida[300], caminhoremove[300];
    /* Primeiro parâmetro: o de leitura */

    /***********************CARREGANDO ARQUIVOS DA PASTA****************************************/
    while ( ( lsdir = readdir(dir) ) != NULL )//atraves do readdir o lsdir tem struct com nomes como parametros..
    {
        if (strcmp(lsdir->d_name, ".") != 0 && strcmp(lsdir->d_name, "..")) { /*O lsdir traz pontos indesejaveis, entao para que nao use-o - uma condicao*/
            /*De um por um, com o lsdir->d_name*/
            strcpy(caminho,argv[1]);//salvando em uma variavel
            strcat(caminho, "/");
            strcat(caminho,lsdir->d_name);/*Concatenando*/
            //printf("%s\n",caminho);
            arquivo = fopen(caminho, "r");
            carregaArquivo(&arvore, arquivo);
        }
    }

    closedir(dir);
    /**************IMPRESSAO EM DESENHO INICIAL.RES*****************/
    strcpy(caminhosaida, argv[3]);
    strcat(caminhosaida,"/carga-inicial.res");
    desenho_arvore = fopen(caminhosaida, "w");
    mostrar(arvore.topo, 0, desenho_arvore);
    fclose(desenho_arvore);
    /*********************REMOVER**********************/
    strcpy(caminhoremove, argv[3]);//terceiro argumento..saída
    strcat(caminhoremove, "/");
    strcat(caminhoremove, "excluir.res");
    arquivoremove = fopen(caminhoremove, "w");
    /**********concatenando strings para a entrada ************/
    strcpy(caminho, argv[2]);
    strcat(caminho, "/");
    strcat(caminho, "excluir.in");
    arquivo = fopen(caminho, "r");
    remover(arvore, arquivo, arquivoremove);//removendo todos do excluir.in o argv2 é o parametro de remocao
    /*****************DESENHO APOS EXCLUSAO.RES (matriculas impressa em formato de arvore********************/
    strcpy(caminhosaida, argv[3]);
    strcat(caminhosaida, "/apos-exclusao.res");
    desenho_arvore = fopen(caminhosaida, "w");
    mostrar(arvore.topo, 0, desenho_arvore);
    fclose(desenho_arvore);
    /**************IMPRESSAO APOS EXCLUSAO***********/
    strcpy(caminhosaida, argv[3]);
    strcat(caminhosaida,"/final.res");
    fim = fopen(caminhosaida,"w");
    salvar(arvore.topo, fim);
    /**************************************************/
    return 0;
}
示例#6
0
int main(){
	Aeroporto l;
	//char letra;
	//int letra_num=0; // recebe um numero decimal e transforma em letra atraves da tabela ascII
	//int indiceRemover; // recebe o indice que será removido
	//int numPassageiro;
	
	double timingDanilo = omp_get_wtime(); // precisa do paramentro -fopenmp na compilacao
	inicializarAeroporto(&l);
	insere ('c', 3, &l);
	insere ('b', 4, &l);
	insere ('z', 5, &l);
	insere ('a', 6, &l);
	insere ('a', 7, &l);
	insere ('a', 8, &l); //6
	//ordenacao  (&l);
	imprime (&l);
	printf("Contador capacidade: %d \n", capacidade);
	buscarAviao(5,&l);
	remover (1, &l);
	imprime (&l);
	printf("Contador capacidade: %d \n", capacidade);
	ordenacao  (&l);
	imprime (&l);
	
	timingDanilo = omp_get_wtime() - timingDanilo;
	printf ("%f\n",timingDanilo);
		
/*while(true){ 
		if(l.prox!=NULL){
		printf("AQUI 2");
		indiceRemover=rand()%+1;
		remover(indiceRemover,&l);
		}
		printf("AQUI 3");
		imprime(&l);
		letra_num=rand()%36+65;
		letra=funcaoASCII(letra_num);
		numPassageiro=rand()%800;
		insere(letra,numPassageiro,&l);
		ordenacao(&l);
		sleep(5);
		//remove();
		//insere();
		//ordena();
		sleep(5);
		//remove();
		//insere();
		//insere();
		//insere();
		//insere();
		//ordena();		
	}*/
return 0;
}
示例#7
0
文件: ParserLL.c 项目: smlle/COMP
void parser(char *expr)
{
	struct Pilha pilha;
	int x, a, nProd, i, *producao;
	int pos = 0;

	inicializa(&pilha);
	insere(&pilha, FIM);
	insere(&pilha, EXPR);
	if ((a = lex(expr, &pos)) == ERRO)
		erro("Erro lexico", expr, pos);
	do
	{
        x = consulta(&pilha);
		if (!(x&NTER))
		{
			if (x == a)
			{
				remover (&pilha);
				if ((a = lex(expr, &pos)) == ERRO)
					erro("Erro lexico", expr, pos);
			}
			else{
				erro("Erro sintatico2",expr, pos);
            }
		}
		if (x&NTER)
		{
            nProd = STAB[(x&NNTER)-1][(a>>8)-3];
			if (nProd)
			{
				remover (&pilha);
				producao = PROD[nProd];
				for (i = producao[0]; i > 0; i--){
					insere (&pilha, producao[i]);
                }
            }
			else
				erro ("Erro sintatico1", expr, pos);
		}
	} while (x != FIM);
}
示例#8
0
void remover(TArvoreA **pRaiz, int valor){
    if(*pRaiz == NULL){   // esta verificacao serve para caso o numero nao exista na arvore.
       printf("Numero nao existe na arvore!");
       return;
    }
    if(valor < (*pRaiz)->valor)
       remover(&(*pRaiz)->esq, valor);
    else
       if(valor > (*pRaiz)->valor)
          remover(&(*pRaiz)->dir, valor);
       else{    // se nao eh menor nem maior, logo, eh o numero que estou procurando! :)
          TArvoreA *pAux = *pRaiz;
          if (((*pRaiz)->esq == NULL) && ((*pRaiz)->dir == NULL)){         // se nao houver filhos...
                free(pAux);
                (*pRaiz) = NULL;
               }
          else{     // so tem o filho da direita
             if ((*pRaiz)->esq == NULL){
                (*pRaiz) = (*pRaiz)->dir;
                pAux->dir = NULL;
                free(pAux); pAux = NULL;
                }
             else{            //so tem filho da esquerda
                if ((*pRaiz)->dir == NULL){
                    (*pRaiz) = (*pRaiz)->esq;
                    pAux->esq = NULL;
                    free(pAux);
                    pAux = NULL;
                    }
                else{       //Escolhi fazer o maior filho direito do filho esq
                   pAux = MaiorDireita(&(*pRaiz)->esq);
                   pAux->esq = (*pRaiz)->esq;
                   pAux->dir = (*pRaiz)->dir;
                   (*pRaiz)->esq = (*pRaiz)->dir = NULL;
                   free((*pRaiz));
                    *pRaiz = pAux;
                    pAux = NULL;
                   }
                }
             }
          }
}
int interface_stdin( void ) {
	no *T = malloc(sizeof(no));
	if ( T ) inicializada(T) = 0;
	
	char 	c; 		/* comando dentre {i, r, b} */
	int 	v, 		/* parametro da {insercao, remocao, busca} */
		i=0, j=0; 	/* controle do buffer, para nao repetir strings 
			   	 * i: indica numero de comandos {i, r, b} chamados,
			   	 * j: indica o numero de impressoes.
			   	 * Portanto, sempre deve valer i=j. */
	
	do {
		scanf("%c", &c);
		switch (c) {
			case 'i':
				scanf("%d", &v);
				T = inserir(T, v);
				i++; 	/* um comando executado implica i <- i + 1,
					 * comentarios posteriormente suprimidos. */
			break;
			case 'r':
				scanf("%d", &v);
				T = balancia(remover(T, v));
				i++;
			break;
			case 'b':
				scanf("%d", &v);
				i++;
			break;
		}

		if ( c == 'i' || c == 'r' || c == 'b' )
			printf("%c %d\n", c, v);

		/* j eh o numero de iteracoes, que deve ser concordante com i, 
		 * senao, j sera decrementado posteriormente e nada sera impresso. */
		j++;

		/* previne impressoes duplicadas. */
		if ( i != j ) 
			j--;
		/* Se o comando for {insercao, remocao}, imprime a arvore */
		else if ( c != 'b' ) {
			escreve(T, PRE_ORDER);
			printf("\n");
		/* Se o comando for de busca, imprime os no's percorridos. */
		} else 
			imprime_lista(busca(T, calloc(AVL_ALTURA_MAX, sizeof(int)), v));
	} while ( c != 'q' && !feof(stdin) );

	finaliza(T); /* Destroi T. */

	return EXIT_SUCCESS;
}
示例#10
0
int liberarLista(ListaEnc* lista) {
    if (lista == NULL)
        return ESTRUTURA_NAO_INICIALIZADA;

    // remove todos os elementos da lista
    while(!estahVazia(lista))
        remover(lista, NULL, 0);
    free(lista);
    lista = NULL;
    return OK;
}
void Binary_search_tree::remove_helper(int x, BST_node* t, BST_node* p) {
	if (t != nullptr){
		if (x > t->get_data()) {
			remove_helper(x, t->get_right_child(), t);
		} else if (x < t->get_data()) {
			remove_helper(x, t->get_left_child(), t);
		} else {
			remover(t, p);
		}
	}
}
示例#12
0
 void removeElement(const Key& k)			// remove using key
     throw(NonexistentElementException) {
   BTPosition u = finder(k, BST::T.root());			// find the node
   if (u.isNull())					// not found?
     throw NonexistentElementException("Remove nonexistent element");
   BTPosition r = remover(u);				// remove u
   if (BST::T.isRoot(r) || isRed(r) || wasParentRed(r))
     setBlack(r);					// fix by color change
   else 						// r, parent both black
     remedyDoubleBlack(r);				// fix double-black r
 }
示例#13
0
arvore *remover(arvore *aux,int numero){

	arvore *p,*p2;

	if(aux->info==numero){
		if(aux->esq==aux->dir){//sem filhos
			delete aux;
			return NULL;
		}
		else if(aux->esq==NULL){//tem filho a direita
			p=aux->dir;
			delete aux;
			return p;
		}
		else if(aux->dir==NULL){//tem filho a esquerda
			p=aux->esq;
			delete aux;
			return p;
		}
		else{//filhos em ambos lados
			p2=aux->dir;
			p=aux->dir;
			while(p->esq!=NULL){
				p=p->esq;
			}
			p->esq=aux->esq;
			//passa a subarvore a esquerda de aux para
			//o ultimo nó a esquerda da sub arvore
			//a direita de aux(que virará raiz)

			delete aux;
			return p2;
		}
	}
	else if(numero>aux->info)
		aux->dir=remover(aux->dir,numero);
	else
		aux->esq=remover(aux->esq,numero);

	return aux;
}//metodo de remover numero
inline void remover(int i)
{
    amigos[i] = 0;
    for (int j = 1; j <= pessoas; j++)
        if (g[i][j])
        {
            g[i][j] = g[j][i] = 0;
            amigos[j]--;
            if (amigos[j] > 0 && amigos[j] < min_amigos)
                remover(j);
        }
}
示例#15
0
// remoção da árvore
struct NO *remover(struct NO *raiz, int info, bool h) {
    if (raiz == NULL) {
        printf("Chave nao encontrada.");
        h = false;
    }
    else {
        if (raiz->info.chave > info) { //desce pela sub-árvore esquerda
            raiz->fesq = remover(raiz->fesq, info, h);

            if (h) raiz = balanceamento_esq(raiz, h);
        }
        else
            if (raiz->info.chave < info) { //desce pela sub-árvore direita
                raiz->fdir = remover(raiz->fdir, info, h);

                if (h) raiz = balanceamento_dir(raiz,h);
            }
            else { //encontrou o elemento que será removido
                if (raiz->fdir == NULL) {
                    if (raiz->fesq != NULL) //escolhe o nó à esquerda como substituto
                        raiz->fesq->pai = raiz->pai;
                        raiz = raiz->fesq;
                        h = true;
                    }
                    else
                    if (raiz->fesq == NULL) {
                        if (raiz->fdir != NULL) //escolhe o nó à direita como substituto
                            raiz->fdir->pai = raiz->pai;
                            raiz = raiz->fdir;
                            h = true;
                        }
                        else { // busca o elemento mais à direita do nó esquerdo
                            raiz->fesq = busca_remove(raiz->fesq, raiz, h);
                            //se necessário efetua balanceamento esquerdo, pois a função busca_remove foi para o nó esquerdo
                            if (h) raiz = balanceamento_esq(raiz, h);
                    }
            }
    }
    return(raiz);
}
示例#16
0
void LSE::set(Info *elemento, int posicao) {
	if (posicao < 0) throw; // Refinar isso para uma excecao decente
	if (qte) {
		if (posicao) {
			int p;
			No *a;

			if (anterior && (posicao >= pos))
				for (p = pos, a = anterior; (p < posicao) && a->proximo; p++, a = a->proximo);
			else
				for (p = 1, a = inicio; (p < posicao) && a->proximo; p++, a = a->proximo);

			if (a->proximo) {
				pos = p;
				anterior = a;
				if(!elemento) remover(posicao);
				else {
					a->proximo->dado = 0;
					a->proximo->dado = elemento;
					return;
//					return a->proximo->dado;
//					return 1;
				}
			}
		} else {
			pos = 0;
			anterior = 0;
			if(!elemento) remover(posicao);
			else {
				inicio->dado = 0;
				inicio->dado = elemento;
				return;
//				return inicio->dado;
//				return 1;
			}
		}
	}
	return;
//	return 0; // Nao ha info para retornar
}
示例#17
0
int main(int argc, char **argv) {
  inserir(3);
  inserir(1);
  inserir(90);
  inserir(6);
  inserir(40);
  inserir(2);
  inserir(4);
  inserir(20);

  /* Testar ordenação da lista */
  int *values = get_list();
  int compare[8] = {1, 2, 3, 4, 6, 20, 40, 90};
  int i = 0;
  for(; i < 8; i++) {
    assert(compare[i] == values[i]);
  }

  /* Testes do metodo buscar */
  assert(tamanho() == 8);

  /* Testes do metodo buscar */
  assert(buscar(200) == 0);
  assert(buscar(20) == 1);

  /* Testes do metodo remover */
  remover(1);
  remover(3);
  remover(20);
  int *values2 = get_list();
  int compare2[5] = {2, 4, 6, 40, 90};
  for(i = 0; i < 5; i++) {
    assert(compare2[i] == values2[i]);
  }

  print_list();

  return EXIT_SUCCESS;
}
示例#18
0
int main(){
    Fila* ini = NULL;
    
    inserir(&ini, 1);
    imprimir(ini);
    inserir(&ini, 2);
    imprimir(ini);
    inserir(&ini, 3);
    imprimir(ini);
    printf("Remove: %d\n", remover(&ini));
    imprimir(ini); 
    printf("Remove: %d\n", remover(&ini));  
    inserir(&ini, 4);
    imprimir(ini); 
    inserir(&ini, 5);
    imprimir(ini);    
    
    printf("\n");
        
system("pause");    
return 0;
}
void remover (no **raiz, int elemento){     //função eu remove o valor desejado
	if(elemento < (*raiz)->chave){          //no caso de estarmos removendo uma função que tem um filho ou nenhum o problema se torna fácil
		remover(&(*raiz)->esq, elemento);
	}else if(elemento > (*raiz)->chave){
		remover(&(*raiz)->dir, elemento);
	}else if((*raiz)->esq!=NULL && (*raiz)->dir!=NULL){
		no *aux = NULL;
		aux = doisfilhos((*raiz)->dir);   //porém para remover um nó com dois filhos o problema se torna mais complicado
		(*raiz)->chave = aux->chave;      //para isso foi criada a função doisfilhos
		remover(&(*raiz)->dir, (*raiz)->chave);
	}
	else{
		no *aux = (*raiz);
		if((*raiz)->esq==NULL){
			(*raiz)=(*raiz)->dir;
		}
		else{
			(*raiz)=(*raiz)->esq;
		}
		free(aux);
	}
}
示例#20
0
 NoBinario<T>* remover(NoBinario<T>* arv, const T& dado) {
     NoBinario<T> *aux, *filho;
     if (arv == NULL) {
         return arv;
     } else {
         if (dado < *arv->getDado()) {
             arv->esquerda = remover(arv->getEsquerda(), dado);
             return arv;
         } else {
             if (dado > *arv->getDado()) {
                 arv->direita = remover(arv->getDireita(), dado);
                 return arv;
             } else {
                 if (arv->getDireita() != NULL &&
                 arv->getEsquerda() != NULL) {
                     aux = minimo(arv->getDireita());
                     arv->dado = aux->getDado();
                     arv->direita = remover(arv->getDireita(),
                     *arv->getDado());
                     return arv;
                 } else {
                     aux = arv;
                     if (arv->getDireita() != NULL) {
                         filho = arv->getDireita();
                         return filho;
                     } else {
                         if (arv->getEsquerda() != NULL) {
                             filho = arv->getEsquerda();
                             return filho;
                         } else {
                         delete arv;
                         return NULL;
                         }
                     }
                 }
             }
         }
     }
 }
示例#21
0
int main(int argc, char *argv[])
{
     while (op!=6){
      printf("\n\n ----------------------- ");
      printf("\n 1 - Incluir ");
      printf("\n 2 - Listar ");
      printf("\n 3 - Alterar ");
      printf("\n 4 - Excluir ");
      printf("\n 5 - Consultar ");
      printf("\n 6 - Sair ");
      printf("\n\n Escolha uma opcao: ");
      scanf("%d",&op);
      system("cls");
switch (op){
        case 1:{ 
     printf("\n Digite o  valor a ser inserido \n " );
     printf("\n");
     scanf("%d",&val);        
     inserir(x,&pos,&fim,val);
      break;
      }
   case 2:{
      imprimir(x,&fim);  
      break;
      }
   case 3:{
      alterar(x,k,&fim);
      printf("\n"); 
      break;
      } 
   case 4:{
        printf("\n Digite a posicao do valor a ser removido\n");
        printf("\n");
        scanf("%d",&pos);
        remover(x,&fim,pos);
     break;
     }     
   case 5:{
       printf ("\n Digite a posição do valor \n");
       scanf("%d",&k); 
       acessar(x,k,&fim);
      break;
      }
   case 6:{ 
      printf("\nSaindo...\n");
      system("\n\npause");   
      break;
      } 
      }
      }  
}
示例#22
0
文件: main.c 项目: gabriellett/FEI
int main(int argc, char *argv[])
{
    struct tLdde *lista = criaLista();
    int escolha, qtde, remChave;
    struct tItem *itRem;
    char resp;
    
    do
    {
        escolha = menu();
        switch(escolha)
        {
            case 1: inserir(lista, criaItem());
                    break;
            case 2: system("cls");
                    printf("Informe o valor da chave a ser removida: ");
                    scanf("%d", &remChave);
                    itRem = remover(lista, remChave);
                    if(itRem != NULL)
                    {
                        printf("\nItem chave [%d] localizado. Deseja realmente exclui-lo. [S]im [N]ao: ", remChave);
                        do
                        {
                            resp = getche();
                        }while(toupper(resp) != 'S' && toupper(resp) != 'N');
                        if(toupper(resp) == 'S')
                        {
                            free(itRem);
                            printf("\nItem chave [%d] removido com sucesso...\n", remChave);
                        }
                        else
                        {
                            inserir(lista, itRem);
                            printf("\nRemocao do item chave [%d] abortada...\n", remChave);
                        }
                        system("pause");
                    }
                    else
                    {
                        printf("O item chave [%d] nao estah na lista...\n", remChave);
                        system("pause");
                    }
                    break;
            case 3: qtde = mostrar(lista->primeiro);
                    printf("\nA lista possui %d itens...\n", qtde);
                    system("pause");
        }
    }while(escolha != 4);
    printf("Saindo...\n");
    system("pause");
}
main() {

	int opcao,valor;
	bool i=true;

	menu();
	do {
		opcao = getche()-'0';

		switch(opcao) {
			case 1:
				system ("cls");
				menu();
				printf("\nDigite o valor a ser inserido ");
				scanf("%d", &valor);
				insere(valor);
				printf("\n\nEscolha outra op\207\706o para continuar...\n\n");
				break;
			case 2:
				system ("cls");
				menu();
				printf("\nDigite o valor a ser removido ");
				scanf("%d", &valor);
				remover(valor);
				printf("\n\nEscolha outra op\207\706o para continuar...\n\n");
				break;
			case 3:
				system ("cls");
				menu();
				printf("\nDigite o valor a ser buscado");
				scanf("%d", &valor);
				buscar(valor);
				printf("\n\nEscolha outra op\207\706o para continuar...\n\n");
				break;
			case 4:
				system ("cls");
				menu();
				exibir();
				printf("\n\nEscolha outra op\207\706o para continuar...\n\n");
				break;
			case 5:
				system ("cls");
				printf("\n\n\t\tAt\202 logo !!\n\n\n\n\n\n\n\n\n\n");
				i=false;
				break;
		}
	}
	while(i==true);

	system ("pause");
}
void deletetop(long long int A[])
{
//	printf("%d\n",A[1]);
	if(count==1)
	{
		A[1]=0;
		count=0;
		return;
	}
	A[1]=A[count];
	A[count]=0;
	count--;
	remover(A,1);
}
示例#25
0
void menu(PPNo tree) {
    int altura_arvore;
    char opcao;

    do {
        system("cls");
        geraLarguras(*tree);  /* lista recebe o ponteiro da lista ligada com as informações necessárias para o desenho */
        desenhaArvore(*tree,5);

        altura_arvore = alturaArvore(*tree);
        gotoxy(1,(altura_arvore+2)*4);
        printf("Escolha uma opcao:\n I - Inserir no\n R - Remover no\n F - Fechar\n");
        opcao = getch();
        switch(opcao) {
        case 'I':
            inserir(tree);
            break;
        case 'i':
            inserir(tree);
            break;
        case 'R':
            remover(tree);
            break;
        case 'r':
            remover(tree);
            break;
        case 'F':
            break;
        case 'f':
            break;
        default:
            printf("Opcao invalida\n");
        }
    } while(opcao != 'f' && opcao != 'F');

}
void remover (int key, tree* t){
    tree* tmp=NULL;
    if(t==NULL){
        return 0;
    }
    if(key < t->id){
        remover(key,t->left);
    }else if(key > t->id){
        remover(key,t->rigth);
    }else{
        if((t->left)&&(t->rigth)){
            tmp = find_min(t->rigth);
            t->id = tmp->id;
            return remove_min(t->rigth);
        }
        tmp=t;
        if(t->left!=NULL){
            t=t->left;
        }else{
            t=t->rigth;
        }
        free(tmp);
    }
}
void menu(no *raiz){
	int j = 1;
	int n, i;
	printf("Agora que voce ja selecionou os elementos da arvore,\nselecione o que deseja fazer: ");
	while(j!=0){
		printf("\n\n1 : Imprime a arvore em ordem\n2 : Imprime a arvore em preordem\n3 : Imprime a arvore em posordem\n");
		printf("4 : Imprime em Labelled Bracketing\n5 : Buscar um numero\n6 : Remover um numero\n7 : Inserir um numero\n");
		printf("8 : Sair\n");
		scanf("%d", &i);
		switch(i){  //para cada número que o usuário entrar o programa realizará um comando diferente
			case 1:
				ordem(raiz);
			break;
			case 2:
				preordem(raiz);
			break;
			case 3:
				posordem(raiz);
			break;
			case 4:
				lbracketing(raiz);
			break;
			case 5:
				printf("\nEscreva o elemento que deseja buscar: ");
				scanf("%d", &n);
				busca(&raiz, n);
			break;
			case 6:
				printf("\nEscreva o elemento que deseja remover, escreva um que esta na arvore! :");	
				scanf("%d", &n);
				remover(&raiz, n);
			break;
			case 7:
				printf("Digite o elemento que deseja inserir, digite um que nao esteja na arvore! :");
				scanf("%d", &n);
				inserir(&raiz, n);
			break;
			case 8:
				j=0;
			break;	
			default	:
				printf("Insira um valor válido!\n");
			break;		
								
		}
	}
	return;
}
示例#28
0
int main() {
    char *palavras[10000];
    int count_palavras, numero, i;

    if((fin = fopen( "in.txt", "w")) == NULL ) {
        printf("nao foi possivel criar o arquivo\n");
        exit(1);
    }

    if((fout = fopen( "out.txt", "w")) == NULL ) {
        printf("nao foi possivel criar o arquivo\n");
        exit(1);
    }

    srand(time(NULL));
    count_palavras = 0;

    for (i = 0; i < TOTAL_PALAVRAS; i++) {
        printf("%d ", i);
        //numero = rand() % 3;
        numero = 0;

        switch(numero) {

        case 0:
            inserir(palavras, &count_palavras);
            break;
        case 1:
            buscar(palavras, count_palavras);
            break;
        case 2:
            remover(palavras, count_palavras);
            break;
        }

        /*		if (count_palavras >= 4000){
        			printf("Superou capacidade do vetor.");
        			exit(1);
        		}*/
    }

    fprintf(fin, "@\n");

    fclose(fout);
    fclose(fin);

    return 0;
}
int main()
{
    while (scanf("%d %d %d", &pessoas, &relacoes, &min_amigos) != EOF)
    {
        if (min_amigos == 0)
        {
            for (int i = 0; i < relacoes; i++)
                scanf("%d %d", &p1, &p2);
            putchar('1');
            for (int i = 2; i <= pessoas; i++)
                printf(" %d", i);
            putchar('\n');
        }
        else
        {
            memset(g, 0, sizeof(g));
            memset(amigos, 0, sizeof(amigos));
            for (int i = 0; i < relacoes; i++)
            {
                scanf("%d %d", &p1, &p2);
                g[p1][p2] = g[p2][p1] = 1;
                amigos[p1]++;
                amigos[p2]++;
            }
            for (int i = 1; i <= pessoas; i++)
                if (amigos[i] > 0 && amigos[i] < min_amigos)
                    remover(i);
            // Imprime todos os que sobraram
            bool imprimiu = false;
            for (int i = 1; i <= pessoas; i++)
                if (amigos[i] > 0)
                {
                    if (!imprimiu)
                    {
                        imprimiu = true;
                        printf("%d", i);
                    }
                    else
                        printf(" %d", i);
                }
            if (imprimiu)
                putchar('\n');
            else
                puts("0");
        }
    }
    return 0;
}
示例#30
0
	NoBinario<T>* remover(NoBinario<T>* arv, const T& dado) {

		if(arv == NULL) {
			return arv;
		} else {
			if(arv->dado > dado) {
				return remover(arv->esquerda, dado);
			} else if(arv->dado < dado){

			} else {

			}
		}


	}