Program to find largest element in an array using Dynamic Memory Allocation

Given an array arr[] consisting of N integers, the task is to find the largest element in the given array using Dynamic Memory Allocation.

Examples:

Input: arr[] = {4, 5, 6, 7} 
Output: 7
Explanation:
The largest element present in the given array is 7.

Input: arr[] = {8, 9, 10, 12} 
Output: 12
Explanation:
The largest element present in the given array is 12.

Approach: The idea here is to use Dynamic Memory for searching the largest element in the given array. Follow the steps below to solve the problem:

1. Take N elements and a pointer to store the address of N elements
2. Allocate memory dynamically for N elements.
3. Store the elements in the allocated memory.
4. Traverse the array arr[] to find the largest element among all the numbers by comparing the values using pointers.

Below is the implementation of the above approach:

C

// C program for the above approach
#include <stdio.h>
#include <stdlib.h>

// Function to find the largest element
// using dynamic memory allocation
void findLargest(int* arr, int N)
{
    int i;

    // Traverse the array arr[]
    for (i = 1; i < N; i++) {

        // Update the largest element
        if (*arr < *(arr + i)) {
            *arr = *(arr + i);
        }
    }

    // Print the largest number
    printf("%d ", *arr);
}

// Driver Code
int main()
{
    int i, N = 4;

    int* arr;

    // Memory allocation to arr
    arr = (int*)calloc(N, sizeof(int));

    // Condition for no memory
    // allocation
    if (arr == NULL) {
        printf("No memory allocated");
        exit(0);
    }

    // Store the elements
    *(arr + 0) = 14;
    *(arr + 1) = 12;
    *(arr + 2) = 19;
    *(arr + 3) = 20;

    // Function Call
    findLargest(arr, N);
    return 0;
}

C++

// C++ program for the above approach
#include <iostream>
using namespace std;

// Function to find the largest element
// using dynamic memory allocation
void findLargest(int* arr, int N)
{

    // Traverse the array arr[]
    for (int i = 1; i < N; i++) {

        // Update the largest element
        if (*arr < *(arr + i)) {
            *arr = *(arr + i);
        }
    }

    // Print the largest number
    cout << *arr;
}

// Driver Code
int main()
{
    int N = 4;
    int* arr;

    // Memory allocation to arr
    arr = new int[N];

    // Condition for no memory
    // allocation
    if (arr == NULL) {
        cout << "No memory allocated";
    }

    // Store the elements
    *(arr + 0) = 14;
    *(arr + 1) = 12;
    *(arr + 2) = 19;
    *(arr + 3) = 20;

    // Function Call
    findLargest(arr, N);
    return 0;
}

Java

// Java program for the above approach
import java.util.*;
class GFG{

// Function to find the largest element
// using dynamic memory allocation
static void findLargest(int []arr, int N)
{
    // Traverse the array arr[]
    for (int i = 1; i < N; i++)
    {
        // Update the largest element
        if (arr[0] < (arr[i]))
        {
            arr[0] = (arr[i]);
        }
    }

    // Print the largest number
    System.out.print(arr[0]);
}

// Driver Code
public static void main(String[] args)
{
    int N = 4;
    int []arr;

    // Memory allocation to arr
    arr = new int[N];

    // Condition for no memory
    // allocation
    if (arr.length < N)
    {
        System.out.print("No memory allocated");
    }

    // Store the elements
    arr[0] = 14;
    arr[1] = 12;
    arr[2] = 19;
    arr[3] = 20;

    // Function Call
    findLargest(arr, N);
}
}

// This code is contributed by shikhasingrajput

Python3

# Python3 program for
# the above approach

# Function to find the largest element
# using dynamic memory allocation
def findLargest(arr, N):

    # Traverse the array arr
    for i in range(1, N):

        # Update the largest element
        if (arr[0] < (arr[i])):
            arr[0] = (arr[i]);

    # Print largest number
    print(arr[0]);

# Driver Code
if __name__ == '__main__':
    N = 4;

    # Memory allocation to arr
    arr = [0] * N;

    # Condition for no memory
    # allocation
    if (len(arr) < N):
        print("No memory allocated");

    # Store the elements
    arr[0] = 14;
    arr[1] = 12;
    arr[2] = 19;
    arr[3] = 20;

    # Function Call
    findLargest(arr, N);

# This code is contributed by shikhasingrajput

C#

// C# program for the above approach
using System;
class GFG{

// Function to find the largest
// element using dynamic memory allocation
static void findLargest(int []arr,
                        int N)
{
  // Traverse the array []arr
  for (int i = 1; i < N; i++)
  {
    // Update the largest element
    if (arr[0] < (arr[i]))
    {
      arr[0] = (arr[i]);
    }
  }

  // Print the largest number
  Console.Write(arr[0]);
}

// Driver Code
public static void Main(String[] args)
{
  int N = 4;
  int []arr;

  // Memory allocation to arr
  arr = new int[N];

  // Condition for no memory
  // allocation
  if (arr.Length < N)
  {
    Console.Write("No memory allocated");
  }

  // Store the elements
  arr[0] = 14;
  arr[1] = 12;
  arr[2] = 19;
  arr[3] = 20;

  // Function Call
  findLargest(arr, N);
}
}

// This code is contributed by Rajput-Ji

Javascript

// Javascript program for the above approach

// Function to find the largest element
// using dynamic memory allocation
function findLargest(arr, N)
{

    // Traverse the array arr[]
    for (let i = 1; i < N; i++)
    {

        // Update the largest element
        if (arr[0] < (arr[i])) {
            arr[0] = (arr[i]);
        }
    }

    // Print the largest number
    console.log(arr[0]);
}

// Driver Code

let N = 4;
let arr = [];

// Memory allocation to arr
arr = new Array(N);

// Condition for no memory
// allocation
if (arr.length < N) {
    console.log("No memory allocated");
}

// Store the elements
arr[0] = 14;
arr[1] = 12;
arr[2] = 19;
arr[3] = 20;

// Function Call
findLargest(arr, N);

// This code is contributed by Saurabh Jaiswal

Output:

20

Time Complexity: O(N)
Auxiliary Space: O(1)