Skip to content
geeksforgeeks
  • Courses
    • DSA to Development
    • Get IBM Certification
    • Newly Launched!
      • Master Django Framework
      • Become AWS Certified
    • For Working Professionals
      • Interview 101: DSA & System Design
      • Data Science Training Program
      • JAVA Backend Development (Live)
      • DevOps Engineering (LIVE)
      • Data Structures & Algorithms in Python
    • For Students
      • Placement Preparation Course
      • Data Science (Live)
      • Data Structure & Algorithm-Self Paced (C++/JAVA)
      • Master Competitive Programming (Live)
      • Full Stack Development with React & Node JS (Live)
    • Full Stack Development
    • Data Science Program
    • All Courses
  • Tutorials
    • Data Structures & Algorithms
    • ML & Data Science
    • Interview Corner
    • Programming Languages
    • Web Development
    • CS Subjects
    • DevOps And Linux
    • School Learning
  • Practice
    • Build your AI Agent
    • GfG 160
    • Problem of the Day
    • Practice Coding Problems
    • GfG SDE Sheet
  • Contests
    • Accenture Hackathon (Ending Soon!)
    • GfG Weekly [Rated Contest]
    • Job-A-Thon Hiring Challenge
    • All Contests and Events
  • DSA
  • Interview Questions on Array
  • Practice Array
  • MCQs on Array
  • Tutorial on Array
  • Types of Arrays
  • Array Operations
  • Subarrays, Subsequences, Subsets
  • Reverse Array
  • Static Vs Arrays
  • Array Vs Linked List
  • Array | Range Queries
  • Advantages & Disadvantages
Open In App
Next Article:
Check for Majority Element in a sorted array
Next article icon

Peak Element in Array

Last Updated : 27 Feb, 2025
Comments
Improve
Suggest changes
Like Article
Like
Report
Try it on GfG Practice
redirect icon

Given an array arr[] where no two adjacent elements are same, find the index of a peak element. An element is considered to be a peak element if it is strictly greater than its adjacent elements. If there are multiple peak elements, return the index of any one of them.

Note: Consider the element before the first element and the element after the last element to be negative infinity.

Examples:

Input: arr[] = [1, 2, 4, 5, 7, 8, 3]
Output: 5
Explanation: arr[5] = 8 is a peak element because arr[4] < arr[5] > arr[6].

Input: arr[] = [10, 20, 15, 2, 23, 90, 80]
Output: 1 or 5
Explanation: arr[1] = 20 and arr[5] = 90 are peak elements because arr[0] < arr[1] > arr[2] and arr[4] < arr[5] > arr[6].

Input: arr[] = [1, 2, 3]
Output: 2
Explanation: arr[2] is a peak element because arr[1] < arr[2] and arr[2] is the last element, so it has negative infinity to its right.

Table of Content

  • [Naive Approach] Using Linear Search – O(n) Time and O(1) Space
  • [Expected Approach] Using Binary Search – O(logn) Time and O(1) Space

[Naive Approach] Using Linear Search – O(n) Time and O(1) Space

The simplest approach is to iterate through the array and check if an element is greater than its neighbors. If it is, then it’s a peak element.

