Check for balanced paranthesis using recursion without stack

//Check for balanced parenthesis without using stack:  DOUBT
static char findClosing(char c)
{
    if (c == '(')
        return ')';
    if (c == '{')
        return '}';
    if (c == '[')
        return ']';
    return Character.MIN_VALUE;
}
static boolean checkBracket(char [] arr,int n){
       if(n==0)
       return true ;
       if(n==1)
           return false;
       if(arr[0]==')' || arr[0]=='}' || arr[0]==']')
           return false;
       char closing =findClosing(arr[0]);
    int i, count = 0;
    for (i = 1; i < n; i++) {
        if (arr[i] == arr[0])
            count++;
        if (arr[i] == closing) {
            if (count == 0)
                break;
            count--;
        }
    }
    if (i == n)
        return false;
    if (i == 1)
        return checkBracket(Arrays.copyOfRange(arr, i + 1, n), n - 2);
    return checkBracket(Arrays.copyOfRange(arr, 1, i), i - 1) && checkBracket(Arrays.copyOfRange(arr, (i + 1), n), n - i - 1);
}

I cannot understand the logic that what is done after initializing the variables count and I.

I know that a loop a written to traverse the array but I cannot get the logic that how it will find the closing brackets at appropriate positions.

Help.

> Check for balanced paranthesis using recursion without stack

The code does not use an explicit stack data structure, but it absolutely uses a stack: the call stack. Each method call involves a push onto that stack (or perhaps more than one, depending on how you characterize things), and each method return involves a corresponding pop (or pops).

> if(n==0)
> return true ;
> if(n==1)
> return false;
> if(arr[0]==')' || arr[0]=='}' || arr[0]==']')
> return false;

If the character (sub)sequence is empty then it is trivially balanced. If it has only one element then it is trivially unbalanced. If the first character is one of the closing delimiters considered then it is necessarily unbalanced. These are the base cases for the recursion.

> char closing =findClosing(arr[0]);

Determine which is the closing bracket matching the first character of the subsequence.

> int i, count = 0;
> for (i = 1; i < n; i++) {
> if (arr[i] == arr[0])
> count++;
> if (arr[i] == closing) {
> if (count == 0)
> break;
> count--;
> }
> }

Scan forward through the character sequence to find the closing delimiter matched to the initial character of the sequence. Variable count provides for handling nested bracket pairs of the same type as the one currently being handled. Brackets of other types are ignored at this time. When the loop terminates, i is the index of the matching close bracket, or it is equal to the length of the sequence, n, which is not a valid index into the array.

> if (i == n)
> return false;

In that case, no matching close bracket was found.

Otherwise,

> if (i == 1)
> return checkBracket(Arrays.copyOfRange(arr, i + 1, n), n - 2);

If the matching close bracket is the very next character then there are no others between. In that case, the overall sequence is balanced if and only if the tail of the sequence is balanced. This is actually a special case of the following, and doesn't really need its own case.

Otherwise,

> return checkBracket(Arrays.copyOfRange(arr, 1, i), i - 1) && checkBracket(Arrays.copyOfRange(arr, (i + 1), n), n - i - 1);

the overall sequence is balanced if and only if the subsequence between the current bracket pair is balanced and the tail of the sequence is balanced.