Programa Java para escribir su propio atoi()

La función atoi() en C toma una string (que representa un número entero) como argumento y devuelve su valor de tipo int. Entonces, básicamente, la función se usa para convertir un argumento de string en un número entero.

Sintaxis:  

int atoi(const char strn)

Parámetros: la función acepta un parámetro strn que se refiere al argumento de string que se necesita convertir en su equivalente entero.

Valor devuelto: si strn es una entrada válida, la función devuelve el número entero equivalente para el número de string pasado. Si no tiene lugar una conversión válida, la función devuelve cero.

Ahora comprendamos varias formas en las que uno puede crear su propia función atoi() compatible con varias condiciones:

Enfoque 1: a continuación se muestra una implementación simple de la conversión sin considerar ningún caso especial. 

• Inicializar el resultado como 0.
• Comience desde el primer carácter y actualice el resultado para cada carácter.
• Para cada carácter actualice la respuesta como resultado = resultado * 10 + (s[i] – ‘0’)

// A simple Java program for
// implementation of atoi
class GFG {
 
    // A simple atoi() function
    static int myAtoi(String str)
    {
       
        // If str is NULL or str contains non-numeric
        // characters then return 0 as the number is not
        // valid
        if (str == "" || str.matches("[a-zA-Z]+") || str.matches(".*[0-9].*")) {
            return 0;
        }
        // Initialize result
        int res = 0;
 
        // Iterate through all characters
        // of input string and update result
        // take ASCII character of corresponding digit and
        // subtract the code from '0' to get numerical
        // value and multiply res by 10 to shuffle
        // digits left to update running total
        for (int i = 0; i < str.length(); ++i)
            res = res * 10 + str.charAt(i) - '0';
 
        // return result.
        return res;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        String str = "8f9789";
       
         
        // Function call
        int val = myAtoi(str);
        System.out.println(val);
    }
}
 
// This code is contributed by PrinciRaj1992

89789

Enfoque 2: esta implementación maneja los números negativos. Si el primer carácter es ‘-‘, almacene el signo como negativo y luego convierta el resto de la string en número utilizando el enfoque anterior mientras multiplica el signo con él. 

// Java program for
// implementation of atoi
class GFG {
 
    // A simple atoi() function
    static int myAtoi(char[] str)
    {
 
        // Initialize result
        int res = 0;
 
        // Initialize sign as positive
        int sign = 1;
 
        // Initialize index of first digit
        int i = 0;
 
        // If number is negative, then
        // update sign
        if (str[0] == '-') {
            sign = -1;
 
            // Also update index of first
            // digit
            i++;
        }
 
        // Iterate through all digits
        // and update the result
        for (; i < str.length; ++i)
            res = res * 10 + str[i] - '0';
 
        // Return result with sign
        return sign * res;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        char[] str = "-123".toCharArray();
       
        // Function call
        int val = myAtoi(str);
        System.out.println(val);
    }
}
 
// This code is contributed by 29AjayKumar

-123

Enfoque 3: esta implementación maneja varios tipos de errores . Si str es NULL o str contiene caracteres no numéricos, devuelva 0 porque el número no es válido. 

 -134

Enfoque 4: Se deben manejar cuatro casos de esquina: 

• Descarta todos los espacios en blanco iniciales
• Signo del número
• Desbordamiento
• Entrada inválida

Para eliminar los espacios en blanco iniciales, ejecute un ciclo hasta que se alcance un carácter del dígito. Si el número es mayor o igual a INT_MAX/10. Luego devuelva INT_MAX si el signo es positivo y devuelva INT_MIN si el signo es negativo. Los otros casos se manejan en enfoques anteriores. 

Ejecución en seco: 

A continuación se muestra la implementación del enfoque anterior: 

// A simple Java program for
// implementation of atoi
class GFG {
    static int myAtoi(char[] str)
    {
        int sign = 1, base = 0, i = 0;
 
        // if whitespaces then ignore.
        while (str[i] == ' ')
        {
            i++;
        }
 
        // sign of number
        if (str[i] == '-' || str[i] == '+')
        {
            sign = 1 - 2 * (str[i++] == '-' ? 1 : 0);
        }
 
        // checking for valid input
        while (i < str.length
               && str[i] >= '0'
               && str[i] <= '9') {
 
            // handling overflow test case
            if (base > Integer.MAX_VALUE / 10
                || (base == Integer.MAX_VALUE / 10
                    && str[i] - '0' > 7))
            {
                if (sign == 1)
                    return Integer.MAX_VALUE;
                else
                    return Integer.MIN_VALUE;
            }
            base = 10 * base + (str[i++] - '0');
        }
        return base * sign;
    }
 
    // Driver code
    public static void main(String[] args)
    {
        char str[] = " -123".toCharArray();
       
        // Function call
        int val = myAtoi(str);
        System.out.printf("%d ", val);
    }
}
 
// This code is contributed by 29AjayKumar

 -123

Análisis de complejidad para todos los enfoques anteriores: 

• Complejidad temporal: O(n). 
  Solo se necesita un recorrido de la string.
• Complejidad espacial: O(1). 
  Como no se requiere espacio adicional.

Programa recursivo para atoi() .

Ejercicio: 
Escriba su won atof() que toma una string (que representa un valor de punto flotante) como argumento y devuelve su valor como doble.

Consulte el artículo completo sobre Escriba su propio atoi() para obtener más detalles.