Найти минимум в массиве используя наиболее оптимальный алгоритм

#include <iostream>
using namespace std;
 
size_t iteration_count(0), comparison_count(0);
 
template<typename T>
void biselectional_sort_henry(T* ar, size_t len)
{
size_t left_ind=0, right_ind=len-1;
size_t  min_val_ind=left_ind, max_val_ind=right_ind;
comparison_count=0;
int temp_int;
 
if(len>1)
do
{
max_val_ind=right_ind;
min_val_ind=left_ind;
iteration_count++;
//////////
for(size_t i=left_ind+1; i<right_ind-1; i+=2)
{
if(ar[i]!=ar[i+1])
{
comparison_count++;
if(ar[i]>ar[i+1])
{
comparison_count++;
if(ar[max_val_ind]<ar[i])
{
comparison_count++;
max_val_ind=i;
}
if(ar[min_val_ind]>ar[i+1])
{
comparison_count++;
min_val_ind=i+1;
}
}
else
{
if(ar[max_val_ind]<ar[i+1])
{
comparison_count++;
max_val_ind=i+1;
}
if(ar[min_val_ind]>ar[i])
{
comparison_count++;
min_val_ind=i;
}
}
}
else
{
if(ar[max_val_ind]<ar[i])
{
comparison_count++;
max_val_ind=i;
}
else
if(ar[min_val_ind]>ar[i])
{
comparison_count++;
min_val_ind=i;
}
}
}
/////////////
temp_int=ar[left_ind];
ar[left_ind++]=ar[min_val_ind];
ar[min_val_ind]=temp_int;
 
temp_int=ar[right_ind];
ar[right_ind--]=ar[max_val_ind];
ar[max_val_ind]=temp_int;
}
while(left_ind<right_ind);
}
 
template<typename T>
void biselectional_sort(T* ar, size_t len)
{
size_t left_ind=0, right_ind=len-1;
size_t  min_val_ind=left_ind, max_val_ind=right_ind;
comparison_count=0;
 
int temp_int;
 
if(len>1)
do
{
max_val_ind=right_ind;
min_val_ind=left_ind;
iteration_count++;
for(size_t i=left_ind+1; i<right_ind+1; ++i)
{
if(ar[max_val_ind]<ar[i])
{
max_val_ind=i;
comparison_count++;
continue;
}
 
if(ar[min_val_ind]>ar[i])
{
comparison_count++;
min_val_ind=i;
continue;
}
}
temp_int=ar[left_ind];
ar[left_ind++]=ar[min_val_ind];
ar[min_val_ind]=temp_int;
 
temp_int=ar[right_ind];
ar[right_ind--]=ar[max_val_ind];
ar[max_val_ind]=temp_int;
}
while(left_ind<right_ind);}
 
int main(int argc, char* argv[])
{
    int ar[]=
    {
        2,1,5,3,7,4,8,11,90,9
    };
    int ar_copy[]=
    {
        2,1,5,3,7,4,8,11,90,9
    };
    size_t len=sizeof(ar)/sizeof(ar[0]);
biselectional_sort_henry(ar, len);
cout<<"The array with size of "<<len<<" was sorted with "<<comparison_count<<" comparisons\n";
cout<<"made while "<<iteration_count<<" iterations\n";
for(size_t i=0; i<len; ++i)cout<<ar[i]<<" ";
cout<<endl;
 
biselectional_sort(ar_copy, len);
cout<<"The array with size of "<<len<<" was sorted with "<<comparison_count<<" comparisons\n";
cout<<"made while "<<iteration_count<<" iterations\n";
for(size_t i=0; i<len; ++i)cout<<ar_copy[i]<<" ";
cout<<endl;
system("pause");
return 0;
}

    int ar[] =
    {
        2,1,5,3,7,4,8,11,9
    };

#include <iostream>
#include <vector>
using namespace std;
 
inline vector<int>& f_findMin(vector<int>& vec)
{
    if (vec.size() == 1)
        return vec;
 
    for (size_t i(0), size(vec.size() - 1); i <= size / 2; ++i)
        vec[i] = vec[i] < vec[size - i] ? vec[i] : vec[size - i];
 
    vec.resize((vec.size() + 1) / 2);
 
    return f_findMin(vec);
}
 
int main()
{
    vector<int> xxx
    {
        1, 5, 2, 6, 10, 3, 7, 4, 8, 9
    };
 
    cout << f_findMin(xxx)[0] << endl;
    system("pause");
}

if (ar[i] < ar[i+1])
{
//не сработает
}
else
{
//сработает
}

if(count++ && (действующее условие))

