diff --git "a/StackAndQueue/\345\256\266/.keep" "b/StackAndQueue/\345\256\266/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/StackAndQueue/\345\256\266_20.md" "b/StackAndQueue/\345\256\266_20.md"
new file mode 100644
index 0000000000000000000000000000000000000000..c7eeaee75e088af898d23ee56969eb18144841aa
--- /dev/null
+++ "b/StackAndQueue/\345\256\266_20.md"
@@ -0,0 +1,19 @@
+/**
+ * 作者：家
+ * 思路：用字典储存对应的括号，遍历字符串，遇到左括号压栈，遇到右括号检查栈顶是否对应，对应即可弹出，最后判断栈是否为空。
+ *      当然如果开心的话，可以先判断字符串长度，为奇数直接return False
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+class Solution:
+    def isValid(self, s: str) -> bool:
+        stack = []
+        dicts = {')': '(', ']': '[', '}': '{'}
+        for x in s :
+            if x in ["(","[","{"] :
+                stack.append(x)
+            else :
+                if len(stack) == 0 or stack.pop() != dicts[x] :
+                    return False             
+        return len(stack) == 0
+        
\ No newline at end of file
diff --git "a/StackAndQueue/\345\256\266_225.md" "b/StackAndQueue/\345\256\266_225.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f171e138713e141b6727ecf582ec6209dcac0791
--- /dev/null
+++ "b/StackAndQueue/\345\256\266_225.md"
@@ -0,0 +1,28 @@
+```go
+/**
+ * 作者：家
+ * 思路：正统的思路肯定是两个队列模拟栈，如果只是刷题的话用python列表的特性即可实现。
+ * 时间复杂度：
+ * push:O(1)
+ * pop:O(1)
+ * top:O(1)
+ * empty:O(1)
+ * 空间复杂度：O(n)
+ */
+class MyStack:
+
+    def __init__(self):
+        self.stack = []
+        
+    def push(self, x: int) -> None:
+        self.stack.append(x)
+        
+    def pop(self) -> int:
+        return self.stack.pop()
+        
+    def top(self) -> int:
+        return self.stack[-1]
+        
+    def empty(self) -> bool:
+        return not self.stack
+```        
\ No newline at end of file
diff --git "a/StackAndQueue/\345\256\266_232.md" "b/StackAndQueue/\345\256\266_232.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6ad0e5573123af2cb54542907b3e80a127014220
--- /dev/null
+++ "b/StackAndQueue/\345\256\266_232.md"
@@ -0,0 +1,28 @@
+/**
+ * 作者：家
+ * 思路：正统的思路肯定是两个栈模拟队列，如果只是刷题的话用python列表的特性即可实现。
+ * 时间复杂度：
+ * push:O(1)
+ * pop:O(1)
+ * peek:O(1)
+ * empty:O(1)
+ * 空间复杂度：O(n)
+ */
+class MyQueue:
+
+    def __init__(self):
+        self.queue = []
+
+    def push(self, x: int) -> None:
+        self.queue.append(x)   
+
+    def pop(self) -> int:
+        tmp = self.queue[0]
+        self.queue = self.queue[1:]
+        return tmp
+
+    def peek(self) -> int:
+        return self.queue[0]
+        
+    def empty(self) -> bool:
+        return not self.queue
\ No newline at end of file
diff --git "a/StackAndQueue/\345\256\266_239.md" "b/StackAndQueue/\345\256\266_239.md"
new file mode 100644
index 0000000000000000000000000000000000000000..cbaacaa513307af0b20185b13ad2387edc46ea5c
--- /dev/null
+++ "b/StackAndQueue/\345\256\266_239.md"
@@ -0,0 +1,28 @@
+```go
+/**
+ * 作者：家
+ * 思路：用队列来实现就可以了，这个队列长度为k，保证队首元素为队列中的最大元素即可。详情在代码，更详情在博客，博客链接后续补上。
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(k)
+ */
+class Solution:
+    def maxSlidingWindow(self, nums: List[int], k: int) -> List[int]:
+        l = len(nums)
+        if l == 0 or k == 0 :
+            return []
+        queue,re = [],[]
+        for i in range(len(nums)) :
+            //如果队列中元素大于k就pop
+            if i >= k and i-queue[0] >= k :
+                queue = queue[1:]
+            //循环，把队列中小于新元素的元素pop掉
+            while len(queue) > 0 and nums[i] >= nums[queue[len(queue)-1]] :
+                queue = queue[:len(queue)-1]
+            //队列中存的是索引
+            queue.append(i)
+            if i >= k-1 :
+                re.append(nums[queue[0]])
+                
+        return re
+
+```
\ No newline at end of file
diff --git "a/StackAndQueue/\345\256\266_703.md" "b/StackAndQueue/\345\256\266_703.md"
new file mode 100644
index 0000000000000000000000000000000000000000..6f73df0b40e6d104cc95ffe90cc16cfcc3062665
--- /dev/null
+++ "b/StackAndQueue/\345\256\266_703.md"
@@ -0,0 +1,25 @@
+```go
+/**
+ * 作者：家
+ * 思路：用一个小顶堆来实现，并且保证长度为k即可。
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+from heapq import heappush, heapify, heappop, heappushpop
+class KthLargest:
+
+    def __init__(self, k: int, nums: List[int]):
+        self.k = k
+        self.heap = nums
+        heapify(self.heap)
+        while len(self.heap) > k:
+            heappop(self.heap)
+
+    def add(self, val: int) -> int:
+        if len(self.heap) < self.k:
+            heappush(self.heap, val)
+        else:
+            heappushpop(self.heap, val)
+        return self.heap[0]
+
+```
\ No newline at end of file