Нахождение max и min функции одной переменной

#ifndef NODE_H
#define NODE_H
 
template < class T >
class Node
{
    template < class T > friend class Stack;
public:
    Node( T );
private:
    T data;
    Node *nextPtr;
};
 
template < class T >
Node< T >::Node( T m_data )
: data( m_data ), nextPtr( 0 )
{
}
 
#endif

#ifndef STACK_H
#define STACK_H
 
#include "Node.h"
 
template < class T >
class Stack
{
public:
    Stack();
    ~Stack();
 
    void push( T );
    bool pop( T & );
    T peek() const;
    bool isEmpty() const;
private:
    Node< T > *firstPtr;
    Node< T > *lastPtr;
};
 
template < class T >
Stack< T >::Stack()
: firstPtr( 0 ), lastPtr( 0 )
{
}
template < class T >
Stack< T >::~Stack()
{
    Node< T > *currentPtr = firstPtr;
    Node< T > *tempPtr = currentPtr;
    while( currentPtr != 0 )
    {
        tempPtr = currentPtr;
        currentPtr = currentPtr->nextPtr;
        delete tempPtr;
    }
}
template < class T >
void Stack< T >::push( T m_data )
{
    Node< T > *newPtr = new Node< T >( m_data );
    if( isEmpty() )
        firstPtr = lastPtr = newPtr;
    else
    {
        lastPtr->nextPtr = newPtr;
        lastPtr = newPtr;
    }
}
template < class T >
bool Stack< T >::pop( T &m_data )
{
    if( isEmpty() )
        return false;
    else
    {
        Node< T > *tempPtr = lastPtr;
        if( firstPtr == lastPtr )
            firstPtr = lastPtr = 0;
        else
        {
            Node< T > *currentPtr = firstPtr;
            while( currentPtr->nextPtr != lastPtr )
                currentPtr = currentPtr->nextPtr;
            lastPtr = currentPtr;
            currentPtr->nextPtr = 0;
        }
        m_data = tempPtr->data;
        delete tempPtr;
        return true;
    }
}
template < class T >
bool Stack< T >::isEmpty() const
{
    return firstPtr == 0;
}
template < class T >
T Stack< T >::peek() const
{
    if( firstPtr != 0 )
        return lastPtr->data;
    else
        return 0;
}
 
#endif

#include <string>
 
void formatStr_xToValue( char *str, int value )
{
    char temp[ 50 ] = { 0 }; 
    char *beginStr = str; // сохраняем указатель str, т.е. дальше мы его будем изменять
    for( char *ptr = strchr( str, 'x' ); ptr != '\0'; ptr = strchr( str, 'x' ) )
    /* находим x ; пока находим x, т.е. ptr не равно 0; находим следующий x  */
    {
        *ptr = '\0'; // вместо x вставим 0
        strcpy( temp + strlen( temp ), str ); // копируем все, что после предыдущего x(или начала функции) и до текущего x
        itoa( value, temp + strlen( temp ), 10 ); // вставляем вместо x значение в конец temp
        str = ptr + 1; // пропускаем 0, который был раньше x. В итоге str указывает на оставшуюся часть функции после текущего x.
    }
    strcpy( temp + strlen( temp ), str ); // все, что осталось после последного x копируем в конец temp
    str = beginStr; // устанавливаем указатель в исходный указатель 
    strcpy( str, temp ); // форматированную функцию temp копируем в str
}

#include "Stack.h"
#include <string>
 
bool isOperator( char symb );
bool isStrIsDigit( const char *str );
int precedence( char operator1, char operator2 );
 
void convertToPostfix( char *infix )
{
    int infixLen = strlen( infix );
    char postfix[ 100 ] = { 0 };
    int postfixLen = 0;
    Stack< char > stack;
    stack.push( '(' );
    infix[ infixLen ] = ' ';
    infix[ infixLen + 1 ] = ')';
    infix[ infixLen + 2 ] = '\0';
    infixLen += 2;
    char symb = 0;
 
    char *tokenPtr = strtok( infix, " " );
    while( tokenPtr != NULL )
    {
        if( isStrIsDigit( tokenPtr ) ) // если число
        {
            strcpy( postfix + postfixLen, tokenPtr );
            postfixLen += strlen( tokenPtr );
            postfix[ postfixLen ] = ' ';
            postfix[ postfixLen + 1 ] = '\0';
            ++postfixLen;
 
        }
        else if( *tokenPtr == '(' ) // если левая скобка
        {
            stack.push( *tokenPtr ); // заталкиваем левую скобку
        } 
        else if( isOperator( *tokenPtr ) ) // если оператор
        {
            while( isOperator( stack.peek() ) && // пока в конце стэка операторы
                1 != precedence( *tokenPtr, stack.peek() ) ) // и приоритеты этих операторов равно или больше
            {
                switch( precedence( *tokenPtr, stack.peek() ) ) // приоритет
                {
                case -1: // если текущий оператор имеет более низкий приоретер, чем оператор в стэке
                case 0: // если текущий оператор имеет одинаковый приоретер с оператором в стэке
                    stack.pop( symb ); // выталкиваем
                    postfix[ postfixLen ] = symb; // и вставляем в postfix
                    postfix[ postfixLen + 1 ] = ' ';
                    postfix[ postfixLen + 2 ] = '\0';
                    postfixLen += 2;
                    break;
                case 1: 
                    // оставляем оператор в стэке и выходим из цикла
                    // сюда мы не должны попасть из-за условия в цикле
                    break;
                }
            }
            stack.push( *tokenPtr ); // заталкиваем текущий оператор
        }
        else if( *tokenPtr == ')' ) // если правая скобка
        {
            while( isOperator( stack.peek() ))  // пока в конце стэка оператор
            {
                stack.pop( symb ); // выталкиваем оператор
                postfix[ postfixLen ] = symb; // и вставляем в postfix
                postfix[ postfixLen + 1 ] = ' ';
                postfix[ postfixLen + 2 ] = '\0';
                postfixLen += 2;
            }
            stack.pop( symb ); // выталкиваем левую скобку
        }   
        tokenPtr = strtok( NULL, " " );
    }
    strcpy( infix, postfix );
    infix[ strlen( infix ) - 1 ] = '\0'; //убираем последний пробел
}

