update code

README.md

@@ -61,9 +61,17 @@
 [荷兰国旗问题与快速排序算法](https://www.cnblogs.com/greyzeng/p/16739515.html)
 
 [找到数组中出现特定次数数字的问题](https://www.cnblogs.com/greyzeng/p/15385402.html)
+
 - 一个数组中有一种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这种数?
 - 一个数组中有两种数出现了奇数次，其他数都出现了偶数次，怎么找到并打印这两种数
-- 一个数组中有一种数出现 k 次，其他数都出现了 m 次，m > 1,  k < m, 找到出现了 k 次的数
+- 一个数组中有一种数出现 k 次，其他数都出现了 m 次，m > 1, k < m, 找到出现了 k 次的数
+
+[栈和队列相关的一些问题](https://www.cnblogs.com/greyzeng/p/16631644.html)
+
+- 最小栈
+- 用双向链表实现双端队列
+- 栈和队列之间互相实现
+- 数组实现固定大小的队列
 
 ## 更多
 

src/main/java/git/snippet/queueandstack/LeetCode_0641_DesignCircularDeque.java

@@ -6,90 +6,101 @@ package git.snippet.queueandstack;
 public class LeetCode_0641_DesignCircularDeque {
 
     class MyCircularDeque {
-        Node head;
-        Node tail;
-        int size;
-        int capacity;
+        private class Node {
+            int v;
+            Node last;
+            Node next;
+
+            public Node(int val) {
+                v = val;
+            }
+        }
+
+        private Node head; // 头节点
+        private Node tail; // 尾部节点
+        private int cap; // 容量
+        private int size; // 当前大小
+
         public MyCircularDeque(int k) {
-            capacity = k;
+            cap = k;
         }
 
         public boolean insertFront(int value) {
-            if (!isFull()) {
-                if (head == null) {
-                    head = new Node(value);
-                    tail = head;
-                } else {
-                    Node newHead = new Node(value);
-                    head.last = newHead;
-                    newHead.next = head;
-                    head = newHead;
-                }
-                size++;
-                return true;
+            if (isFull()) {
+                return false;
+            }
+            size++;
+            if (head == null) {
+                head = new Node(value);
+                tail = head;
+            } else {
+                Node newHead = new Node(value);
+                newHead.next = head;
+                head.last = newHead;
+                head = newHead;
             }
-            return false;
+            return true;
         }
 
         public boolean insertLast(int value) {
-            if (!isFull()) {
-                if (head == null) {
-                    head = new Node(value);
-                    tail = head;
-                } else {
-                    Node newTail = new Node(value);
-                    tail.next = newTail;
-                    newTail.last = tail;
-                    tail = newTail;
-                }
-                size++;
-                return true;
+            if (isFull()) {
+                return false;
             }
-            return false;
+            size++;
+            if (head == null) {
+                head = new Node(value);
+                tail = head;
+            } else {
+                Node newTail = new Node(value);
+                tail.next = newTail;
+                newTail.last = tail;
+                tail = newTail;
+            }
+            return true;
         }
 
         public boolean deleteFront() {
-            if (!isEmpty()) {
-                if (size == 1) {
-                    head = null;
-                    tail = null;
-                    size = 0;
-                    return true;
-                } else {
-                    Node t = head.next;
-                    t.last = null;
-                    head = t;
-                    size--;
-                }
-                return true;
+            if (size == 0 || cap == 0) {
+                return false;
+            }
+            size--;
+            if (size == 0) {
+                head = null;
+                tail = null;
+            } else {
+                head = head.next;
+                head.last = null;
             }
-            return false;
+            return true;
         }
 
         public boolean deleteLast() {
-            if (!isEmpty()) {
-                if (size == 1) {
-                    head = null;
-                    tail = null;
-                    size = 0;
-                    return true;
-                } else {
-                    Node t = tail.last;
-                    t.next = null;
-                    tail = t;
-                    size--;
-                }
-                return true;
+            if (size == 0 || cap == 0) {
+                return false;
             }
-            return false;
+            size--;
+            if (size == 0) {
+                head = null;
+                tail = null;
+            } else {
+                tail = tail.last;
+                tail.next = null;
+            }
+            return true;
         }
 
         public int getFront() {
-            return isEmpty() ? -1 : head.v;
+            if (size == 0) {
+                return -1;
+            }
+            return head.v;
         }
 
         public int getRear() {
-            return isEmpty() ? -1 : tail.v;
+            if (size == 0) {
+                return -1;
+            }
+            return tail.v;
         }
 
         public boolean isEmpty() {
@@ -97,17 +108,7 @@ public class LeetCode_0641_DesignCircularDeque {
         }
 
         public boolean isFull() {
-            return capacity == size;
-        }
-
-        class Node {
-            public int v;
-            public Node next;
-            public Node last;
-
-            public Node(int v) {
-                this.v = v;
-            }
+            return size == cap;
         }
     }
 }