 Open in App
Not now

## Related Articles

• Write an Interview Experience
• String Data Structure

# Find maximum depth of nested parenthesis in a string

• Difficulty Level : Medium
• Last Updated : 24 Jun, 2022

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 :

```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
• If current character is ‘(’ push it to the stack .
• If character is ‘)’, pop an element.
• Maintain maximum count during the traversal.

Below is the code implementation of the algorithm.

## C++

 `// A C++ program to find the maximum depth of nested``// parenthesis in a given expression``#include ``using` `namespace` `std;` `int` `maxDepth(string& s)``{``    ``int` `count = 0;``    ``stack<``int``> st;` `    ``for` `(``int` `i = 0; i < s.size(); i++) {``        ``if` `(s[i] == ``'('``)``            ``st.push(i); ``// pushing the bracket in the stack``        ``else` `if` `(s[i] == ``')'``) {``            ``if` `(count < st.size())``                ``count = st.size();``            ``/*keeping track of the parenthesis and storing``            ``it before removing it when it gets balanced*/``            ``st.pop();``        ``}``    ``}``    ``return` `count;``}` `// Driver program``int` `main()``{``    ``string s = ``"( ((X)) (((Y))) )"``;``    ``cout << maxDepth(s);` `    ``// This code is contributed by rakeshsahni` `    ``return` `0;``}`

## Java

 `/*package whatever //do not write package name here */` `import` `java.io.*;``import` `java.util.*;``class` `GFG {``    ``public` `static` `int` `maxDepth(String s) {``        ``int` `count=``0``;``        ``Stack st = ``new` `Stack<>();``        ` `        ``for``(``int` `i=``0``;i

## Python3

 `# Python code to implement the approach`  `def` `maxDepth(s):` `    ``count ``=` `0``    ``st ``=` `[]` `    ``for` `i ``in` `range``(``len``(s)):``        ``if` `(s[i] ``=``=` `'('``):``            ``st.append(i) ``# pushing the bracket in the stack``        ``elif` `(s[i] ``=``=` `')'``):``            ``if` `(count < ``len``(st)):``                ``count ``=` `len``(st)``            ``# keeping track of the parenthesis and storing``            ``# it before removing it when it gets balanced``            ``st.pop()``        ` `    ``return` `count` `# Driver program` `s ``=` `"( ((X)) (((Y))) )"``print``(maxDepth(s))`  `# This code is contributed by shinjanpatra`

## C#

 `//C# program to find the  maximum depth``//of nested parenthesis in a string``using` `System;``using` `System.Collections;` `public` `class` `GFG{``    ` `    ``static` `int` `maxDepth(``string` `s){``        ``int` `count=0;``        ``Stack st = ``new` `Stack();``         ` `        ``for``(``int` `i=0;i

## Javascript

 ``

Output

`4`

Time Complexity: O(N) where n is number of elements in given string. As, we are using a loop to traverse N times so it will cost us O(N) time
Auxiliary Space: O(1), as we are using extra space for stack.

Method 2 ( O(1) auxiliary space ):

This can also be done without using stack.

1. 1) Take two variables max and current_max, initialize both of them as 0.
2. 2) Traverse the string, do following for every character
• If current character is ‘(’, increment current_max and  update max value if required.
• 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));``    ``}``}`

## Python3

 `# 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``        ``else` `if` `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) where n is number of elements in given string. As, we are using a loop to traverse N times so it will cost us O(N) time.
Auxiliary Space: O(1), as we are not using any extra space.

My Personal Notes arrow_drop_up