feat: add solutions to lc problem: No.0946

No.0946.Validate Stack Sequences

Author: yanglbme

solution/0900-0999/0946.Validate Stack Sequences/README.md

@@ -36,27 +36,90 @@ push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
 	<li><code>pushed</code>&nbsp;是&nbsp;<code>popped</code>&nbsp;的排列。</li>
 </ol>
 
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->
 
+遍历 pushed 序列，将每个数依次压入栈中，压入后检查这个数是不是 popped 序列中下一个要 pop 的值，如果是就把它 pop 出来。
+
+最后检查所有数是否都 pop 出来了。
+
 <!-- tabs:start -->
 
 ### **Python3**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
-
+class Solution:
+    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
+        stk, j, n = [], 0, len(popped)
+        for x in pushed:
+            stk.append(x)
+            while stk and j < n and stk[-1] == popped[j]:
+                stk.pop()
+                j += 1
+        return j == n
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public boolean validateStackSequences(int[] pushed, int[] popped) {
+        Deque<Integer> stk = new ArrayDeque<>();
+        int j = 0, n = popped.length;
+        for (int x : pushed) {
+            stk.push(x);
+            while (!stk.isEmpty() && j < n && stk.peek() == popped[j]) {
+                stk.pop();
+                ++j;
+            }
+        }
+        return j == n;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
+        int j = 0, n = popped.size();
+        stack<int> stk;
+        for (int x : pushed)
+        {
+            stk.push(x);
+            while (!stk.empty() && j < n && stk.top() == popped[j])
+            {
+                stk.pop();
+                ++j;
+            }
+        }
+        return j == n;
+    }
+};
+```
 
+### **Go**
+
+```go
+func validateStackSequences(pushed []int, popped []int) bool {
+	j, n := 0, len(popped)
+	var stk []int
+	for _, x := range pushed {
+		stk = append(stk, x)
+		for len(stk) > 0 && j < n && stk[len(stk)-1] == popped[j] {
+			stk = stk[:len(stk)-1]
+			j++
+		}
+	}
+	return j == n
+}
 ```
 
 ### **...**

solution/0900-0999/0946.Validate Stack Sequences/README_EN.md

@@ -40,21 +40,80 @@ push(5), pop() -> 5, pop() -> 3, pop() -> 2, pop() -> 1
 	<li><code>pushed</code> and <code>popped</code> have distinct values.</li>
 </ul>
 
-
 ## Solutions
 
 <!-- tabs:start -->
 
 ### **Python3**
 
 ```python
-
+class Solution:
+    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
+        stk, j, n = [], 0, len(popped)
+        for x in pushed:
+            stk.append(x)
+            while stk and j < n and stk[-1] == popped[j]:
+                stk.pop()
+                j += 1
+        return j == n
 ```
 
 ### **Java**
 
 ```java
+class Solution {
+    public boolean validateStackSequences(int[] pushed, int[] popped) {
+        Deque<Integer> stk = new ArrayDeque<>();
+        int j = 0, n = popped.length;
+        for (int x : pushed) {
+            stk.push(x);
+            while (!stk.isEmpty() && j < n && stk.peek() == popped[j]) {
+                stk.pop();
+                ++j;
+            }
+        }
+        return j == n;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
+        int j = 0, n = popped.size();
+        stack<int> stk;
+        for (int x : pushed)
+        {
+            stk.push(x);
+            while (!stk.empty() && j < n && stk.top() == popped[j])
+            {
+                stk.pop();
+                ++j;
+            }
+        }
+        return j == n;
+    }
+};
+```
 
+### **Go**
+
+```go
+func validateStackSequences(pushed []int, popped []int) bool {
+	j, n := 0, len(popped)
+	var stk []int
+	for _, x := range pushed {
+		stk = append(stk, x)
+		for len(stk) > 0 && j < n && stk[len(stk)-1] == popped[j] {
+			stk = stk[:len(stk)-1]
+			j++
+		}
+	}
+	return j == n
+}
 ```
 
 ### **...**

solution/0900-0999/0946.Validate Stack Sequences/Solution.cpp

@@ -0,0 +1,17 @@
+class Solution {
+public:
+    bool validateStackSequences(vector<int>& pushed, vector<int>& popped) {
+        int j = 0, n = popped.size();
+        stack<int> stk;
+        for (int x : pushed)
+        {
+            stk.push(x);
+            while (!stk.empty() && j < n && stk.top() == popped[j])
+            {
+                stk.pop();
+                ++j;
+            }
+        }
+        return j == n;
+    }
+};

solution/0900-0999/0946.Validate Stack Sequences/Solution.go

@@ -0,0 +1,12 @@
+func validateStackSequences(pushed []int, popped []int) bool {
+	j, n := 0, len(popped)
+	var stk []int
+	for _, x := range pushed {
+		stk = append(stk, x)
+		for len(stk) > 0 && j < n && stk[len(stk)-1] == popped[j] {
+			stk = stk[:len(stk)-1]
+			j++
+		}
+	}
+	return j == n
+}

solution/0900-0999/0946.Validate Stack Sequences/Solution.java

@@ -1,19 +1,14 @@
-import java.util.*;
-
 class Solution {
     public boolean validateStackSequences(int[] pushed, int[] popped) {
-        Stack<Integer> stack = new Stack<>();
-        int i = 0, k = 0;
-        while (i < popped.length) {
-            if (!stack.isEmpty() && popped[i] == stack.peek()) {
-                stack.pop();
-                i ++;
-            } else {
-                if (k < pushed.length) {
-                    stack.push(pushed[k ++]);
-                } else return false;
+        Deque<Integer> stk = new ArrayDeque<>();
+        int j = 0, n = popped.length;
+        for (int x : pushed) {
+            stk.push(x);
+            while (!stk.isEmpty() && j < n && stk.peek() == popped[j]) {
+                stk.pop();
+                ++j;
             }
         }
-        return stack.isEmpty();
+        return j == n;
     }
 }

solution/0900-0999/0946.Validate Stack Sequences/Solution.py

@@ -0,0 +1,9 @@
+class Solution:
+    def validateStackSequences(self, pushed: List[int], popped: List[int]) -> bool:
+        stk, j, n = [], 0, len(popped)
+        for x in pushed:
+            stk.append(x)
+            while stk and j < n and stk[-1] == popped[j]:
+                stk.pop()
+                j += 1
+        return j == n