A counterexample in balanced parentheses

Question

In this program I had to analyse if the parenthesis given are well balanced. For instance, input (()) is correct and input ())(() is incorrect. I've tested with other similar inputs, so my question is: can my code fail with some weird expression (using parentheses) or will it always work correctly?

public class Main {

public static void main(String[] args) {
    Scanner x = new Scanner(System.in);
    Stack<String> parenthesis = new Stack<>();

    System.out.println("Introduce the length of your expression");
    int l = x.nextInt();
    System.out.println("Introduce your expression");

    x.nextLine();
    for (int i = 0; i < l; i++) {
        System.out.println("Introduce an element");
       String e = x.next();
        parenthesis.push(e);
    }

    analysis(parenthesis);
}

public static void analysis(Stack<String> st) {

    Stack<String> closed = new Stack<>();//only for parentesis like this: )



    int ww = 0;
    while (!st.isEmpty() && ww != 1) {
        String s =st.pop();
        if (0 == s.compareTo("(") && !closed.isEmpty()) {
            closed.pop();
        } else if ((0 == s.compareTo("(")) && closed.isEmpty()) {
            System.out.println("incorrect expression.");
            ww = 1;
        } else {
            closed.push(s);
        }
    }
    if (ww == 1) {
        System.out.println();
    } else if (!closed.isEmpty()) {
        System.out.println("incorrect espression");
    } else {
        System.out.println("correct");
    }

}
  }

Answer 1

Inside the analysis method, you only use the variable ww as 0 or 1. This would be better as a boolean type instead of int type.

---

Currently analysis has two actions:

1. Validate the input
2. Write the response to the console.

The analysis would be more reusable if you removed the printing and put it in a different function. And then analysis would return String instead of void.

This:

public static void analysis(Stack<String> st) {
...<snip>...
    if (ww == 1) {
        System.out.println();
    } else if (!closed.isEmpty()) {
        System.out.println("incorrect espression");
    } else {
        System.out.println("correct");
    }
}

becomes

public static String analysis(Stack<String> st) {
...<snip>...
    if (ww == 1) {
        return "\n";
    } else if (!closed.isEmpty()) {
        return "incorrect espression\n";
    } else {
        return "correct\n";
    }
}

---

Some of your variable names are really good (such as parentheses), but some are only a single letter or two, which can be hard to understand by someone else reading your code. l would be better as length, x could be scanner or input, etc. I still haven't figured out what ww is, other than a flag of some kind.

---

Is there a reason the user needs to type each character in the parentheses one at a time instead of all at once?

---

You have a typo in one of your incorrect espression blocks. And one ends with a period while the other does not.

Answer 2

May I suggest a simpler solution: You need only a counter. it is incremented by 1 whenever you encounter an openning parenthesis "(" and is decreased by 1 whenever you encounter a closing parenthesis ")" The input is invalid if the counter drops below zero or is not zero by the end of scanning.

EDIT
since OP specified they must use a stack, we can follow @JollyJoker's advice: counter increament is implemented by a push operation, counter decrement by a pop one. counter falling below zero is implemented by attemt to pop when the stack is empty. by the end of scanning the stack has to be empty.