C++ 
// C++ program to find a peak element in the given array // Using Linear Search  #include <iostream> #include <vector> using namespace std;  int peakElement(vector<int> &arr) {     int n = arr.size();        for(int i = 0; i < n; i++) {     	bool left = true;         bool right = true;                // Check for element to the left         if(i > 0 && arr[i] <= arr[i - 1])              left = false;                // Check for element to the right         if(i < n - 1 && arr[i] <= arr[i + 1])             right = false;                // If arr[i] is greater than its left as well as         // its right element, return its index         if(left && right) {         	return i;         }     }     return 0; }  int main() {     vector<int> arr = {1, 2, 4, 5, 7, 8, 3};     cout << peakElement(arr);     return 0; }
C 
// C program to find a peak element in the given array // Using Linear Search  #include <stdio.h>  int peakElement(int arr[], int n) {     for (int i = 0; i < n; i++) {         int left = 1;         int right = 1;          // Check for element to the left         if (i > 0 && arr[i] <= arr[i - 1])             left = 0;          // Check for element to the right         if (i < n - 1 && arr[i] <= arr[i + 1])             right = 0;          // If arr[i] is greater than its left as well as         // its right element, return its index         if (left && right) {             return i;         }     }     return 0; }  int main() {     int arr[] = {1, 2, 4, 5, 7, 8, 3};     int n = sizeof(arr) / sizeof(arr[0]);     printf("%d\n", peakElement(arr, n));     return 0; }
Java 
// Java program to find a peak element in the given array // Using Linear Search  import java.util.*; class GfG {     static int peakElement(int[] arr) {         int n = arr.length;          for (int i = 0; i < n; i++) {             boolean left = true;             boolean right = true;              // Check for element to the left             if (i > 0 && arr[i] <= arr[i - 1])                 left = false;              // Check for element to the right             if (i < n - 1 && arr[i] <= arr[i + 1])                 right = false;              // If arr[i] is greater than its left as well as             // its right element, return its index             if (left && right) {                 return i;             }         }         return 0;     }      public static void main(String[] args) {         int[] arr = {1, 2, 4, 5, 7, 8, 3};         System.out.println(peakElement(arr));     } }
Python 
# Python program to find a peak element in the given array # Using Linear Search  def peakElement(arr):     n = len(arr)      for i in range(n):         left = True         right = True          # Check for element to the left         if i > 0 and arr[i] <= arr[i - 1]:             left = False          # Check for element to the right         if i < n - 1 and arr[i] <= arr[i + 1]:             right = False          # If arr[i] is greater than its left as well as         # its right element, return its index         if left and right:             return i  if __name__ == "__main__": 	arr = [1, 2, 4, 5, 7, 8, 3] 	print(peakElement(arr))
C# 
// C# program to find a peak element in the given array // Using Linear Search  using System; class GfG {     static int peakElement(int[] arr) {         int n = arr.Length;          for (int i = 0; i < n; i++) {             bool left = true;             bool right = true;              // Check for element to the left             if (i > 0 && arr[i] <= arr[i - 1])                 left = false;              // Check for element to the right             if (i < n - 1 && arr[i] <= arr[i + 1])                 right = false;              // If arr[i] is greater than its left as well as             // its right element, return its index             if (left && right) {                 return i;             }         }         return 0;     }      static void Main() {         int[] arr = { 1, 2, 4, 5, 7, 8, 3 };         Console.WriteLine(peakElement(arr));     } }
JavaScript 
// JavaScript program to find a peak element in the given // array Using Linear Search  function peakElement(arr) {     let n = arr.length;      for (let i = 0; i < n; i++) {         let left = true;         let right = true;          // Check for element to the left         if (i > 0 && arr[i] <= arr[i - 1])              left = false;          // Check for element to the right         if (i < n - 1 && arr[i] <= arr[i + 1])              right = false;          // If arr[i] is greater than its left as well as         // its right element, return its index         if (left && right) {             return i;         }     } }  // Driver Code let arr = [1, 2, 4, 5, 7, 8, 3]; console.log(peakElement(arr));

Output
5

[Expected Approach] Using Binary Search – O(logn) Time and O(1) Space

If we observe carefully, we can say that:

  • If an element is smaller than it’s next element then it is guaranteed that at least one peak element will exist on the right side of this element.
  • Conversely if an element is smaller than it’s previous element then it is guaranteed that at least one peak element will exist on the left side of this element.

Therefore, we can use binary search to find the peak element.

Why it is guaranteed that peak element will definitely exist on the right side of an element, if its next element is greater than it?

If we keep moving in the right side of this element, as long as the elements are increasing, we will eventually reach an element that is either:

  • The last element of the array, which will be a peak as it is greater than or equal to its previous element.
  • An element where the sequence is no longer increasing, i.e., arr[i] > arr[i + 1], which would be a peak element.

