# Find maximum depth of nested parenthesis in a string

• Difficulty Level : Medium
• Last Updated : 31 Mar, 2021

We are given a string having parenthesis like below
“( ((X)) (((Y))) )”
We need to find the maximum depth of balanced parenthesis, like 4 in the above example. Since ‘Y’ is surrounded by 4 balanced parentheses.
If parenthesis is unbalanced then return -1.

Examples :

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

```Input : S = "( a(b) (c) (d(e(f)g)h) I (j(k)l)m)";
Output : 4

Input : S = "( p((q)) ((s)t) )";
Output : 3

Input : S = "";
Output : 0

Input : S = "b) (c) ()";
Output : -1

Input : S = "(b) ((c) ()"
Output : -1 ```

Method 1 (Uses Stack)
A simple solution is to use a stack that keeps track of current open brackets.

```1) Create a stack.
2) Traverse the string, do following for every character
a) If current character is ‘(’ push it to the stack .
b) If character is ‘)’, pop an element.
c) Maintain maximum count during the traversal. ```

Time Complexity : O(n)
Auxiliary Space : O(n)

Method 2 ( O(1) auxiliary space )
This can also be done without using stack.

```1) Take two variables max and current_max, initialize both of them as 0.
2) Traverse the string, do following for every character
a) If current character is ‘(’, increment current_max and
update max value if required.
b) If character is ‘)’. Check if current_max is positive or
not (this condition ensure that parenthesis are balanced).
If positive that means we previously had a ‘(’ character
so decrement current_max without worry.
If not positive then the parenthesis are not balanced.
Thus return -1.
3) If current_max is not 0, then return -1 to ensure that the parenthesis
are balanced. Else return max```

Below is the implementation of the above algorithm.

## C++

 `// A C++ program to find the maximum depth of nested``// parenthesis in a given expression``#include ``using` `namespace` `std;` `// function takes a string and returns the``// maximum depth nested parenthesis``int` `maxDepth(string S)``{``    ``int` `current_max = 0; ``// current count``    ``int` `max = 0; ``// overall maximum count``    ``int` `n = S.length();` `    ``// Traverse the input string``    ``for` `(``int` `i = 0; i < n; i++)``    ``{``        ``if` `(S[i] == ``'('``)``        ``{``            ``current_max++;` `            ``// update max if required``            ``if` `(current_max > max)``                ``max = current_max;``        ``}``        ``else` `if` `(S[i] == ``')'``)``        ``{``            ``if` `(current_max > 0)``                ``current_max--;``            ``else``                ``return` `-1;``        ``}``    ``}` `    ``// finally check for unbalanced string``    ``if` `(current_max != 0)``        ``return` `-1;` `    ``return` `max;``}` `// Driver program``int` `main()``{``    ``string s = ``"( ((X)) (((Y))) )"``;``    ``cout << maxDepth(s);``    ``return` `0;``}`

## Java

 `//Java program to find the maximum depth of nested``// parenthesis in a given expression` `class` `GFG {``// function takes a string and returns the``// maximum depth nested parenthesis` `    ``static` `int` `maxDepth(String S) {``        ``int` `current_max = ``0``; ``// current count``        ``int` `max = ``0``; ``// overall maximum count``        ``int` `n = S.length();` `        ``// Traverse the input string``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``if` `(S.charAt(i) == ``'('``) {``                ``current_max++;` `                ``// update max if required``                ``if` `(current_max > max) {``                    ``max = current_max;``                ``}``            ``} ``else` `if` `(S.charAt(i) == ``')'``) {``                ``if` `(current_max > ``0``) {``                    ``current_max--;``                ``} ``else` `{``                    ``return` `-``1``;``                ``}``            ``}``        ``}` `        ``// finally check for unbalanced string``        ``if` `(current_max != ``0``) {``            ``return` `-``1``;``        ``}` `        ``return` `max;``    ``}` `// Driver program``    ``public` `static` `void` `main(String[] args) {``        ``String s = ``"( ((X)) (((Y))) )"``;``        ``System.out.println(maxDepth(s));``    ``}``}`

## Python

 `# A Python program to find the maximum depth of nested``# parenthesis in a given expression` `# function takes a string and returns the``# maximum depth nested parenthesis``def` `maxDepth(S):``    ``current_max ``=` `0``    ``max` `=` `0``    ``n ``=` `len``(S)` `    ``# Traverse the input string``    ``for` `i ``in` `range``(n):``        ``if` `S[i] ``=``=` `'('``:``            ``current_max ``+``=` `1` `            ``if` `current_max > ``max``:``                ``max` `=` `current_max``        ``elif` `S[i] ``=``=` `')'``:``            ``if` `current_max > ``0``:``                ``current_max ``-``=` `1``            ``else``:``                ``return` `-``1` `    ``# finally check for unbalanced string``    ``if` `current_max !``=` `0``:``        ``return` `-``1` `    ``return` `max` `# Driver program``s ``=` `"( ((X)) (((Y))) )"``print` `(maxDepth(s))` `# This code is contributed by BHAVYA JAIN`

## C#

 `// C# program to find the``// maximum depth of nested``// parenthesis in a given expression``using` `System;``class` `GFG {``  ` `// function takes a string``// and returns the maximum``// depth nested parenthesis` `static` `int` `maxDepth(``string` `S)``{``  ``// current count``  ``int` `current_max = 0;``  ` `  ``// overall maximum count``  ``int` `max = 0;``  ` `  ``int` `n = S.Length;` `  ``// Traverse the input string``  ``for` `(``int` `i = 0; i < n; i++)``  ``{``    ``if` `(S[i] == ``'('``)``    ``{``      ``current_max++;` `      ``// update max if required``      ``if` `(current_max > max)``      ``{``        ``max = current_max;``      ``}``    ``}``    ``else` `if` `(S[i] == ``')'``)``    ``{``      ``if` `(current_max > 0)``      ``{``        ``current_max--;``      ``}``      ``else``      ``{``        ``return` `-1;``      ``}``    ``}``  ``}` `  ``// finally check for unbalanced string``  ``if` `(current_max != 0)``  ``{``    ``return` `-1;``  ``}` `  ``return` `max;``}` `// Driver program``public` `static` `void` `Main()``{``  ``string` `s = ``"(((X)) (((Y))))"``;``  ``Console.Write(maxDepth(s));``}``}` `// This code is contributed by Chitranayal`

## PHP

 ` ``\$max``)``                ``\$max` `= ``\$current_max``;``        ``}``        ` `        ``else` `if` `(``\$S``[``\$i``] == ``')'``)``        ``{``            ``if` `(``\$current_max``>0)``                ``\$current_max``--;``            ``else``                ``return` `-1;``        ``}``    ``}` `    ``// finally check for``    ``// unbalanced string``    ``if` `(``\$current_max` `!= 0)``        ``return` `-1;` `    ``return` `\$max``;``}` `// Driver Code``\$s` `= ``"( ((X)) (((Y))) )"``;``echo` `maxDepth(``\$s``);` `// This code is contributed by mits``?>`

## Javascript

 ``

Output :

` 4 `

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