feat: add python and java solutions to leetcode problem: No.0225

Author: yanglbme

.github/workflows/prettier.yml

@@ -20,6 +20,6 @@ jobs:
       uses: creyD/prettier_action@v3.0
       with:
         prettier_options: --write **/*.{js,c,cpp,go,rb,java,cs,py,scala,md}
-        commit_message: 'docs: prettify code'
+        commit_message: 'style: prettify code'
       env:
         GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

README.md

@@ -76,6 +76,10 @@
 
 ### 栈和队列
 
+1. [有效的括号](/solution/0000-0099/0020.Valid%20Parentheses/README.md)
+1. [用栈实现队列](/solution/0200-0299/0232.Implement%20Queue%20using%20Stacks/README.md)
+1. [用队列实现栈](/solution/0200-0299/0225.Implement%20Stack%20using%20Queues/README.md)
+
 ### 动态规划
 
 ### 混合问题

README_EN.md

@@ -71,6 +71,10 @@ Complete solutions to [LeetCode](https://leetcode-cn.com/problemset/all/), [LCOF
 
 ### Stack & Queue
 
+1. [Valid Parentheses](/solution/0000-0099/0020.Valid%20Parentheses/README_EN.md)
+1. [Implement Queue using Stacks](/solution/0200-0299/0232.Implement%20Queue%20using%20Stacks/README_EN.md)
+1. [Implement Stack using Queues](/solution/0200-0299/0225.Implement%20Stack%20using%20Queues/README_EN.md)
+
 ### Dynamic Programming
 
 ### Misc

solution/0200-0299/0225.Implement Stack using Queues/README.md

@@ -33,15 +33,102 @@
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```python
+class MyStack:
 
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.q = []
+
+
+    def push(self, x: int) -> None:
+        """
+        Push element x onto stack.
+        """
+        self.q.append(x)
+        n = len(self.q)
+        for i in range(1, n):
+            self.q.append(self.q.pop(0))
+
+
+    def pop(self) -> int:
+        """
+        Removes the element on top of the stack and returns that element.
+        """
+        return self.q.pop(0)
+
+
+    def top(self) -> int:
+        """
+        Get the top element.
+        """
+        return self.q[0]
+
+
+    def empty(self) -> bool:
+        """
+        Returns whether the stack is empty.
+        """
+        return len(self.q) == 0
+
+
+
+# Your MyStack object will be instantiated and called as such:
+# obj = MyStack()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.empty()
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
-
+class MyStack {
+
+    private Deque<Integer> q;
+
+    /** Initialize your data structure here. */
+    public MyStack() {
+        q = new ArrayDeque<>();
+    }
+
+    /** Push element x onto stack. */
+    public void push(int x) {
+        q.offerLast(x);
+        int n = q.size();
+        while (n-- > 1) {
+            q.offerLast(q.pollFirst());
+        }
+    }
+
+    /** Removes the element on top of the stack and returns that element. */
+    public int pop() {
+        return q.pollFirst();
+    }
+
+    /** Get the top element. */
+    public int top() {
+        return q.peekFirst();
+    }
+
+    /** Returns whether the stack is empty. */
+    public boolean empty() {
+        return q.isEmpty();
+    }
+}
+
+/**
+ * Your MyStack object will be instantiated and called as such:
+ * MyStack obj = new MyStack();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.top();
+ * boolean param_4 = obj.empty();
+ */
 ```
 
 ### **...**

solution/0200-0299/0225.Implement Stack using Queues/README_EN.md

@@ -7,15 +7,10 @@
 <p>Implement the following operations of a stack using queues.</p>
 
 <ul>
-
     <li>push(x) -- Push element x onto stack.</li>
-
     <li>pop() -- Removes the element on top of the stack.</li>
-
     <li>top() -- Get the top element.</li>
-
     <li>empty() -- Return whether the stack is empty.</li>
-
 </ul>
 
 <p><b>Example:</b></p>
@@ -39,13 +34,9 @@ stack.empty(); // returns false</pre>
 <p><b>Notes:</b></p>
 
 <ul>
-
     <li>You must use <i>only</i> standard operations of a queue -- which means only <code>push to back</code>, <code>peek/pop from front</code>, <code>size</code>, and <code>is empty</code> operations are valid.</li>
-
     <li>Depending on your language, queue may not be supported natively. You may simulate a queue by using a list or deque (double-ended queue), as long as you use only standard operations of a queue.</li>
-
     <li>You may assume that all operations are valid (for example, no pop or top operations will be called on an empty stack).</li>
-
 </ul>
 
 ## Solutions
@@ -55,13 +46,100 @@ stack.empty(); // returns false</pre>
 ### **Python3**
 
 ```python
