Cacher is the code snippet organizer for pro developers

/*
 * Autor: Wagner F o Jr
 * Algoritmos e Estruturas de Dados I
 * Aula 7, Exercicio 1
 */

#include <stdlib.h>
#include <stdio.h>

int main (int argc, char *argv[])
{
	void imprimeVet (int vet[], int ini, int fim);
	int compara1( const void *x, const void *y);
	int compara2( const void *x, const void *y);
	int compara3( const void *x, const void *y);
	int compara4( const void *x, const void *y);
	int compara5( const void *x, const void *y);

	int n, i;
	int (*ponteiro)(const void *, const void *);

	// Recebe o número de elementos do vetor
	scanf("%d", &n);
	int *vetor = (int *) malloc(sizeof(int)*n);
	
	// Recebe os elementos		
	for ( i = 0; i < n; i++ )
		scanf("%d", &vetor[i]);

	//imprimeVet(vetor, 0, n-1);

	printf("compara1:\n");
	ponteiro = &compara1;
	qsort( vetor, n, sizeof *vetor, ponteiro);
	imprimeVet(vetor, 0, n-1);

	printf("compara2:\n");
	ponteiro = &compara2;
	qsort( vetor, n, sizeof *vetor, ponteiro);
	imprimeVet(vetor, 0, n-1);

	printf("compara3:\n");
	ponteiro = &compara3;
	qsort( vetor, n, sizeof *vetor, ponteiro);
	imprimeVet(vetor, 0, n-1);

	printf("compara4:\n");
	ponteiro = &compara4;
	qsort( vetor, n, sizeof *vetor, ponteiro);
	imprimeVet(vetor, 0, n-1);

	printf("compara5:\n");
	ponteiro = &compara5;
	qsort( vetor, n, sizeof *vetor, ponteiro);
	imprimeVet(vetor, 0, n-1);

	return EXIT_SUCCESS;
}

void imprimeVet (int vet[], int ini, int fim)
{
	int i;
	printf("{");
	for( i=ini ; i<fim ; i++) {
		printf("%d, ", vet[i]);
	}
	printf("%d}\n\n", vet[fim]);
}

// Função compara1: o menor inteiro precede o maior (ordem crescente).
int compara1( const void *a, const void *b) {
	return (*(int *)a - *(int *)b); 
}

// Função compara2: o maior inteiro precede o menor (ordem decrescente)
int compara2( const void *a, const void *b) {
	return (*(int *)b - *(int *)a); 
}

// Função compara3: o inteiro ímpar precede o inteiro par, mas se ambos forem ímpar/par então o menor precede o maior
int compara3( const void *a, const void *b) {
	// conseguindo os valores passados
	int l = *(const int *)a;
	int r = *(const int *)b;
 
	// dois são impar, coloca o menor dos dois primeiro
	if ((l&1) && (r&1))
		return (l-r);
 
	// dois são par, coloca o menor dos dois primeiro
	if ( !(l&1) && !(r&1) )
		return (l-r);
 
	// l é par, coloca r primeiro
	if (!(l&1))
		return 1;
 
	// l é impar, coloca l primeiro
	return -1;
}

// Função compara4: o inteiro positivo precede o inteiro negativo, mas se ambos forem positivos, o menor precede o maior; e se ambos forem negativos, o maior precede o menor
int compara4( const void *a, const void *b) {
	// conseguindo os valores passados
	int l = *(const int *)a;
	int r = *(const int *)b;
 
	// dois são negativos, retorna o maior
	if ((l<0) && (r<0))
		return (r-l);
 
	// dois são posivos, retorna o menor
	if ((l>0) && (r>0))
		return (l-r);
 
	// l é positivo, retorna o maior
	if (l>0)
		return -1;
	
	return r;
}

// Função compara5: o menor inteiro precede o maior com base nos seus valores absolutos, mas se os valores absolutos forem iguais, o inteiro positivo precede o inteiro negativo
int compara5( const void *a, const void *b) {
	// conseguindo os valores passados
	int l = *(const int *)a;
	int r = *(const int *)b;
 
	// valores absolutos iguais, retorna o menor
	if ((abs(l)) == (abs(r)))
		return (r-l);

	// menor inteiro é retornado com base nos valores absolutos
	if ((abs(l)) > (abs(r)))
		return 1;
 
	return -1;
}