L'algorithme de recherche binaire standard peut retourner n'importe lequel des éléments correspondants lorsque plusieurs occurrences existent. Pour garantir le retour de la première occurence, une modification est nécessaire. En utilisant le tableau défini par int donnees[8] = { 1, 2, 2, 2, 5, 6, 8, 9 };, l'implémentation suivante ajuste la logique de recherche :

#define TAILLE 8
int donnees[TAILLE] = { 1, 2, 2, 2, 5, 6, 8, 9 };

int chercherPremiereOccurrence(int valeur)
{
    int debut = 0, fin = TAILLE - 1;
    while (debut <= fin) {
        int centre = (debut + fin) / 2;
        if (valeur < donnees[centre]) {
            fin = centre - 1;
        } else if (valeur > donnees[centre]) {
            debut = centre + 1;
        } else {
            while (centre > 0 && donnees[centre - 1] == donnees[centre])
                centre--;
            return centre;
        }
    }
    return -1;
}

Pour calculer la racine carrée d'un nombre positif réel y, la recherche binaire peut être appliquée entre 0 et y. L'algorithme ci-dessous itère jusqu'à atteindre une précision suffisante, par exemple lorsque la différence entre le carré de l'approximation et y est inférieure à 0.001 :

double calculerRacineCarree(double nombre)
{
    double borneInferieure = 0.0, borneSuperieure = nombre, estimation;
    while (borneSuperieure - borneInferieure > 0.000001) {
        estimation = (borneInferieure + borneSuperieure) / 2.0;
        if (estimation * estimation > nombre)
            borneSuperieure = estimation;
        else
            borneInferieure = estimation;
    }
    return (borneInferieure + borneSuperieure) / 2.0;
}

Pour élever x à la puissance n (avec n entier positif), l'exponentiation rapide offre une complexité en Θ(log n). La méthode récursive divise le problème en sous-problèmes :

double puissanceRecursive(double base, int exposant)
{
    if (exposant == 1)
        return base;
    double resultatIntermediaire = puissanceRecursive(base, exposant / 2);
    resultatIntermediaire *= resultatIntermediaire;
    if (exposant % 2 == 1)
        return resultatIntermediaire * base;
    return resultatIntermediaire;
}

Une approche itérative évite la récursion et utilise les propriétés de l'exposant binaire :

double puissanceIterative(double base, int exposant)
{
    double resultat = 1.0;
    while (exposant > 0) {
        if (exposant % 2 == 1)
            resultat *= base;
        base *= base;
        exposant /= 2;
    }
    return resultat;
}