Existe un algoritmo que se utiliza para encontrar el número máximo y el mínimo dentro de un arreglo de números (o de otros objetos, dependiendo del programa), es el algoritmo MAXMIN.

El algoritmo sirve para un número n(en potencia de dos) de elementos. Después de encontrar el máximo y el mínimo en el arreglo, guarda el valor máximo en la posición [0] y el mínimo en la posición[1] de un arreglo[2].

El algoritmo es recursivo, en el caso base(cuando n es dos) solamente compara los valores y los coloca en en las casillas correspondientes del arreglo[2].

En el caso recursivo, el arreglo se va partiendo en mitades, de 0 a (n/2)-1 y otro de n/2 a n-1. Así hasta llegar al caso base.

Aquí se presenta el código en lenguaje C.

/*
 * Author: Arturo Nereu Nunez Martinez 1163145
 *
 * Version: Febrero 2008
 *
 * Programa que ejecuta el algoritmo MAXMIN, con una entrada de maximo 32 numeros.
 * La entrada debe ser potencia de dos.
*/

#include <stdio.h>

void maxMin(int *arr, int *arrMaxMin, int n){

	if(n == 2){

		if(arr[0] > arr[1]){

			arrMaxMin[0] = arr[0];
			arrMaxMin[1] = arr[1];
		} else{
			arrMaxMin[0] = arr[1];
			arrMaxMin[1] = arr[0];
		}
	}

	if(n >= 4){

		int i = 0;
		int lim = n/2;
		int maxMinA[2];
		int maxMinB[2];

		int arrTempA[lim];

		for(i; i<lim; i++){

			arrTempA[i] = arr[i];
		}

		int arrTempB[lim];
		i = 0;

		for(i; i< lim; i++){

			arrTempB[i] = arr[lim+i];
		}	

		maxMin(arrTempA, maxMinA, lim);
		maxMin(arrTempB, maxMinB, lim);

		if(maxMinA[0] >= maxMinB[0]){

			arrMaxMin[0] = maxMinA[0];
		} else{

			arrMaxMin[0] = maxMinB[0];
		}

		if(maxMinA[1] <= maxMinB[1]){

			arrMaxMin[1] = maxMinA[1];
		} else{

			arrMaxMin[1] = maxMinB[1];
		}
	}
}

void pideDatos(int *X, int n){

	int *x, i=0;
	x = X+n;

   for(; X<x; ++X) {
       printf("Dame el dato [%i]:",i++);
       scanf("%i",X);
    }
}

int main (void){

	int tamArr = 0;
	int arrMaxMin[2];
	int *ptrArrMaxMin = &arrMaxMin[0];	

	printf("Dame el numero en potencias de dos, para el tamaño del arreglo: ");
	scanf("%i", &tamArr);

	int arrGeneral[tamArr];

	pideDatos(arrGeneral, tamArr);
	maxMin(arrGeneral, ptrArrMaxMin, tamArr);

	printf("El max: %i, y el min: %i \n", arrMaxMin[0], arrMaxMin[1]);

	return 0;
}

Probablemente no esté bien refactorizado, pero el ejemplo del algoritmo es funcional.