diff --git a/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/QuickMinStack.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/QuickMinStack.java
new file mode 100644
index 0000000000..8beb22287d
--- /dev/null
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/QuickMinStack.java
@@ -0,0 +1,51 @@
+package com.github.orajavac.coding2017.basic.stack;
+
+
+/**
+ * 设计一个栈，支持栈的push和pop操作，以及第三种操作findMin, 它返回改数据结构中的最小元素
+ * finMin操作最坏的情形下时间复杂度应该是O(1) ， 简单来讲，操作一次就可以得到最小值
+ * @author liuxin
+ *
+ */
+public class QuickMinStack {
+	
+	private Stack s1 = new Stack();
+	
+	private Stack s2 = new Stack();
+	
+	private int min = 0;
+	
+	public void push(int data){
+		if(s1.length() == 0){
+			s1.push(data);
+			s2.push(data);
+			min = data;
+		}else{
+			if (data <= min){
+				s2.push(data);
+				min = data;
+			}
+			s1.push(data);
+		}
+	}
+	
+	public int pop(){
+		Integer result = Integer.parseInt(s1.pop().toString());
+		if (result == min){
+			min = Integer.parseInt(s2.pop().toString());
+		}
+		return result;
+	}
+	
+	public int findMin(){
+		Integer min_ = Integer.parseInt(s2.pop().toString());
+		s2.push(min_);
+		return min_;
+	}
+	
+	//测试使用，观察栈里元素
+    public void toStrings(){
+    	System.out.println("s1 = "+s1.positiveToString());
+    	System.out.println("s2 = "+s2.positiveToString());
+    }
+}
diff --git a/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/Stack.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/Stack.java
index 499b4a33e4..82b0ab9c74 100644
--- a/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/Stack.java
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/Stack.java
@@ -14,11 +14,17 @@ public Stack(){
 		l = new LRUPageFrame();
 	}
 	
+	//栈使用
 	public void push(Object o){
 		//l.addFirst(o);
 		l.add(o);
 	}
 	
+	//StackWithTwoQueues 使用
+	public void push1(Object o){
+		l.addFirst(o);
+	}
+	
 	public Object pop(){
 		return l.remove();
 	}
@@ -31,6 +37,10 @@ public String toString(){
 		return l.lastToString();
 	}
 	
+	public String positiveToString(){
+		return l.toString();
+	}
+	
 	public Object[] getElements(int len){
 		return l.getElements(len);
 	}
diff --git a/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/StackWithTwoQueues.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/StackWithTwoQueues.java
new file mode 100644
index 0000000000..75a59c937d
--- /dev/null
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/StackWithTwoQueues.java
@@ -0,0 +1,45 @@
+package com.github.orajavac.coding2017.basic.stack;
+
+
+/**
+ * （1）入栈：Q1：1，2，3，4入队列（相当于入栈）；
+ （2）出栈：Q1：1，2，3出队列，Q2：1，2，3入队列；（此时Q1只剩4，正是我们要出栈的元素）
+ （3）
+     1>入栈：Q1：5入队列（每次入栈都用Q1入队列实现，而不入队列Q2，这样会提高效率，后面会说到）
+     2>出栈：判断：如果Q1队列不为空就用（1）（2）步的方法出栈最后一个元素。否则，出栈Q2队列的最后一个元素。
+ * @author ora
+ *
+ */
+public class StackWithTwoQueues {
+	
+	private Stack q1 = new Stack();
+	
+	private Stack q2 = new Stack();
+	
+	public void push(int data) {
+		q1.push(data);
+    }
+
+    public int pop() {
+    	int len = q1.length();
+    	while(len != 1){
+    		q2.push(q1.popLow());
+    		len--;
+    	}
+    	int result = Integer.parseInt(q1.popLow().toString());
+    	
+    	//再push回去
+    	len = q2.length();
+    	while(len != 0){
+    		q1.push(q2.popLow());
+    		len--;
+    	}
+    	return result;
+    }
+    
+    //测试使用，观察栈里元素
+    public String toString(){
+    	System.out.println(q1.positiveToString());
+    	return q1.positiveToString();
+    }
+}
diff --git a/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/TwoStackInOneArray.java b/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/TwoStackInOneArray.java
new file mode 100644
index 0000000000..44629b2144
--- /dev/null
+++ b/group02/562768642/src/com/github/orajavac/coding2017/basic/stack/TwoStackInOneArray.java
@@ -0,0 +1,119 @@
+package com.github.orajavac.coding2017.basic.stack;
+
+
+/**
+ * 用一个数组实现两个栈
+ * 将数组的起始位置看作是第一个栈的栈底，将数组的尾部看作第二个栈的栈底，压栈时，栈顶指针分别向中间移动，直到两栈顶指针相遇，则扩容。
+ * @author liuxin
+ *
+ */
+public class TwoStackInOneArray {
+	Object[] data = new Object[10];
+	//栈顶指针1
+	private int front = 0;  
+	//栈顶指针2
+	private int rear = data.length-1;
+	
+	/**
+	 * 向第一个栈中压入元素
+	 * @param o
+	 */
+	public void push1(Object o){
+		if (data[front] == null){
+			data[front] = o;
+			front++;
+		}else{
+			grow(data,10);
+			data[front] = o;
+			front++;
+		}
+	}
+	/**
+	 * 从第一个栈中弹出元素
+	 * @return
+	 */
+	public Object pop1(){
+		Object o = null;
+		if (front !=0 ){
+			front--;
+			o = data[front];
+			data[front] = null;
+		}else{
+			throw new RuntimeException("栈底已经没有元素了");
+		}
+		return o;
+	}
+	
+	/**
+	 * 获取第一个栈的栈顶元素
+	 * @return
+	 */
+	
+	public Object peek1(){
+		return data[front-1];
+	}
+	/*
+	 * 向第二个栈压入元素
+	 */
+	public void push2(Object o){
+		if (data[rear] == null){
+			data[rear] = o;
+			rear--;
+		}else{
+			grow(data,10);
+			data[rear] = o;
+			rear--;
+		}
+	}
+	/**
+	 * 从第二个栈弹出元素
+	 * @return
+	 */
+	public Object pop2(){
+		Object o = null;
+		if (rear !=data.length-1 ){
+			rear++;
+			o = data[rear];
+			data[rear] = null;
+		}else{
+			throw new RuntimeException("栈底已经没有元素了");
+		}
+		return o;
+	}
+	/**
+	 * 获取第二个栈的栈顶元素
+	 * @return
+	 */
+	
+	public Object peek2(){
+		return data[rear+1];
+	}
+	
+	public void grow(Object[] elementData,int size){
+		Object[] target = new Object[size+elementData.length];
+		int n = target.length;
+		int m = 0;
+		for (int i=0;i<front;i++){
+			target[i]=elementData[i];
+			m = i;	//5
+		}
+		System.out.println("m = "+m);
+		
+		for (int j=elementData.length-1;j>rear;j--){
+			n--;
+			target[n]=elementData[j];
+		}
+		n--;	//在这里 n-- m++ 是因为在 push1 push2 时候，先push进去，再++的
+		rear=n;
+		m++;
+		front=m;
+		this.data=target;
+	}
+	
+	public void iteration(){
+		for (int i=0;i<data.length;i++){
+			System.out.print(data[i]+",");
+		}
+		System.out.println();
+	}
+}