+class MyStack:
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.q = []
+
 
+    def push(self, x: int) -> None:
+        """
+        Push element x onto stack.
+        """
+        self.q.append(x)
+        n = len(self.q)
+        for i in range(1, n):
+            self.q.append(self.q.pop(0))
+
+
+    def pop(self) -> int:
+        """
+        Removes the element on top of the stack and returns that element.
+        """
+        return self.q.pop(0)
+
+
+    def top(self) -> int:
+        """
+        Get the top element.
+        """
+        return self.q[0]
+
+
+    def empty(self) -> bool:
+        """
+        Returns whether the stack is empty.
+        """
+        return len(self.q) == 0
+
+
+
+# Your MyStack object will be instantiated and called as such:
+# obj = MyStack()
+# obj.push(x)
+# param_2 = obj.pop()
+# param_3 = obj.top()
+# param_4 = obj.empty()
 ```
 
 ### **Java**
 
 ```java
-
+class MyStack {
+
+    private Deque<Integer> q;
+
+    /** Initialize your data structure here. */
+    public MyStack() {
+        q = new ArrayDeque<>();
+    }
+
+    /** Push element x onto stack. */
+    public void push(int x) {
+        q.offerLast(x);
+        int n = q.size();
+        while (n-- > 1) {
+            q.offerLast(q.pollFirst());
+        }
+    }
+
+    /** Removes the element on top of the stack and returns that element. */
+    public int pop() {
+        return q.pollFirst();
+    }
+
+    /** Get the top element. */
+    public int top() {
+        return q.peekFirst();
+    }
+
+    /** Returns whether the stack is empty. */
+    public boolean empty() {
+        return q.isEmpty();
+    }
+}
+
+/**
+ * Your MyStack object will be instantiated and called as such:
+ * MyStack obj = new MyStack();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.top();
+ * boolean param_4 = obj.empty();
+ */
 ```
 
 ### **...**

solution/0200-0299/0225.Implement Stack using Queues/Solution.java

@@ -1,52 +1,42 @@
-    class MyStack {
+class MyStack {
 
-        Queue<Integer> q1;
-        Queue<Integer> q2;
+    private Deque<Integer> q;
 
-        /** Initialize your data structure here. */
-        public MyStack() {
-            q1 = new LinkedList<>();
-            q2 = new LinkedList<>();
+    /** Initialize your data structure here. */
+    public MyStack() {
+        q = new ArrayDeque<>();
+    }
+    
+    /** Push element x onto stack. */
+    public void push(int x) {
+        q.offerLast(x);
+        int n = q.size();
+        while (n-- > 1) {
+            q.offerLast(q.pollFirst());
         }
+    }
+    
+    /** Removes the element on top of the stack and returns that element. */
+    public int pop() {
+        return q.pollFirst();
+    }
+    
+    /** Get the top element. */
+    public int top() {
+        return q.peekFirst();
+    }
+    
+    /** Returns whether the stack is empty. */
+    public boolean empty() {
+        return q.isEmpty();
+    }
+}
 
-        /** Push element x onto stack. */
-        public void push(int x) {
-            q1.add(x);
-        }
-
-        /** Removes the element on top of the stack and returns that element. */
-        public int pop() {
-            if (q1.isEmpty()) {
-                return 0;
-            }
-            while (q1.size() > 1) {
-                q2.add(q1.poll());
-            }
-            int result = q1.poll();
-            Queue<Integer> temp = q1;
-            q1 = q2;
-            q2 = temp;
-            return result;
-        }
-
-        /** Get the top element. */
-        public int top() {
-            if (q1.isEmpty()) {
-                return 0;
-            }
-            while (q1.size() > 1) {
-                q2.add(q1.poll());
-            }
-            int result = q1.poll();
-            q2.add(result);
-            while (q2.size() > 0) {
-                q1.add(q2.poll());
-            }
-            return result;
-        }
-
-        /** Returns whether the stack is empty. */
-        public boolean empty() {
-            return q1.isEmpty() && q2.isEmpty();
-        }
-    }
+/**
+ * Your MyStack object will be instantiated and called as such:
+ * MyStack obj = new MyStack();
+ * obj.push(x);
+ * int param_2 = obj.pop();
+ * int param_3 = obj.top();
+ * boolean param_4 = obj.empty();
+ */