Thinking:
This lesson is about two kinds of data structures -- queue and stack. After reading the question carefully, you can tell stack is a good choice. As it's a EASY-level question, there is neither a trick nor a math theory behind it. But, some traps still exist, which make the code a little bit long. Let's see my solution directly.
class Solution {
public int solution(String S) {
// empty string, return 1, notice: "".split("") return an array [""], neither null nor array []
if (S == null || S.equals("")) {
return 1;
}
String[] sArray = S.split("");
int l = sArray.length;
Stack<String> stackLeft = new Stack<String>();
Stack<String> stackRight = new Stack<String>();
System.out.println(S);
// odd number, return 0
if((l / 2) < (l - (l / 2))) {
return 0;
}
for(int i = 0; i < l; i ++) {
stackLeft.push(sArray[i]);
}
while(!stackLeft.empty()) {
String next1;
String next2;
if (stackRight.empty()) {
next1 = stackLeft.pop();
if (!stackLeft.empty()) {
next2 = stackLeft.pop();
} else {
return 0;
}
} else {
next1 = stackRight.pop();
next2 = stackLeft.pop();
}
// isn't couple
if (!isCouple(next2, next1)) {
stackRight.push(next1);
stackRight.push(next2);
continue;
}
}
if (stackLeft.empty() && stackRight.empty()) {
return 1;
} else {
return 0;
}
}
public boolean isCouple(String left, String right) {
if((left.equals("(") && right.equals(")"))
|| (left.equals("[") && right.equals("]"))
|| (left.equals("{") && right.equals("}"))) {
return true;
}
return false;
}
}
Task description:
A string S consisting of N characters is considered to be properly nested if any of the following conditions is true:
- S is empty;
- S has the form "(U)" or "[U]" or "{U}" where U is a properly nested string;
- S has the form "VW" where V and W are properly nested strings.
For example, the string "{[()()]}" is properly nested but "([)()]" is not.
Write a function:
class Solution { public int solution(String S); }
that, given a string S consisting of N characters, returns 1 if S is properly nested and 0 otherwise.
For example, given S = "{[()()]}", the function should return 1 and given S = "([)()]", the function should return 0, as explained above.
Assume that:
- N is an integer within the range [0..200,000];
- string S consists only of the following characters: "(", "{", "[", "]", "}" and/or ")".
Complexity:
- expected worst-case time complexity is O(N);
- expected worst-case space complexity is O(N) (not counting the storage required for input arguments).