For the same reasons, if an element is lesser than its previous element, then it is guaranteed that at least one peak element will exist on the left side of that element.


C++ 
// C++ program to find a peak element in the given array // Using Binary Search  #include <iostream> #include <vector> using namespace std;  int peakElement(vector<int> &arr) {     int n = arr.size();        // If there is only one element, then it's a peak     if (n == 1)          return 0;              // Check if the first element is a peak     if (arr[0] > arr[1])         return 0;              // Check if the last element is a peak     if (arr[n - 1] > arr[n - 2])         return n - 1;          // Search Space for binary Search     int lo = 1, hi = n - 2;          while(lo <= hi) {         int mid = lo + (hi - lo)/2;                  // If the element at mid is a           // peak element return  mid         if(arr[mid] > arr[mid - 1]                         && arr[mid] > arr[mid + 1])             return mid;                  // If next neighbor is greater, then peak         // element will exist in the right subarray         if(arr[mid] < arr[mid + 1])             lo = mid + 1;                      // Otherwise, it will exist in left subarray         else             hi = mid - 1;     }          return 0; }  int main() {     vector<int> arr = {1, 2, 4, 5, 7, 8, 3};     cout << peakElement(arr);     return 0; }
C 
// C program to find a peak element in the given array // Using Binary Search  #include <stdio.h>  int peakElement(int arr[], int n) {          // If there is only one element, then it's a peak     if (n == 1)         return 0;      // Check if the first element is a peak     if (arr[0] > arr[1])         return 0;      // Check if the last element is a peak     if (arr[n - 1] > arr[n - 2])         return n - 1;      // Search Space for binary Search     int lo = 1, hi = n - 2;      while (lo <= hi) {         int mid = lo + (hi - lo) / 2;          // If the element at mid is a           // peak element return mid         if (arr[mid] > arr[mid - 1] && arr[mid] > arr[mid + 1])             return mid;          // If next neighbor is greater, then peak         // element will exist in the right subarray         if (arr[mid] < arr[mid + 1])             lo = mid + 1;          // Otherwise, it will exist in left subarray         else             hi = mid - 1;     }      return 0; }  int main() {     int arr[] = {1, 2, 4, 5, 7, 8, 3};     int n = sizeof(arr) / sizeof(arr[0]);     printf("%d\n", peakElement(arr, n));     return 0; }
Java 
// Java program to find a peak element in the given array // Using Binary Search  class GfG {      static int peakElement(int[] arr) {         int n = arr.length;          // If there is only one element, then it's a peak         if (n == 1)             return 0;          // Check if the first element is a peak         if (arr[0] > arr[1])             return 0;          // Check if the last element is a peak         if (arr[n - 1] > arr[n - 2])             return n - 1;          // Search Space for binary Search         int lo = 1, hi = n - 2;          while (lo <= hi) {             int mid = lo + (hi - lo) / 2;              // If the element at mid is a               // peak element return mid             if (arr[mid] > arr[mid - 1] && arr[mid] > arr[mid + 1])                 return mid;              // If next neighbor is greater, then peak             // element will exist in the right subarray             if (arr[mid] < arr[mid + 1])                 lo = mid + 1;              // Otherwise, it will exist in left subarray             else                 hi = mid - 1;         }          return 0;     }      public static void main(String[] args) {         int[] arr = {1, 2, 4, 5, 7, 8, 3};         System.out.println(peakElement(arr));     } }
Python 
# Python program to find a peak element in the given array # Using Binary Search  def peakElement(arr):     n = len(arr)      # If there is only one element, then it's a peak     if n == 1:         return 0      # Check if the first element is a peak     if arr[0] > arr[1]:         return 0      # Check if the last element is a peak     if arr[n - 1] > arr[n - 2]:         return n - 1      # Search Space for binary Search     lo, hi = 1, n - 2      while lo <= hi:         mid = lo + (hi - lo) // 2          # If the element at mid is a           # peak element return mid         if arr[mid] > arr[mid - 1] and arr[mid] > arr[mid + 1]:             return mid          # If next neighbor is greater, then peak         # element will exist in the right subarray         if arr[mid] < arr[mid + 1]:             lo = mid + 1          # Otherwise, it will exist in left subarray         else:             hi = mid - 1   if __name__ == "__main__":     arr = [1, 2, 4, 5, 7, 8, 3]     print(peakElement(arr))
C# 
// C# program to find a peak element in the given array // Using Binary Search  using System;  class GfG {     static int peakElement(int[] arr) {         int n = arr.Length;          // If there is only one element, then it's a peak         if (n == 1)             return 0;          // Check if the first element is a peak         if (arr[0] > arr[1])             return 0;          // Check if the last element is a peak         if (arr[n - 1] > arr[n - 2])             return n - 1;          // Search Space for binary Search         int lo = 1, hi = n - 2;          while (lo <= hi) {             int mid = lo + (hi - lo) / 2;              // If the element at mid is a               // peak element return mid             if (arr[mid] > arr[mid - 1] && arr[mid] > arr[mid + 1])                 return mid;              // If next neighbor is greater, then peak             // element will exist in the right subarray             if (arr[mid] < arr[mid + 1])                 lo = mid + 1;              // Otherwise, it will exist in left subarray             else                 hi = mid - 1;         }          return 0;     }      static void Main() {         int[] arr = {1, 2, 4, 5, 7, 8, 3};         Console.WriteLine(peakElement(arr));     } }
JavaScript 
// JavaScript program to find a peak element in the given // array Using Binary Search  function peakElement(arr) {     let n = arr.length;      // If there is only one element, then it's a peak     if (n === 1)         return 0;      // Check if the first element is a peak     if (arr[0] > arr[1])         return 0;      // Check if the last element is a peak     if (arr[n - 1] > arr[n - 2])         return n - 1;      // Search Space for binary Search     let lo = 1, hi = n - 2;      while (lo <= hi) {         let mid = lo + Math.floor((hi - lo) / 2);          // If the element at mid is a         // peak element return mid         if (arr[mid] > arr[mid - 1]             && arr[mid] > arr[mid + 1])             return mid;          // If next neighbor is greater, then peak         // element will exist in the right subarray         if (arr[mid] < arr[mid + 1])             lo = mid + 1;          // Otherwise, it will exist in left subarray         else             hi = mid - 1;     }      return 0; }  // Driver Code const arr = [ 1, 2, 4, 5, 7, 8, 3 ]; console.log(peakElement(arr));

