valid parentheses leetcode java

[hainam74]

#Valid Parentheses #leetcode #Java #Algorithms #Interview Câu hỏi

## dấu ngoặc đơn hợp lệ trong java

Dấu ngoặc đơn hợp lệ là một vấn đề cổ điển trong khoa học máy tính.Cho một chuỗi dấu ngoặc đơn, xác định xem dấu ngoặc đơ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à ") () (" không.

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 ta có thể sử dụng một ngăn xếp để theo dõi dấu ngoặc đơn trong chuỗi đầu vào.Khi chúng tôi gặp một dấu ngoặc đơn mở, chúng tôi đẩy nó lên ngăn xếp.Khi chúng tôi gặp phải một dấu ngoặc đơn, chúng tôi bật phần tử hàng đầu của ngăn xếp.Nếu phần tử popped không phải là dấu ngoặc đơn phù hợp, thì chuỗi không hợp lệ.

Dưới đây là việc triển khai thuật toán dấu ngoặc đơn hợp lệ trong Java:

`` `java
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;
}

char top = stack.pop ();
if (top! = '(') {
trả lại sai;
}
}
}

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

Thuật toán này chạy trong thời gian O , trong đó n là độ dài của chuỗi đầu vào.

## Người giới thiệu

* [Dấu ngoặc đơn hợp lệ trên LeetCode] (https://leetcode.com/problems/valid-parentheses/)
* [Dấu ngoặc đơn hợp lệ trong java trên geeksforgeek] (https://www.geeksforgeek.org/valid-parentheses-in-java/)
=======================================
#Valid Parentheses #leetcode #Java #Algorithms #Interview Questions

## Valid Parentheses in Java

Valid Parentheses is a classic problem in computer science. Given a string of parentheses, determine whether the parentheses are valid.

A valid parenthesis string is one in which each open parenthesis has a corresponding closed parenthesis. For example, "(()())" and "(())" are valid, while "(()(" and ")()(" are not.

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 use a stack to track the parentheses in the input string. When we encounter an open parenthesis, we push it onto the stack. When we encounter a closed parenthesis, we pop the top element of the stack. If the popped element is not a matching open parenthesis, then the string is invalid.

Here is an implementation of the valid parentheses algorithm in Java:

```java
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;
}

char top = stack.pop();
if (top != '(') {
return false;
}
}
}

return stack.isEmpty();
}
```

This algorithm runs in O time, where n is the length of the input string.

## References

* [Valid Parentheses on Leetcode](https://leetcode.com/problems/valid-parentheses/)
* [Valid Parentheses in Java on GeeksforGeeks](https://www.geeksforgeeks.org/valid-parentheses-in-java/)