Alternativamente, dado que siempre recorres hacia la izquierda o derecha para una u otra función, sugiero hacer un ciclo, no invocar recursivamente, deteniendose justo al darse cuenta que no hay mas nodos que visitar a continuación.

Ambas (recursiva o no) son soluciones sencillas, pero la recursiva podría "morir" por hacer crecer el stack indefinidamente, para árboles más grandes.

Ahora, todo esto funciona solo si el árbol binario es un árbol de busqueda binaria, pues si fuera solo binario, irse a la izquierda o derecha no garantiza encontrar el mínimo o máximo y en ese caso, tal vez la versión recursiva sea más sencilla que su equivalente no recursiva.

tal vez max() deberia tomar la rama derecha, no la izquierda.

Ojo que  Redondeo != Truncado, por lo que la suma de n2 / 2 es importante

n2 es siempre una potencia de 10?

Si es asi esto sugiero:
- Sumar la mitad de n2 a n1
- Calcular el resto de la division entre n1 y n2 usando el modulo
- Restarle ese resto a n1

1424, 10:
- 1424 + 5 = 1429
- 1429 % 10 = 9
- 1429 - 9 = 1420

2636, 100:
- 2636 + 50 = 2686
- 2686 % 100 = 86
- 2686 - 86 = 2600

¿que ocurre si se ingresan numeros negativos?

¿Por que solicitas ancho y largo del cuadrado, si ellos son siempre iguales?

Sugiero que pongas las entradas y salidas que obtienes versus la que esperas. Decir que obtienes "lo mismo" no es clarificador, en mi opinion.

La especificacion del lenguaje indica que sizeof(float) <= sizeof(double), esto permite que algunos compiladores tomen la opcion de hacerlos de igual tamaño y otros hacer que el double use mayor tamaño.

Un codigo escrito leyendo un double usando %f es un codigo no portable de un compilador a otro.

Lo que un compilador tiene que implementar es que
sizeof float sea menor o igual a sizeof double.

Sospecho que en ese compilador el primer sizeof es menor estricto que el segundo, lo que hace razonable el comportamiento que obtienes.

Creo que el codigo ofrecido tiene un error adicional al hacer una suposición incorrecta. La suposición es esta:
  
No ser mayor que el máximo actual convierte a un numero en el menor del conjunto.

Si los nros fueran { 0, 2, 1, 7 }

La logica del código anterior se seguiría así:

• El máximo y mínimo es el 0 inicial.
• 2 es > 0, -> ahora 2 es el maximo, el minimo no cambia
• 1 no es > 2 -> ahora 1 es el minimo (lo que es falso).

Ademas, el codigo mantiene variables que pueden ser eliminadas.
Lo único necesario, creo yo, es mantener los indices del mayor o menor.

Propongo estas correcciones, imayor e imenor son los indices de los valores mayor y menor. No es necesario guardar el valor mayor o menor, porque eso se obtiene usando el arreglo que se recibe como parametro y esos índices.

#include <stdio.h>
 
void mayor_menor( int votos[] )
{
    int imayor = 0, imenor = 0;
    int contador = 0;
 
    for( contador = 1 ; contador < 4 ; contador++ ) {
        if ( votos[contador] > votos[imayor]) {
            imayor = contador ;
        }
        else 
        if ( votos[contador] < votos[imenor]) {
            imenor = contador;
        }
    }
 
    printf( "Valor mayor: %d\n", votos[imayor] );
    printf( "Valor menor: %d\n", votos[imenor] );
}
 
int main() {
    int votos[] = { 0, 2, 1, 7 };
 
    mayor_menor( votos );
}
 

Esto se puede ver en ejecución es este link: http://goo.gl/24qbNK