Skip to content
Related Articles

Related Articles

Improve Article
Save Article
Like Article

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

  • Last Updated : 17 Sep, 2020

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:

We provide nothing but the best curated videos and practice problems for our students. Check out the C Foundation Course and master the C language from basic to advanced level. Wait no more, start learning today!

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
Output: 
20







 

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




My Personal Notes arrow_drop_up
Recommended Articles
Page :

Start Your Coding Journey Now!