Share valid parentheses leetcode java,

[phuhai420000]

#Valid Parentheses #LeetCode #Java #algorithms #data Cấu trúc ## Dấu ngoặc

Cho một chuỗi dấu ngoặc đơn, xác định xem nó có hợp lệ hay không.

Một chuỗi dấu ngoặc đơn hợp lệ là một trong đó mỗi dấu ngoặc đơn có dấu ngoặc đơn tương ứng.

Ví dụ: "(() ())" và "(())" là hợp lệ, trong khi "(()" và ") (" thì không.

**Giải pháp**

Chúng ta có thể giải quyết vấn đề này bằng cách sử dụng một ngăn xếp.Một ngăn xếp là một cấu trúc dữ liệu lưu trữ các yếu tố theo thứ tự cuối cùng, đầu tiên (LIFO).

Chúng tôi có thể lặp lại chuỗi dấu ngoặc đơn và với mỗi dấu ngoặc đơn, chúng tôi đẩy nó lên ngăn xếp.Đối với mỗi dấu ngoặc đơn, chúng tôi bật một yếu tố từ ngăn xếp.Nếu ngăn xếp trống khi chúng ta gặp dấu ngoặc đơn, thì chuỗi không hợp lệ.

Chúng ta cũng có thể kiểm tra xem ngăn xếp có trống ở cuối chuỗi không.Nếu là, thì chuỗi là hợp lệ.Nếu không, chuỗi không hợp lệ.

`` `java
nhập java.util.stack;

Lớp công khai Validparentheses {

công khai boolean isvalid (chuỗi s) {
Stack <ký tự> stack = new stack <> ();

for (char c: s.toararray ()) {
if (c == '(') {
stack.push (c);
} if if (c == ')') {
if (stack.isempty ()) {
trả lại sai;
}

stack.pop ();
}
}

trả lại ngăn xếp.isempty ();
}

công khai void void main (String [] args) {
System.out.println (isValid ("(() ())")));// ĐÚNG VẬY
System.out.println (isValid ("(())"));// ĐÚNG VẬY
System.out.println (isValid ("(()")); // Sai
System.out.println (isValid (")")));// SAI
}
}
`` `

## Độ phức tạp thời gian

Độ phức tạp về thời gian của thuật toán này là O , trong đó n là độ dài của chuỗi.

## Độ phức tạp không gian

Độ phức tạp không gian của thuật toán này là O , trong đó n là độ dài của chuỗi.
=======================================
#Valid Parentheses #LeetCode #Java #algorithms #data Structures ##Valid Parentheses in Java

Given a string of parentheses, determine whether it is valid.

A valid parentheses string is one where each open parenthesis has a corresponding closed parenthesis.

For example, "(()())" and "(())" are valid, while "(()" and ")(" are not.

**Solution**

We can solve this problem using a stack. A stack is a data structure that stores elements in a last-in, first-out (LIFO) order.

We can iterate over the string of parentheses, and for each open parenthesis, we push it onto the stack. For each closed parenthesis, we pop an element from the stack. If the stack is empty when we encounter a closed parenthesis, then the string is invalid.

We can also check if the stack is empty at the end of the string. If it is, then the string is valid. Otherwise, the string is invalid.

```java
import java.util.Stack;

public class ValidParentheses {

public static boolean isValid(String s) {
Stack<Character> stack = new Stack<>();

for (char c : s.toCharArray()) {
if (c == '(') {
stack.push(c);
} else if (c == ')') {
if (stack.isEmpty()) {
return false;
}

stack.pop();
}
}

return stack.isEmpty();
}

public static void main(String[] args) {
System.out.println(isValid("(()())")); // true
System.out.println(isValid("(())")); // true
System.out.println(isValid("(()")); // false
System.out.println(isValid(")")); // false
}
}
```

## Time Complexity

The time complexity of this algorithm is O, where n is the length of the string.

## Space Complexity

The space complexity of this algorithm is O, where n is the length of the string.