refactor: 利用双端队列实现栈和队列

dairongpeng · dairongpeng · commit 6c23cd113d96 · 2022-01-11T22:22:22.000+08:00
diff --git a/02-链表、栈、队列、递归、哈希表、顺序表.md b/02-链表、栈、队列、递归、哈希表、顺序表.md
@@ -223,201 +223,45 @@ func (q *DoubleEndsQueue) IsEmpty() bool {
 
 > 利用双向链表（双端队列）封装栈和队列
 
-```Java
-package class02;
-
-import java.util.LinkedList;
-import java.util.Queue;
-import java.util.Stack;
-
-public class Code03_DoubleEndsQueueToStackAndQueue {
-
-	public static class Node<T> {
-		public T value;
-		public Node<T> last;
-		public Node<T> next;
-
-		public Node(T data) {
-			value = data;
-		}
-	}
-
-	public static class DoubleEndsQueue<T> {
-		public Node<T> head;
-		public Node<T> tail;
-
-                // 从头部加节点
-		public void addFromHead(T value) {
-			Node<T> cur = new Node<T>(value);
-			if (head == null) {
-				head = cur;
-				tail = cur;
-			} else {
-				cur.next = head;
-				head.last = cur;
-				head = cur;
-			}
-		}
-
-                // 从尾部加节点
-		public void addFromBottom(T value) {
-			Node<T> cur = new Node<T>(value);
-			if (head == null) {
-				head = cur;
-				tail = cur;
-			} else {
-				cur.last = tail;
-				tail.next = cur;
-				tail = cur;
-			}
-		}
-
-                // 从头部弹出节点
-		public T popFromHead() {
-			if (head == null) {
-				return null;
-			}
-			Node<T> cur = head;
-			if (head == tail) {
-				head = null;
-				tail = null;
-			} else {
-				head = head.next;
-				cur.next = null;
-				head.last = null;
-			}
-			return cur.value;
-		}
-
-                // 从尾部弹出节点
-		public T popFromBottom() {
-			if (head == null) {
-				return null;
-			}
-			Node<T> cur = tail;
-			if (head == tail) {
-				head = null;
-				tail = null;
-			} else {
-				tail = tail.last;
-				tail.next = null;
-				cur.last = null;
-			}
-			return cur.value;
-		}
-
-                // 该双向链表结构是否为空
-		public boolean isEmpty() {
-			return head == null;
-		}
-
-	}
-
-        // 用上述双向链表结构实现栈
-	public static class MyStack<T> {
-		private DoubleEndsQueue<T> queue;
-
-		public MyStack() {
-			queue = new DoubleEndsQueue<T>();
-		}
-
-		public void push(T value) {
-			queue.addFromHead(value);
-		}
-
-		public T pop() {
-			return queue.popFromHead();
-		}
-
-		public boolean isEmpty() {
-			return queue.isEmpty();
-		}
-
-	}
-
-        // 用上述双向链表结构实现队列
-	public static class MyQueue<T> {
-		private DoubleEndsQueue<T> queue;
-
-		public MyQueue() {
-			queue = new DoubleEndsQueue<T>();
-		}
-
-		public void push(T value) {
-			queue.addFromHead(value);
-		}
+```Go
+// Stack 利用双端队列实现栈
+type Stack struct {
+	qu *DoubleEndsQueue
+}
 
-		public T poll() {
-			return queue.popFromBottom();
-		}
+func (s *Stack) push(v int) {
+	s.qu.AddFromHead(v)
+}
 
-		public boolean isEmpty() {
-			return queue.isEmpty();
-		}
+func (s *Stack)pop() (int, bool) {
+	return s.qu.PopFromHead()
+}
 
-	}
+func (s *Stack)IsEmpty() bool {
+	return s.qu.IsEmpty()
+}
+```
 
-	public static boolean isEqual(Integer o1, Integer o2) {
-		if (o1 == null && o2 != null) {
-			return false;
-		}
-		if (o1 != null && o2 == null) {
-			return false;
-		}
-		if (o1 == null && o2 == null) {
-			return true;
-		}
-		return o1.equals(o2);
-	}
+```Go
+// Queue 利用双端队列实现队列
+type Queue struct {
+	qu *DoubleEndsQueue
+}
 
-	public static void main(String[] args) {
-		int oneTestDataNum = 100;
-		int value = 10000;
-		int testTimes = 100000;
-		for (int i = 0; i < testTimes; i++) {
-			MyStack<Integer> myStack = new MyStack<>();
-			MyQueue<Integer> myQueue = new MyQueue<>();
-			Stack<Integer> stack = new Stack<>();
-			Queue<Integer> queue = new LinkedList<>();
-			for (int j = 0; j < oneTestDataNum; j++) {
-				int nums = (int) (Math.random() * value);
-				if (stack.isEmpty()) {
-					myStack.push(nums);
-					stack.push(nums);
-				} else {
-					if (Math.random() < 0.5) {
-						myStack.push(nums);
-						stack.push(nums);
-					} else {
-						if (!isEqual(myStack.pop(), stack.pop())) {
-							System.out.println("oops!");
-						}
-					}
-				}
-				int numq = (int) (Math.random() * value);
-				if (stack.isEmpty()) {
-					myQueue.push(numq);
-					queue.offer(numq);
-				} else {
-					if (Math.random() < 0.5) {
-						myQueue.push(numq);
-						queue.offer(numq);
-					} else {
-						if (!isEqual(myQueue.poll(), queue.poll())) {
-							System.out.println("oops!");
-						}
-					}
-				}
-			}
-		}
-		System.out.println("finish!");
-	}
+func (q *Queue) push(v int) {
+	q.qu.AddFromHead(v)
+}
 
+func (q *Queue) poll() (int, bool) {
+	return q.qu.PopFromBottom()
 }
 
+func (q *Queue)IsEmpty() bool {
+	return q.qu.IsEmpty()
+}
 ```
 
-> 数组实现,对于栈特别简单，对于队列，如下
+> 数组实现栈和队列, 对于栈特别简单，对于队列，如下
 
 ```Java
 package class02;