#include <iostream>
#include <string>
 
void searchMinMax( char *function, int a, int b, double &min, double &max );
 
int main()
{
    setlocale( LC_ALL, "Russian" );
    
    const int sizeFunction = 50;
    char function[ sizeFunction ];
    std::cout << "Введите функцию( все символы должны быть отделены пробелами ):" << std::endl;
    std::cin.getline( function, 50, '\n' );
    //strcpy( function, "x + 2 * x / 5" );
    std::cout << "Введите через пробел границы отрезка [a,b]: " << std::endl;
    int a = 0;
    int b = 0;
    std::cin >> a >> b;
 
    double min = 0;
    double max = 0;
    searchMinMax( function, a, b, min, max );
 
    std::cout << "Минимум на отрезке [a,b] составляет: " << min << std::endl;
    std::cout << "Максимум на отрезке [a,b] составляет: " << max << std::endl;
 
    system( "pause" );
    return 0;
}

#include <cmath>
 
bool isOperator( char symb )
{
    if( symb == '+' || symb == '-' || symb == '*' || symb == '/' ||
        symb == '^' || symb == '%' )
        return true;
    return false;
}
bool isDigit( char symb )
{
    if( symb >= '0' && symb <= '9' )
        return true;
    return false;
}
double calculate( double y, double x, char operat )
{
    double result = 0;
    switch( operat )
    {
    case '+':
        result = y + x;
        break;
    case '-':
        result = y - x;
        break;
    case '*':
        result = y * x;
        break;
    case '/':
        result = y / x;
        break;
    case '^':
        result = pow( y, x );
        break;
    case '%':
        result = ( int )y % ( int )x;
        break;
    }
    return result;
}
 
bool isStrIsDigit( const char *str )
{
    if( *str == '-' )
    {
        ++str;
        if( !isDigit( *str ) &&  *str != '-' )
            return false;
        else if( *str == '-' )
        {
            ++str;
            if( !isDigit( *str ) )
                return false;
        }
    }
    for( ; !isDigit( *str ) && *str; ++str )
        return false;
    return true;
}
int precedence( char operator1, char operator2 )
{
    if( operator1 == '+' || operator1 == '-' )
        if( operator2 == '+' || operator2 == '-' )
            return 0;
        else // * / ^ %
            return -1;
    else // * / ^ %
        if( operator2 == '+' || operator2 == '-' )
            return 1;
        else // * / ^ %%
            return 0;
}

#include "Stack.h"
#include <cmath>
#include <string>
 
bool isOperator( char symb );
bool isStrIsDigit( const char *str );
double calculate( double y, double x, char operat );
 
double evaluatePostfixExpression( char *postfix )
{
    Stack< double > stack;
    double result = 0;
    double x = 0;
    double y = 0;
 
    char *tokenPtr = strtok( postfix, " " );
 
    while( tokenPtr != NULL )
    {
        if( isStrIsDigit( tokenPtr )  )
        {
            if( *tokenPtr == '-' && *( tokenPtr + 1 ) == '-' ) // минус на минус дает пробелы(плюс)!
                *tokenPtr = *( tokenPtr + 1 ) = ' ';
            stack.push( atoi( tokenPtr ) );
        }
        else if( isOperator( *tokenPtr ) )
        {
            stack.pop( x );
            stack.pop( y );
            result = calculate( y, x, *tokenPtr );
            stack.push( result );
        }
        tokenPtr = strtok( NULL, " " );
    }
    stack.pop( result );
    return result;
}

#include <string>
 
void convertToPostfix( char *infix );
double evaluatePostfixExpression( char *postfix );
void formatStr_xToValue( char *str, int value );
 
void searchMinMax( char *function, int a, int b, double &min, double &max )
{
    char str[ 50 ] = { 0 };
    double result = 0;
    
    strcpy( str, function ); // скопируем в str исходную функцию
    formatStr_xToValue( str, a ); // заменяем все x на текущее значение, т.е. границу a
    convertToPostfix( str ); // преобразуем инфиксную нотацию в постфиксную нотацию
    min = max = evaluatePostfixExpression( str ); // вычисляем результат постфиксной нотации
    
    for( int i = a + 1; i <= b; ++i )
    {
        strcpy( str, function ); // скопируем в str исходную функцию
        formatStr_xToValue( str, i ); // заменяем все x на текущее значение i
        convertToPostfix( str ); // преобразуем инфиксную нотацию в постфиксную нотацию
        result = evaluatePostfixExpression( str ); // вычисляем результат постфиксной нотации
        if( result > max )
            max = result;
        else if( result < min )
            min = result;
    }
}