int main(void){
    char* cpf = (char*)malloc(sizeof(char));
    char* nome = (char*)malloc(sizeof(char));
    int i, qtd;

    Lista* lista;

    lista = criarLista();
    /*
    printf("Quantos registros deseja inserir na lista?\n");
    scanf("%d", &qtd);

    for(i = 0; i < qtd; i++){
        printf("Insira seu CPF: ");
        scanf("%s",cpf);
        printf("Insira seu Nome: ");
        scanf("%s",nome);

        lista = insereOrdNaLstSemRepet(lista, cpf, nome);
    }

    */
    // basta fazer os testes utilizando os métodos, ex. logo abaixo:
    lista = insereOrdNaLstSemRepet(lista, "07348605605", "lol");
    lista = insereOrdNaLstSemRepet(lista, "07348605600", "aaa");
    lista = insereOrdNaLstSemRepet(lista, "07348605600", "bbb");
    lista = insereOrdNaLstSemRepet(lista, "07348605699", "ccc");
    lista = insereOrdNaLstSemRepet(lista, "07048605699", "ddd");
    lista = insereOrdNaLstSemRepet(lista, "07448605699", "eee");


    imprimirLista(lista);

    return 0;
}
예제 #2
0
int main(){
	lista *li;
	li = criaLista();
	int i;
	int quantCarros,quantRemocao;
	int opcao;
	while(1){
		system("cls");
		setlocale(LC_ALL,"Portuguese");
		printf("[1] Adicionar carro\n[2] Excluir carro\n[3] Mostrar carros\n[4] Mostrar tamanho da lista\n[5] Sair\nEscolha a opção: ");
		fflush(stdin);
		scanf("%d",&opcao);
		
		if(opcao == 1){
			printf("Desejas adicionar quantos carros? ");
			fflush(stdin);
			scanf("%d",&quantCarros);
			carros car[quantCarros];
			for(i=0; i<quantCarros; i++){
				fflush(stdin);
				printf("Digite a marca: ");fflush(stdin);
				gets(car[i].marca);
				printf("Digite o ano: ");fflush(stdin);
				scanf("%d",&car[i].ano);
				printf("Digite a cor: ");fflush(stdin);
				gets(car[i].cor);
				printf("Digite o preco: ");fflush(stdin);
				scanf("%f",&car[i].preco);
				inserirLista(li,car[i]);
			}			
		}else if(opcao == 2){
			system("cls");
			printf("Deseja remover quantos? ");
			scanf("%d",&quantRemocao);
			if(removeInicio(li,quantRemocao) == 1){
				printf("Removido com Sucesso!\n");
			}else{
				printf("Erro ao Remover!");
			}
			system("pause");
		}else if(opcao == 3){
			imprimirLista(li);
		}else if(opcao == 4){
			system("cls");
			if(tamanhoLista(li) == 0){
				printf("Lista está vazia!\n");
			}else{
				printf("Tamanho da lista: %d\n",tamanhoLista(li));
			}
			system("pause");
		}else if(opcao == 5){
			return 0;
		}else{
			printf("Opção inválida!\n");
		}
	}
	
	liberarLista(li);
return 0;
}
예제 #3
0
파일: booblesort.c 프로젝트: tulioc/EDA
int main (void) {
Lista* lista;
lista = criaLista(12);
int contador = 0;
 for(contador = 0; contador <= 50; contador++) {

   lista = insereElementoLista(lista, contador);

 }

imprimirLista(lista);
lista = booblesort(lista, qntElementos(lista));
printf("\n");
imprimirLista(lista);


  return 0;
}
예제 #4
0
void gestionarPedidoDeJob(socketQueEscribe){
	t_Package package;
	int seDebeReplanificar =1;
	recibirYdeserializarBloques(&package,socketQueEscribe); //validar status...
	do{
		pthread_mutex_lock(&lockEnvioSolicitudFS);
	t_list* estructuraDeTrabajo =solicitarArchivosAlFileSystem(package.rutasDeArchivos);  //YA FUNCIONA HASTA ACA. ESTA TESTEADO.
		pthread_mutex_unlock(&lockEnvioSolicitudFS);
		imprimirLista(estructuraDeTrabajo);
	if(list_size(estructuraDeTrabajo)==0){
		printf("Finaliza el Job debido a que FS no posee ninguno de los archivos solicitados\n");
		char idProceso = 'F';
		send(socketQueEscribe,&idProceso,sizeof(char),0);
		return;
	}
	t_list* estructuraDeTrabajoPlanificada = planificarNodos(estructuraDeTrabajo,package.combiner);
	imprimirLista(estructuraDeTrabajoPlanificada);
	seDebeReplanificar = mandarAEjecutarJob(estructuraDeTrabajoPlanificada,package.combiner,socketQueEscribe,package.rutaDestinoDeResultado,estructuraDeTrabajo,package.rutasDeArchivos);
//	eliminarListaEstructuraDeTrabajo(estructuraDeTrabajo);
	}while(0);//seDebeReplanificar);
}
void pruebaListaCircular2(ClinkedList<Articulo*, F>* lista)
{

//	for (int i = 0; i < 20; ++i)
//		lista->addDescendent(new Articulo(i, std::to_string(i)));

	bool existe = lista->addDescendent(new Articulo(10, "20"));
	std::cout << "Se inserto? " << (existe ? "si" : "no") << std::endl;
	Articulo* a = new Articulo(2, "nuevo");
	bool remplasado = lista->replace(a, [](Articulo* a){return a->getNombre() == "4"; });
	std::cout << a->getNombre() << "Se remplaso? " << (remplasado ? "si" : "no") << std::endl;
	imprimirLista(lista);

}
예제 #6
0
int main() {
    tPuntero cabeza;//ya se implica un * puntero, debido al sinonimo
    int e;
    cabeza = NULL;//Inicializar cabeza es FUNDAMENTAL
    printf("Ingrese elementos, -1 para finalizar: ");
    scanf("%d", &e);
    while(e != -1) {
        insertarAlPrincipio(&cabeza, e);
        scanf("%d", &e);
    }
    imprimirLista(cabeza);
    borrarLista(&cabeza);

    return 0;
}
//Aprobado.
void pruebaListaCircular(ClinkedList<Articulo*>* lista)
{
	for (int i = 0; i < 20; ++i)
		lista->addLast(new Articulo(i, "dfef"));

	bool seRemovio= lista->remove([](Articulo* a){ return a->getCodigo() == 6; });
	std::cout << (seRemovio ? "Si" : "No") << std::endl;

	Articulo * a = nullptr;
	bool seRemovio2 = lista->remove([](Articulo* a){ return a->getCodigo() == 7; },a );

	std::cout << "Se elimino: " << (seRemovio ? "Si" : "No") << std::endl;
	if (seRemovio2)
	{
		std::cout << "Codigo: " << a->getCodigo()
			<< ", Nombre: " << a->getNombre() << std::endl;
	}
	imprimirLista(lista);

	
	delete lista;

}
int main()
{
    no *lista=NULL;
    /*
    lista=insere(lista, "Belem" ); //1 Caso
    lista=insere(lista, "Alexandre"); //2 Caso
    lista=insere(lista, "Aalexandre");
    lista=insere(lista, "Nilton");
    lista=insere(lista, "Matos");
    lista=insere(lista, "Six");
    */
    lista=insere(lista,"Marco Feliciano"); //caso 1
    lista=insere(lista,"Alexandre"); //caso 2
    lista=insere(lista,"Yzaac"); //caso 4
    lista=insere(lista,"Carlos"); //caso 3
    
    imprimirLista(lista);    

    if ( find(lista, "Alexandre") ) { //retorna 1 se encontra, 1 no C eh verdadeiro
       printf("Alexandre existe na lista ordenada\n");
    }

    system("PAUSE");
}
예제 #9
0
파일: main.cpp 프로젝트: cco2013-1/INE5408
int main(int argc, char** argv) {
    
    ListaDeVetores lP;
    int op = 10;

    while (op!=0) {
        imprimeMenu();
        scanf("%d",&op);
        switch(op)
        {
            case 1:
                try
                {
                    lP.adiciona(lerString());
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 2:
                try
                {
                    lP.adicionaNoInicio(lerString());
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 3:
                try
                {
                    lP.adicionaNaPosicao(lerString(),lerInt());
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            
            case 4:
                try
                {
                    lP.adicionaEmOrdem(lerString());
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 5:
                try
                {
                    char *aux = lP.retira();
                    printf("%s foi retirado da lista.\n\n",aux);
                    delete(aux);
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 6:
                try
                {
                    char *aux = lP.retiraDoInicio();
                    printf("%s foi retirado da lista.\n\n",aux);
                    delete(aux);
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 7:
                try
                {
                    char *aux = lP.retiraDaPosicao(lerInt());
                    printf("%s foi retirado da lista.\n\n",aux);
                    delete(aux);
                }catch(int exc)
                {
                    except(exc);
                }
                break;
             case 8:
                try
                {
                    char *aux = lP.retiraEspecifico(lerString());
                    printf("%s foi retirado da lista.\n\n",aux);
                    delete(aux);
                }catch(int exc)
                {
                    except(exc);
                }
                break;
             case 9:
                try
                {
                    imprimirLista(&lP);
                }catch(int exc)
                {
                    except(exc);
                }
                break;
            case 0:
               printf("Hasta La Vista Baby!\n");
            	break;
            default:
                printf("Sinto muito, opção inválida.\n");
                break;
        }
    }
    return 0;
}
예제 #10
0
void* planificador(void* argumentos) {
	int q = 1; //En que parte del quantum esta
	int contIndex = 0;
	int proxPj = 0;

	nivel_t argu;
	memcpy(&argu, argumentos, sizeof(nivel_t));

	message_t mensaje;
	personaje_t pjAuxiliar; //--Este sirve para crear los personajes nuevos
	personaje_t* pjLevantador = malloc(sizeof(personaje_t)); //--Este sirve para levantar de la lista y usar

//--Boludeces de los sockets
	fd_set master, temp;
	struct sockaddr_in myAddress;
	struct sockaddr_in remoteAddress;
	int maxSock;
	int sockListener;
	int i, contPj;
	_Bool encontrado = false, pedirNoRequiereQuantum;

//para forzar el turno si se desbloquea

	iniSocks(&master, &temp, &myAddress, remoteAddress, &maxSock, &sockListener, argu.puertoPlan, logger);
	while (1) {
		i = getSockChanged(&master, &temp, &maxSock, sockListener, &remoteAddress, &mensaje, sizeof(mensaje), logger);
		if (i != -1) { //Conexcion que cambia
			pthread_mutex_lock(&semNiv);
			switch (mensaje.type) {
			case SALUDO:
				pjAuxiliar.name = mensaje.name;
				pjAuxiliar.sockID = i;
				pjAuxiliar.index = ++contIndex;
				pjAuxiliar.recursos = list_create(); //Arma la lista delos recursos

				list_add_new(argu.l_personajesRdy, &pjAuxiliar, sizeof(personaje_t));

				log_trace(logger, "Se agrego %c a la lista (%d)", mensaje.name, list_size(argu.l_personajesRdy));
				imprimirLista(argu.nombre, argu.l_personajesRdy, argu.l_personajesBlk, proxPj);

				if (list_size(argu.l_personajesRdy) == 1) {
					//--Mandar primer turno al primero

					mensaje.type = PERSONAJE;
					mensaje.detail = TURNO;

					if (send(pjAuxiliar.sockID, &mensaje, sizeof(message_t), 0) == -1) {
						log_error(logger, "send: %s", strerror(errno));
						exit(EXIT_FAILURE);
					}
				}

				break;
			case TURNO:
				pedirNoRequiereQuantum = true;
				if (mensaje.detail2 != NADA) {
					//--Agregar recurso pedido a su lista de recursos
					// (se lo agregamos aca, para saber poque recurso esta bloqueado, antes de mandarlo a la lista de bloqueados)
					list_add_new(pjLevantador->recursos, &(mensaje.detail2), sizeof(mensaje.detail2));
					pedirNoRequiereQuantum = false;

					if (mensaje.detail == BLOCK) { //Si volvió bloqueado, marcar personaje como bloqueado

						log_info(logger, "Personaje: %c esta bloquado por: %c", pjLevantador->name, mensaje.detail2);
						//-- Lo saca de listos, y lo pone en bloquados
						list_add(argu.l_personajesBlk, list_remove(argu.l_personajesRdy, proxPj));

						//Para que pase al otro PJ
						proxPj--;
						imprimirLista(argu.nombre, argu.l_personajesRdy, argu.l_personajesBlk, proxPj);

						q = Quantum + 1;
					}
					q--;
				}

				if (list_size(argu.l_personajesRdy) != 0) {

					//--Si ya terminó su quantum
					if (q >= Quantum) {
						proxPj++; //Solo avanza en la lista si se le acabo el Qauntum
						proxPj = abs(proxPj) % list_size(argu.l_personajesRdy);
						q = 1;
					} else {
						q++;
					}
					//--Cachear pj
					pjLevantador = list_get(argu.l_personajesRdy, proxPj);

					//--Si hay a quien enviarle el próximo turno

					mensaje.type = PERSONAJE;
					mensaje.detail = TURNO;

					if (pedirNoRequiereQuantum)
						usleep(delay);
					log_trace(logger, "Turno para %c", pjLevantador->name);
					if (send(pjLevantador->sockID, &mensaje, sizeof(message_t), 0) == -1) {
						log_error(logger, "send: %s", strerror(errno));
					}
				}
				break;
			case REINICIAR:
				mensaje.detail = DIEPOTATO;
				// Enviar mensaje de muerte al personaje, porque solicitó reiniciar.
				if (send(i, &mensaje, sizeof(mensaje), 0) == -1) {
					log_error(logger, "send: %s", strerror(errno));
					exit(EXIT_FAILURE);
				}
				break;
			case SALIR:
				encontrado = false;

				for (contPj = 0; contPj < list_size(argu.l_personajesBlk); contPj++) { //Cicla los personajes
					pjLevantador = list_get(argu.l_personajesBlk, contPj);
					if (pjLevantador->sockID == i) {
						encontrado = true; //Si lo encontras en Blk
						list_remove(argu.l_personajesBlk, contPj); //y sacarlo de la lista
						break;
					}
				}

				//Si no lo encuentra
				if (!encontrado) { //Si no lo encontras, buscarlo en rdy
					for (contPj = 0; contPj < list_size(argu.l_personajesRdy); contPj++) { //Cicla los personajes
						pjLevantador = list_get(argu.l_personajesRdy, contPj);
						if (pjLevantador->sockID == i) {
							list_remove(argu.l_personajesRdy, contPj); //y sacarlo de la lista
							break;
						}
					}
				}
				//Jamas deveria pasar que no lo encuentre

				int contRec;
				char* recurso;
				int j;
				personaje_t* pjLevantadorBlk = malloc(sizeof(personaje_t));
				//Si esta seteado "encontrado" es porque estaba bloqueado, entonces el ultimo recurso de la lista no es un recurso real.
				for (contRec = 0; contRec < list_size(pjLevantador->recursos) - (encontrado ? 1 : 0); contRec++) {
					recurso = list_get(pjLevantador->recursos, contRec);

					for (j = 0; j < list_size(argu.l_personajesBlk); j++) {
						//--Cicla los personajes bloqueados
						pjLevantadorBlk = list_get(argu.l_personajesBlk, j);
						//Si el ultimo recurso, es el que libera

						char* recursoLevantado = list_get(pjLevantadorBlk->recursos, list_size(pjLevantadorBlk->recursos) - 1);
						if (*recursoLevantado == *recurso) {
							log_trace(logger, "Se desbloqueo %c por %c recurso", pjLevantadorBlk->name, *recurso);
							//Desbloquear
							list_add(argu.l_personajesRdy, pjLevantadorBlk);
							list_remove(argu.l_personajesBlk, j);

							imprimirLista(argu.nombre, argu.l_personajesRdy, argu.l_personajesBlk, proxPj - 1);

							break;
						}
					}
				}

				//Limpia las cosas, porque se fue
				list_destroy_and_destroy_elements(pjLevantador->recursos, free);

				// forzar un mensaje de turno para volver a multiplexar
				if (list_size(argu.l_personajesRdy) > 0) {

					proxPj--;
					proxPj = abs(proxPj) % list_size(argu.l_personajesRdy);
					q = 1;

					imprimirLista(argu.nombre, argu.l_personajesRdy, argu.l_personajesBlk, proxPj);
					//--Cachear pj
					usleep(delay);
					mensaje.detail = TURNO;
					pjLevantador = list_get(argu.l_personajesRdy, proxPj);

					log_trace(logger, "Turno para %c", pjLevantador->name);
					if (send(pjLevantador->sockID, &mensaje, sizeof(message_t), 0) == -1) {
						log_error(logger, "send: %s", strerror(errno));
					}

				}

				if (mensaje.detail2 == FOSHIZZLE) {
					mensaje.detail2 = NADA;
					//Cuando un PJ termina tod0 su plan, se fija si hay otros PJs dando vueltas, o termina
					orqTerminoTodo(); //<-- Aca esta el execve
				}
				//End case SALIR
				break;
			}
			pthread_mutex_unlock(&semNiv);
		}
	}
	return NULL ;
}
int seleccionarJugador(tPersonaje** pPersonaje, tNivel* nivel) {
    int iTamanioColaListos, iTamanioListaBlock;

    // Me fijo si puede seguir jugando
    if (*pPersonaje != NULL) {

        switch(nivel->algoritmo) {
        case RR:
        	log_debug(logger, "RR: Planificando....");
            if ((*pPersonaje)->quantumUsado < nivel->quantum) {
                // Puede seguir jugando
            	enviarTurno(nivel, *pPersonaje, nivel->delay);
                return (EXIT_SUCCESS);

            } else {
                // Termina su quantum vuelve a la cola
                (*pPersonaje)->quantumUsado = 0;
            	queue_push(nivel->cListos, *pPersonaje);
            }
            break;

        case SRDF:
        	log_debug(logger, "SRDF: Planificando....");
            if ((*pPersonaje)->remainingDistance > 0) {
                // Puede seguir jugando
				enviarTurno(nivel, *pPersonaje, nivel->delay);
                return (EXIT_SUCCESS);

            } else if ((*pPersonaje)->remainingDistance == 0) {
            	//Le doy un turno para que pida el recurso
            	enviarTurno(nivel, *pPersonaje, nivel->delay);
                // Llego al recurso, se bloquea
            	return EXIT_SUCCESS;
            }
            break;
        }
    }

    // Busco al proximo personaje para darle turno
    iTamanioColaListos = queue_size(nivel->cListos);
    iTamanioListaBlock = list_size(nivel->lBloqueados);
    imprimirLista(nivel, *pPersonaje);

    if (iTamanioColaListos == 0 && iTamanioListaBlock == 0 && *pPersonaje == NULL) {
    	log_debug(logger, "No quedan mas personajes en el nivel: %s.", nivel->nombre);
    	return EXIT_SUCCESS;

    } else if (iTamanioColaListos == 1) {
    	//Si estan aqui es porque su quantum terminó
        *pPersonaje = queue_pop(nivel->cListos);
        enviarTurno(nivel, *pPersonaje, nivel->delay);

    } else if (iTamanioColaListos > 1) {
        switch(nivel->algoritmo) {
        case RR:
        	log_debug(logger, "Planificando RR...");
            *pPersonaje = queue_pop(nivel->cListos);
            (*pPersonaje)->quantumUsado = 0;
            enviarTurno(nivel, *pPersonaje, nivel->delay);
            break;

        case SRDF:
        	//Si esta aqui tiene que haber 3 o mas personajes
        	log_debug(logger, "Planificando SRDF...");

            *pPersonaje = planificacionSRDF(nivel);

            if((*pPersonaje)->remainingDistance > 0)
            	enviarTurno(nivel, *pPersonaje, nivel->delay);
            break;
        }
    }

    imprimirLista(nivel, *pPersonaje);

    return EXIT_SUCCESS;
}
int main (){
	srand(time(NULL));
	arv* arvIdade  = NULL;
	arv* arvNome = NULL;
	arv* arvAltura = NULL;
	lista* listaOrdenada = NULL;
	pessoa* estranho;
	int menu = 0;
	int submenu =0;
	int height =0;
	
	
	for(int i =0; i<TAM_INI; i++){
		estranho = criarPessoaAleatoria();
		if(i<5){
			estranho->idade = 15;
		}if(i<11&&i>=5){
			//use letras minusculas para o nome para nao ter problema com o strcmp
			estranho->nome ="jose";
		}if(i<16&&i>=10){
			estranho->altura =1.70;
		}
		arvNome = inserirPorNome(arvNome,estranho);	
		arvIdade = inserirPorIdade(arvIdade,estranho);	
		arvAltura = inserirPorAltura(arvAltura,estranho);
		
	}

	while(1){
	menu = 0;
	printf("-------------------------------------\ \n");
	printf("Filtragem de Objetos\n");
	printf("1 - Imprimir arvore filtrada pelo nome.\n");
	printf("2 - Imprimir arvore filtrada pela idade.\n");
	printf("3 - Imprimir arvore filtrada pela altura.\n");
	printf("4 - Imprimir arvore filtrada pelos elementos idicados pelo usuario.\n");
	printf("5 - Imprimir a altura das Arvores.\n");
	printf("6 - Sair.\n");
	printf("Selecione um iem de menu: ");
	scanf("%d",&menu);
	
	if(menu == 2){
		emOrdem(arvIdade);
	}else if( menu == 1){
		emOrdem(arvNome);
	}else if(menu == 3){
		emOrdem(arvAltura);
	}else if(menu ==4){
		while(1){
			submenu = 0;
			printf("-------------------------------------\ \n");
			printf("Menu de filtragem por prioridades.\n");
			
			printf("1 - Prioridade nome seguido por idade.\n");
			printf("2 - Prioridade nome seguido por altura.\n");
			printf("3 - Prioridade idade seguido por nome.\n");
			printf("4 - Prioridade idade seguido por altura.\n");
			printf("5 - Prioridade altura seguido por nome.\n");
			printf("6 - Prioridade altura seguido por idade.\n");
			printf("7 - Retornar.\n");
			printf("Selecione um iem de menu: ");
			scanf("%d",&submenu);
			
			if(submenu == 1){
				
				listaOrdenada = listaEmOrdem(arvNome);
				
				if(listaOrdenada != NULL){
					listaOrdenada = prioridadeNomeIdade(listaOrdenada);
					imprimirLista(listaOrdenada);
				}
				
				
			}else if(submenu==2){
				
				listaOrdenada = listaEmOrdem(arvNome);
				imprimirLista(listaOrdenada);
				if(listaOrdenada != NULL){
					listaOrdenada = prioridadeNomeAltura(listaOrdenada);
					imprimirLista(listaOrdenada);
				}
			
			}else if(submenu==3){
				
			listaOrdenada = listaEmOrdem(arvIdade);

				if(listaOrdenada != NULL){
					listaOrdenada = prioridadeIdadeNome(listaOrdenada);
					imprimirLista(listaOrdenada);
				}
			}else if(submenu==4){
				
				listaOrdenada = listaEmOrdem(arvIdade);
				if(listaOrdenada != NULL){
					listaOrdenada = prioridadeIdadeAltura(listaOrdenada);
					imprimirLista(listaOrdenada);
				}
				
				
			}else if(submenu==5){
				listaOrdenada = listaEmOrdem(arvAltura);
				if(listaOrdenada != NULL){
					listaOrdenada = prioridadeAlturaNome(listaOrdenada);
					imprimirLista(listaOrdenada);
				}
				
				
			}else if(submenu==6){
				
				listaOrdenada = listaEmOrdem(arvAltura);
				if(listaOrdenada != NULL){
					listaOrdenada = prioridadeAlturaIdade(listaOrdenada);
					imprimirLista(listaOrdenada);
				}
			
			}else if(submenu == 7){
				break;
			}
		
			
		}
		
		
	}else if(menu == 5){
		int height = altura(arvNome);
		printf("Altura da Arvore por Nome eh: %d\n", height);
		height = altura(arvIdade);
		printf("Altura da Arvore por Idade eh: %d\n", height);
		height = altura(arvAltura);
		printf("Altura da Arvore por Altura eh: %d\n", height);
	}else if(menu == 6){
		return 0;
	}

	}