#include <stdio.h>
#include <stdlib.h>
#include <iostream.h>
#include <conio.h>

int maxs(double*, int);

int _tmain(int argc, _TCHAR* argv[])
{
    randomize();
    double n;
    int i;
    cin >> n;
    double* a = new double[n];

    for (i = 0; i < n; i++)
        *(a + i) = random(21) - 10;

    for (i = 0; i < n; i++)
        cout << *(a + i) << " ";

    cout << endl;
    double r = maxs(a, n - 1);
    cout << "Max value is " << r;
    getch();
    return 0;
}

int maxs(double* a, int n)
{
    double r1, r2;

    if (n == 0)
        return a[0];

    r1 = maxs(a, n / 2);
    r2 = maxs(a + n / 2 + 1, n - 1);
    return max(r1, r2);
}

for(i=0;i<n;i++)
*(a+i)=random(21)-10;

int maxs(double *, int  );
^^^

maxs(a,n-1);
       ^^^^

r1=maxs(a,n/2);
r2=maxs(a+n/2+1,n-1);

r2=maxs(a+n/2+1,n-1);
                ^^^^

#include <iostream>
#include <algorithm>

int maxs (double *a,int n){
double r1,r2;
if(n==0)
  return a[0];
 r1=maxs(a,n/2);
 r2=maxs(a+n/2+1,n-1);
 return std:: max(r1,r2);
}

int main()
{
    double a[] = { 1.1, 2.2, 3.3, 100.123 };

    std::cout << maxs( a, 2 ) << std::endl;
}

size_t max_element( const double *a, size_t n )
{
    if ( n < 2 )
    {
        return 0;
    }
    else
    {
        size_t i = max_element( a, n / 2 );
        size_t j = n / 2 + max_element( a + n / 2 , n - n / 2 );

        return a[i] < a[j] ? j : i;
    }
}

#include <iostream>
#include <algorithm>

size_t max_element( const double *a, size_t n )
{
    if ( n < 2 )
    {
        return 0;
    }
    else
    {
        size_t i = max_element( a, n / 2 );
        size_t j = n / 2 + max_element( a + n / 2 , n - n / 2 );

        return a[i] < a[j] ? j : i;
    }
}

int maxs (double *a,int n){
double r1,r2;
if(n==0)
  return a[0];
 r1=maxs(a,n/2);
 r2=maxs(a+n/2+1,n-1);
 return std:: max(r1,r2);
}

int main()
{
    double a[] = { 1.1, 2.2, 3.3, 100.123 };

    std::cout << maxs( a, 2 ) << std::endl;

    std::cout << a[max_element( a, 3 )] << std::endl;
}

100
3.3

max_element( a, 4 )

max_element( a, 2 ) <== max_element( a, n / 2 )

max_element( a + 2, 2 ) <== max_element( a + т . 2, т - n / 2 )

a[0] a[1] a[2] a[3]
 |    |    |    |
 ------    ------
 max1       max2
  |          |
  ------------
      max

size_t i = max_element( a, n / 2 );
size_t j = n / 2 + max_element( a + n / 2 , n - n / 2 );

return a[i] < a[j] ? j : i;