Encuentre los elementos máximos en la primera y la segunda mitad de la array

, Dada una array arr[] de N enteros. La tarea es encontrar los elementos más grandes en la primera mitad y la segunda mitad de la array. Tenga en cuenta que si el tamaño de la array es impar, el elemento central se incluirá en ambas mitades.
Ejemplos: 

Entrada: arr[] = {1, 12, 14, 5} 
Salida: 12, 14 
La primera mitad es {1, 12} y la segunda mitad es {14, 5}.
Entrada: arr[] = {1, 2, 3, 4, 5} 
Salida: 3, 5 

Enfoque: Calcule el índice medio de la array como mid = N / 2 . Ahora los elementos de la primera mitad estarán presentes en el subarreglo arr[0…mid-1] y arr[mid…N-1] si N es par . 
Si N es impar , las mitades son arr[0…mid] y arr[mid…N-1]
A continuación se muestra la implementación del enfoque anterior: 

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function to print largest element in
// first half and second half of an array
void findMax(int arr[], int n)
{
 
    // To store the maximum element
    // in the first half
    int maxFirst = INT_MIN;
 
    // Middle index of the array
    int mid = n / 2;
 
    // Calculate the maximum element
    // in the first half
    for (int i = 0; i < mid; i++)
        maxFirst = max(maxFirst, arr[i]);
 
    // If the size of array is odd then
    // the middle element will be included
    // in both the halves
    if (n % 2 == 1)
        maxFirst = max(maxFirst, arr[mid]);
 
    // To store the maximum element
    // in the second half
    int maxSecond = INT_MIN;
 
    // Calculate the maximum element
    // int the second half
    for (int i = mid; i < n; i++)
        maxSecond = max(maxSecond, arr[i]);
 
    // Print the found maximums
    cout << maxFirst << ", " << maxSecond;
}
 
// Driver code
int main()
{
    int arr[] = { 1, 12, 14, 5 };
    int n = sizeof(arr) / sizeof(arr[0]);
 
    findMax(arr, n);
 
    return 0;
}

// Java implementation of the approach
import java.io.*;
 
class GFG
{
    static void findMax(int []arr, int n)
    {
     
        // To store the maximum element
        // in the first half
        int maxFirst = Integer.MIN_VALUE;
     
        // Middle index of the array
        int mid = n / 2;
     
        // Calculate the maximum element
        // in the first half
        for (int i = 0; i < mid; i++)
        {
            maxFirst = Math.max(maxFirst, arr[i]);
        }
     
        // If the size of array is odd then
        // the middle element will be included
        // in both the halves
        if (n % 2 == 1)
        {
            maxFirst = Math.max(maxFirst, arr[mid]);
        }
         
        // To store the maximum element
        // in the second half
        int maxSecond = Integer.MIN_VALUE;
     
        // Calculate the maximum element
        // int the second half
        for (int i = mid; i < n; i++)
        {
            maxSecond = Math.max(maxSecond, arr[i]);
        }
         
        // Print the found maximums
        System.out.print(maxFirst + ", " + maxSecond);
        // cout << maxFirst << ", " << maxSecond;
    }
     
    // Driver Code
    public static void main(String[] args)
    {
        int []arr = { 1, 12, 14, 5 };
        int n = arr.length;
     
        findMax(arr, n);
    }
}
 
// This code is contributed by anuj_67..

# Python3 implementation of the approach
import sys
 
# Function to print largest element in
# first half and second half of an array
def findMax(arr, n) :
 
    # To store the maximum element
    # in the first half
    maxFirst = -sys.maxsize - 1
 
    # Middle index of the array
    mid = n // 2;
 
    # Calculate the maximum element
    # in the first half
    for i in range(0, mid):
        maxFirst = max(maxFirst, arr[i])
 
    # If the size of array is odd then
    # the middle element will be included
    # in both the halves
    if (n % 2 == 1):
        maxFirst = max(maxFirst, arr[mid])
 
    # To store the maximum element
    # in the second half
    maxSecond = -sys.maxsize - 1
 
    # Calculate the maximum element
    # int the second half
    for i in range(mid, n):
        maxSecond = max(maxSecond, arr[i])
 
    # Print the found maximums
    print(maxFirst, ",", maxSecond)
 
# Driver code
arr = [1, 12, 14, 5 ]
n = len(arr)
 
findMax(arr, n)
 
# This code is contributed by ihritik

// C# implementation of the approach
using System;
 
class GFG
{
    static void findMax(int []arr, int n)
    {
     
        // To store the maximum element
        // in the first half
        int maxFirst = int.MinValue;
     
        // Middle index of the array
        int mid = n / 2;
     
        // Calculate the maximum element
        // in the first half
        for (int i = 0; i < mid; i++)
        {
            maxFirst = Math.Max(maxFirst, arr[i]);
        }
     
        // If the size of array is odd then
        // the middle element will be included
        // in both the halves
        if (n % 2 == 1)
        {
            maxFirst = Math.Max(maxFirst, arr[mid]);
        }
         
        // To store the maximum element
        // in the second half
        int maxSecond = int.MinValue;
     
        // Calculate the maximum element
        // int the second half
        for (int i = mid; i < n; i++)
        {
            maxSecond = Math.Max(maxSecond, arr[i]);
        }
         
        // Print the found maximums
        Console.WriteLine(maxFirst + ", " + maxSecond);
        // cout << maxFirst << ", " << maxSecond;
    }
     
    // Driver Code
    public static void Main()
    {
        int []arr = { 1, 12, 14, 5 };
        int n = arr.Length;
     
        findMax(arr, n);
    }
}
 
// This code is contributed by nidhiva

// javascript implementation of the approach
    function findMax(arr, n)
    {
      
        // To store the maximum element
        // in the first half
         
        var maxFirst = Number.MIN_VALUE
      
        // Middle index of the array
        var mid = n / 2;
      
        // Calculate the maximum element
        // in the first half
        for (var i = 0; i < mid; i++)
        {
            maxFirst = Math.max(maxFirst, arr[i]);
        }
      
        // If the size of array is odd then
        // the middle element will be included
        // in both the halves
        if (n % 2 == 1)
        {
            maxFirst = Math.max(maxFirst, arr[mid]);
        }
          
        // To store the maximum element
        // in the second half
        var maxSecond = Number.MIN_VALUE
      
        // Calculate the maximum element
        // int the second half
        for (var i = mid; i < n; i++)
        {
            maxSecond = Math.max(maxSecond, arr[i]);
        }
          
        // Print the found maximums
        document.write(maxFirst + ", " + maxSecond);
    }
      
    // Driver Code
        var arr = [ 1, 12, 14, 5 ];
        var n = arr.length;
      
        findMax(arr, n);
 
 // This code is contributed by bunnyram19.

12, 14

Complejidad de tiempo: O(n), ya que el ciclo va de 0 a (media – 1), y luego de media a (n – 1).

Espacio Auxiliar: O(1), ya que no se ha ocupado ningún espacio extra.