Output
5

Related Articles:

  • Find local minima in an array


Next Article
Check for Majority Element in a sorted array
author
kartik
Improve
Article Tags :
  • Arrays
  • Divide and Conquer
  • DSA
  • Searching
  • Adobe
  • Amazon
  • Visa
Practice Tags :
  • Adobe
  • Amazon
  • Visa
  • Arrays
  • Divide and Conquer
  • Searching

Similar Reads

  • Divide and Conquer Algorithm
    Divide and Conquer algorithm is a problem-solving strategy that involves. Divide : Break the given problem into smaller non-overlapping problems.Conquer : Solve Smaller ProblemsCombine : Use the Solutions of Smaller Problems to find the overall result.Examples of Divide and Conquer are Merge Sort, Q
    1 min read
  • Introduction to Divide and Conquer Algorithm
    Divide and Conquer Algorithm is a problem-solving technique used to solve problems by dividing the main problem into subproblems, solving them individually and then merging them to find solution to the original problem. Divide and Conquer is mainly useful when we divide a problem into independent su
    9 min read
  • Dynamic Programming vs Divide-and-Conquer
    In this article I’m trying to explain the difference/similarities between dynamic programming and divide and conquer approaches based on two examples: binary search and minimum edit distance (Levenshtein distance).The ProblemWhen I started to learn algorithms it was hard for me to understand the mai
    12 min read
  • Decrease and Conquer
    As divide-and-conquer approach is already discussed, which include following steps: Divide the problem into a number of subproblems that are smaller instances of the same problem. Conquer the sub problems by solving them recursively. If the subproblem sizes are small enough, however, just solve the
    5 min read
  • Advanced master theorem for divide and conquer recurrences
    The Master Theorem is a tool used to solve recurrence relations that arise in the analysis of divide-and-conquer algorithms. The Master Theorem provides a systematic way of solving recurrence relations of the form: T(n) = aT(n/b) + f(n) where a, b, and f(n) are positive functions and n is the size o
    5 min read

    • Some standard Divide and Conquer Algorithms

    • Write program to calculate pow(b, e)
      Given two numbers b and e, the task is to implement a function to compute b^e. Examples: Input: b = 3.00000, e = 5Output: 243.00000 Input: b = 0.55000, e = 3Output: 0.16638 Input: b = -0.67000, e = -7Output: -16.49971 Table of Content [Naive Approach 1] Using Iteration - O(e) Time and O(1) Space[Nai
      10 min read
    • Karatsuba algorithm for fast multiplication using Divide and Conquer algorithm
      Given two binary strings that represent value of two integers, find the product of two strings. For example, if the first bit string is "1100" and second bit string is "1010", output should be 120. For simplicity, let the length of two strings be same and be n. A Naive Approach is to follow the proc
      15+ min read
    • Strassen's Matrix Multiplication
      Given two square matrices arr[][] and brr[][] of order n * n. Your task is to multiply both the matrices and find the resultant matrix. Examples: Input: arr[][] = [ [7, 8], [2, 9] ]brr[][] = [ [14, 5], [5, 18] ]Output: [ [138, 179], [73, 172] ] Input: arr[][] = [ [17, 4], [17, 16] ]brr[][] = [ [9, 2
      15+ min read
    • Convex Hull using Divide and Conquer Algorithm
      In computational geometry, a convex hull is the smallest convex polygon that contains a given set of points. It is a fundamental concept with applications in various fields such as computer graphics, robotics, and image processing. Importance of Convex Hull:Convex hulls are important in computationa
      15 min read
    • Quickhull Algorithm for Convex Hull
      Given a set of points, a Convex hull is the smallest convex polygon containing all the given points. Input : points[] = {{0, 3}, {1, 1}, {2, 2}, {4, 4}, {0, 0}, {1, 2}, {3, 1}, {3, 3}};Output : The points in convex hull are: (0, 0) (0, 3) (3, 1) (4, 4)Input : points[] = {{0, 3}, {1, 1}Output : Not P
      14 min read

    Binary Search based problems

    • Peak Element in Array
      Given an array arr[] where no two adjacent elements are same, find the index of a peak element. An element is considered to be a peak element if it is strictly greater than its adjacent elements. If there are multiple peak elements, return the index of any one of them. Note: Consider the element bef
      13 min read
    • Check for Majority Element in a sorted array
      Given an array arr of N elements, A majority element in an array arr of size N is an element that appears more than N/2 times in the array. The task is to write a function say isMajority() that takes an array (arr[] ), array’s size (n) and a number to be searched (x) as parameters and returns true i
      15+ min read
    • K-th Element of Merged Two Sorted Arrays
      Given two sorted arrays of sizes m and n respectively, the task is to find the element that would be at the k-th position in the final sorted array formed by merging these two arrays. Examples: Input: a[] = [2, 3, 6, 7, 9], b[] = [1, 4, 8, 10], k = 5Output: 6Explanation: The final sorted array is [1
      15+ min read
    • Find the number of zeroes
      Given an array of 1s and 0s which has all 1s first followed by all 0s. Find the number of 0s. Count the number of zeroes in the given array.Examples : Input: arr[] = {1, 1, 1, 1, 0, 0} Output: 2 Input: arr[] = {1, 0, 0, 0, 0} Output: 4 Input: arr[] = {0, 0, 0} Output: 3 Input: arr[] = {1, 1, 1, 1} O
      12 min read
    • Rotation Count in a Rotated Sorted array
      Given an array arr[] having distinct numbers sorted in increasing order and the array has been right rotated (i.e, the last element will be cyclically shifted to the starting position of the array) k number of times, the task is to find the value of k. Examples: Input: arr[] = {15, 18, 2, 3, 6, 12}O
      13 min read
    • Unbounded Binary Search Example (Find the point where a monotonically increasing function becomes positive first time)
      Given a function 'int f(unsigned int x)' which takes a non-negative integer 'x' as input and returns an integer as output. The function is monotonically increasing with respect to the value of x, i.e., the value of f(x+1) is greater than f(x) for every input x. Find the value 'n' where f() becomes p
      11 min read
    • Median of two Sorted Arrays of Different Sizes
      Given two sorted arrays, a[] and b[], the task is to find the median of these sorted arrays. Assume that the two sorted arrays are merged and then median is selected from the combined array. This is an extension of Median of two sorted arrays of equal size problem. Here we handle arrays of unequal s
      15+ min read
    • The Painter's Partition Problem using Binary Search
      Given an array arr[] and k, where the array represents the boards and each element of the given array represents the length of each board. k numbers of painters are available to paint these boards. Consider that each unit of a board takes 1 unit of time to paint.The task is to find the minimum time
      10 min read

    Some practice problems on Divide and Conquer algorithm

    • Program for Square Root of Integer
      Given a positive integer n, find its square root. If n is not a perfect square, then return floor of √n. Examples : Input: n = 4Output: 2Explanation: The square root of 4 is 2. Input: n = 11Output: 3Explanation: The square root of 11 lies in between 3 and 4 so floor of the square root is 3. Table of
      13 min read
    • Maximum and minimum of an array using minimum number of comparisons
      Given an array of size N. The task is to find the maximum and the minimum element of the array using the minimum number of comparisons. Examples: Input: arr[] = {3, 5, 4, 1, 9}Output: Minimum element is: 1 Maximum element is: 9 Input: arr[] = {22, 14, 8, 17, 35, 3}Output: Minimum element is: 3 Maxim
      15+ min read
    • Find frequency of each element in a limited range array in less than O(n) time
      Given a sorted array arr[] of positive integers, the task is to find the frequency for each element in the array. Assume all elements in the array are less than some constant M Note: Do this without traversing the complete array. i.e. expected time complexity is less than O(n) Examples: Input: arr[]
      10 min read
    • Tiling Problem - L Shaped
      Given an n×n board (where n = 2k and k≥1), with one missing cell, the task is to fill the remaining cells using L-shaped tiles. An L-shaped tile covers 3 cells in a 2x2 grid, with one cell missing. You need to tile the entire board using the L-shaped tiles, ensuring that the missing cell remains unc
      15+ min read
    • Count Inversions of an Array
      Given an integer array arr[] of size n, find the inversion count in the array. Two array elements arr[i] and arr[j] form an inversion if arr[i] > arr[j] and i < j. Note: Inversion Count for an array indicates that how far (or close) the array is from being sorted. If the array is already sorte
      15+ min read
    • The Skyline Problem | Set-1
      Given n rectangular buildings in a 2-dimensional city, compute the skyline of these buildings, eliminating hidden lines. The main task is to view buildings from a side and remove all sections that are not visible. All buildings share a common bottom and every building is represented by a triplet (le
      14 min read
    • Search in a Row-wise and Column-wise Sorted 2D Array using Divide and Conquer algorithm
      Given an n x n matrix, where every row and column is sorted in increasing order. Given a key, how to decide whether this key is in the matrix. Input: x = 62, mat[][] = [[3, 30, 38], [20, 52, 54], [35, 60, 69]]Output: falseExplanation: 62 is not present in the matrix. Input: x = 30, mat[][] = [[3, 30
      7 min read
    • Allocate Minimum Pages
      Given an array arr[] and an integer k, where arr[i] denotes the number of pages of a book and k denotes total number of students. All the books need to be allocated to k students in contiguous manner, with each student getting at least one book. The task is to minimize the maximum number of pages al
      15+ min read
geeksforgeeks-footer-logo
Corporate & Communications Address:
A-143, 7th Floor, Sovereign Corporate Tower, Sector- 136, Noida, Uttar Pradesh (201305)
Registered Address:
K 061, Tower K, Gulshan Vivante Apartment, Sector 137, Noida, Gautam Buddh Nagar, Uttar Pradesh, 201305
GFG App on Play Store GFG App on App Store
Advertise with us
  • Company
  • About Us
  • Legal
  • Privacy Policy
  • In Media
  • Contact Us
  • Advertise with us
  • GFG Corporate Solution
  • Placement Training Program
  • Languages
  • Python
  • Java
  • C++
  • PHP
  • GoLang
  • SQL
  • R Language
  • Android Tutorial
  • Tutorials Archive
  • DSA
  • Data Structures
  • Algorithms
  • DSA for Beginners
  • Basic DSA Problems
  • DSA Roadmap
  • Top 100 DSA Interview Problems
  • DSA Roadmap by Sandeep Jain
  • All Cheat Sheets
  • Data Science & ML
  • Data Science With Python
  • Data Science For Beginner
  • Machine Learning
  • ML Maths
  • Data Visualisation
  • Pandas
  • NumPy
  • NLP
  • Deep Learning
  • Web Technologies
  • HTML
  • CSS
  • JavaScript
  • TypeScript
  • ReactJS
  • NextJS
  • Bootstrap
  • Web Design
  • Python Tutorial
  • Python Programming Examples
  • Python Projects
  • Python Tkinter
  • Python Web Scraping
  • OpenCV Tutorial
  • Python Interview Question
  • Django
  • Computer Science
  • Operating Systems
  • Computer Network
  • Database Management System
  • Software Engineering
  • Digital Logic Design
  • Engineering Maths
  • Software Development
  • Software Testing
  • DevOps
  • Git
  • Linux
  • AWS
  • Docker
  • Kubernetes
  • Azure
  • GCP
  • DevOps Roadmap
  • System Design
  • High Level Design
  • Low Level Design
  • UML Diagrams
  • Interview Guide
  • Design Patterns
  • OOAD
  • System Design Bootcamp
  • Interview Questions
  • Inteview Preparation
  • Competitive Programming
  • Top DS or Algo for CP
  • Company-Wise Recruitment Process
  • Company-Wise Preparation
  • Aptitude Preparation
  • Puzzles
  • School Subjects
  • Mathematics
  • Physics
  • Chemistry
  • Biology
  • Social Science
  • English Grammar
  • Commerce
  • World GK
  • GeeksforGeeks Videos
  • DSA
  • Python
  • Java
  • C++
  • Web Development
  • Data Science
  • CS Subjects
@GeeksforGeeks, Sanchhaya Education Private Limited, All rights reserved
We use cookies to ensure you have the best browsing experience on our website. By using our site, you acknowledge that you have read and understood our Cookie Policy & Privacy Policy
Lightbox
Improvement
Suggest Changes
Help us improve. Share your suggestions to enhance the article. Contribute your expertise and make a difference in the GeeksforGeeks portal.
geeksforgeeks-suggest-icon
Create Improvement
Enhance the article with your expertise. Contribute to the GeeksforGeeks community and help create better learning resources for all.
geeksforgeeks-improvement-icon
Suggest Changes
min 4 words, max Words Limit:1000

Thank You!

Your suggestions are valuable to us.

What kind of Experience do you want to share?

Interview Experiences
Admission Experiences
Career Journeys
Work Experiences
Campus Experiences
Competitive Exam Experiences