#include <iostream>
using namespace std;
 
size_t comparison_count(0);
 
template<typename T>
void biselectional_sort_henry(T ar[], size_t len)
{
    comparison_count = 0;
 
    size_t  left_ind = 0, right_ind = len - 1,
            max_val_ind, min_val_ind;
    T temp_val;
    bool is_even = (len % 2 == 1 ? false : true);   //четная ли длина массива
 
    if (len <= 1)
        return;
 
    do
    {
        if (!is_even)
            min_val_ind = max_val_ind = left_ind;
        else
        {
            ++comparison_count;
            if (ar[left_ind] < ar[left_ind + 1])
            {
                min_val_ind = left_ind;
                max_val_ind = left_ind + 1;
            }
            else
            {
                min_val_ind = left_ind + 1;
                max_val_ind = left_ind;
            }
        }
 
        for (size_t i = left_ind + 1 + is_even; i < right_ind; i += 2)
        {
            ++comparison_count;
            if (ar[i] > ar[i + 1])
            {
                ++comparison_count;
                if (ar[max_val_ind] < ar[i])
                    max_val_ind = i;
 
                ++comparison_count;
                if (ar[min_val_ind] > ar[i + 1])
                    min_val_ind = i + 1;
            }
            else
            {
                ++comparison_count;
                if (ar[max_val_ind] < ar[i + 1])
                    max_val_ind = i + 1;
                
                ++comparison_count;
                if (ar[min_val_ind] > ar[i])
                    min_val_ind = i;
            }
        }
 
        if (max_val_ind == left_ind)
            max_val_ind = min_val_ind;
 
        temp_val = ar[left_ind];
        ar[left_ind++] = ar[min_val_ind];
        ar[min_val_ind] = temp_val;
 
 
        temp_val = ar[right_ind];
        ar[right_ind--] = ar[max_val_ind];
        ar[max_val_ind] = temp_val;
 
    } while (left_ind < right_ind);
}
 
template<typename T>
void biselectional_sort(T* ar, size_t len)
{
    size_t left_ind = 0, right_ind = len - 1;
    size_t  min_val_ind, max_val_ind;
    comparison_count = 0;
 
    int temp_int;
 
    if (len>1)
        do
        {
            min_val_ind = max_val_ind = left_ind;
 
            for (size_t i = left_ind + 1; i <= right_ind; ++i)
            {
                comparison_count++;
                if (ar[max_val_ind]<ar[i])
                {
                    max_val_ind = i;
                    continue;
                }
                
                comparison_count++;
                if (ar[min_val_ind]>ar[i])
                {   
                    min_val_ind = i;
                    continue;
                }
            }
 
            if (max_val_ind == left_ind)
                max_val_ind = min_val_ind;
 
            temp_int = ar[left_ind];
            ar[left_ind++] = ar[min_val_ind];
            ar[min_val_ind] = temp_int;
 
            temp_int = ar[right_ind];
            ar[right_ind--] = ar[max_val_ind];
            ar[max_val_ind] = temp_int;
        } while (left_ind<right_ind);
}
 
int main(int argc, char* argv[])
{
    int ar[] =
    {
        2, 1, 5, 3, 7, 4, 8, 11, 90, 9
    };
    int ar_copy[] =
    {
        2, 1, 5, 3, 7, 4, 8, 11, 90, 9
    };
    size_t len = sizeof(ar) / sizeof(ar[0]);
    biselectional_sort_henry(ar, len);
    cout << "The array with size of " << len << " was sorted with " << comparison_count << " comparisons\n";
    for (size_t i = 0; i<len; ++i)cout << ar[i] << " ";
    cout << endl;
 
    biselectional_sort(ar_copy, len);
    cout << "The array with size of " << len << " was sorted with " << comparison_count << " comparisons\n";
    for (size_t i = 0; i<len; ++i)cout << ar_copy[i] << " ";
    cout << endl;
    system("pause");
 
    return 0;
}

double gM(double *A, int N) {
    int M=N/2,X,Y;
    return(N==1?A[0]:N==2?A[A[0]>A[1]]:(X=gM(A,M))<(Y=gM(A+M,N-M))?X:Y);
}

int min = arr[0];
int size = sizeof(arr)/sizeof(arr[0]);
for(int i = 1; i<size; i++)
if(arr[i]<min)
min=arr[i];

int min = min(arr[0],arr[1]);
int max = max(arr[0],arr[1]);
int size = sizeof(arr)/sizeof(arr[0]);
for(int i = 2; i<size; i++)
   if(arr[i]<min)
   min=arr[i];
   else if (arr[i]>max)
    max=arr[i];