Рекурсия: поиск второго максимального числа из заданного набора целых чисел

#include "stdafx.h"
#include <iostream>
 
using std::cout;
using namespace std;
 
auto main(int argc, char * argv[]) -> int
{
    extern auto maxrec(int * , size_t const) -> int;
    size_t const ARRSIZE {5};
    int array[ARRSIZE] {5, 8, 7, 9, 3};
    cout << maxrec(array, ARRSIZE) << '\n';
        
    system("pause");
    return EXIT_SUCCESS;
}
 
 
auto maxrec(int * arr, size_t const arrSize) -> int
{
    switch (arrSize)
    {
        case 2:
            return arr[0] < arr[1] ? arr[0] : arr[1];
        case 3:
            if (arr[0] <= arr[1] && arr[0] <= arr[2])
                return arr[1] < arr[2] ? arr[1] : arr[2];
            else if (arr[1] <= arr[0] && arr[1] <= arr[2])
                return arr[0] < arr[2] ? arr[0] : arr[2];
            else
                return arr[0] < arr[1] ? arr[0] : arr[1];
        default:
            if (arr[0] <= arr[1] && arr[0] <= arr[2])
                ;
            else if (arr[1] <= arr[0] && arr[1] <= arr[2])
                arr[1] = arr[0];
            else
                arr[2] = arr[0];
            return maxrec(arr + 1, arrSize - 1);        
    }
}

#include <iostream>
#include <algorithm>
#include <climits>
 
int n;
int* arr = nullptr;
int* parr = nullptr;
int res[2] = {INT_MIN, INT_MIN};
 
int main()
{
    if (nullptr == parr)
    {
        std::cout << "n = ";
        std::cin >> n;
        arr = new int[n];
        parr = arr;
        for (int i = 0; i < n; ++i)
        {
            std::cin >> arr[i];
        }
        if (n >= 2)
        {
            main();
        }
    }
    else if (arr + n == parr)
    {
        auto imm = std::minmax_element(res, res + 2);
        if (*imm.first != *imm.second)
        {
            std::cout << "Result: " << std::min(*imm.first, *imm.second) << std::endl;
        }
        else
        {
            std::cout << "nf\n";
        }
        delete[] arr;
        arr = nullptr;
        parr = nullptr;
    }
    else
    {
        auto imin = std::min_element(res, res + 2);
        if (*parr > *imin)
        {
            *imin = *parr;
        }
        ++parr;
        main();
    }
        
    return 0;
 
 
}

#include <iostream>
#include <vector>
#include <algorithm>
 
int Rmax(std::vector<int> a, int n, int size) {
    if (size == 2) {
        if (a[0] == n || a[1] == n)
            return std::min(a[0], a[1]);
        else return std::max(a[0], a[1]);
    }
    else if (a[size - 1] != n)
        return std::max(a[size - 1], Rmax(a, n, size - 1));
    else
        return Rmax(a, n, size - 1);
}
 
int main()
{
    std::size_t n; std::cin >> n;
    std::vector<int> a(n);
    for (std::size_t i = 0; i < n; i++)
        std::cin >> a[i];
    std::vector<int>::iterator max_iterator = std::max_element(a.begin(), a.end());
    std::cout << Rmax(a, a[std::distance(a.begin(), max_iterator)], a.size()) << "\n";
    system("pause");
}

int second_max_element(int array[], int size, int _first = 0, int _second = 0) {
    if (size == 0) {
        return _second;
    }
    else {
        --size;
        if (array[size] > _first) {
            return second_max_element(array, size, array[size], _first);
        }
        else if (array[size] > _second) {
            return second_max_element(array, size, _first, array[size]);
        }
        else {
            return second_max_element(array, size, _first, _second);
        }
    }
}

else if (array[size] > _second && array[size] != _first) {