GFG App
Open App
Browser
Continue

# Find maximum depth of nested parenthesis in a string

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(N), 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