void* removerComThread(void* ptr){
char* message;
message = (char*) ptr;
pthread_mutex_lock(&count_mutex);
printf("%s removendo da fila\n", message);
remover(l, ®);
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;
}
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);
}
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;
}
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;
}
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);
}
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;
}
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);
}
}
}
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
}
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);
}
}
// 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);
}
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
}
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;
}
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);
}
}
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;
}
}
}
}
}
}
}
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;
}
}
}
}
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);
}
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;
}
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;
}
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 {
}
}
}