121111914 作业：stack练习

group24/121111914/src/com/github/ipk2015/coding2017/basic/stack/QuickMinStack.java

@@ -0,0 +1,37 @@
+package com.github.ipk2015.coding2017.basic.stack;
+
+import java.util.HashMap;
+
+/**
+ * 设计一个栈，支持栈的push和pop操作，以及第三种操作findMin, 它返回改数据结构中的最小元素
+ * finMin操作最坏的情形下时间复杂度应该是O(1) ， 简单来讲，操作一次就可以得到最小值
+ * @author liuxin
+ *
+ */
+public class QuickMinStack {
+	private Stack normalStack = new Stack();
+	private Stack minStack = new Stack();
+	public void push(int data){
+		normalStack.push(data);
+		if(minStack.isEmpty()){
+			minStack.push(data);
+		}else{
+			if(data <= (Integer)minStack.peek()){
+				minStack.push(data);
+			}
+		}
+	}
+	public int pop(){
+		int element = (Integer)normalStack.pop();
+		if(element == (Integer)minStack.peek()){
+			minStack.pop();
+		}
+		return element;
+	}
+	public int peek(){
+		return (Integer)normalStack.peek();
+	}
+	public int findMin(){
+		return (Integer)minStack.peek();
+	}
+}

group24/121111914/src/com/github/ipk2015/coding2017/basic/stack/StackWithTwoQueues.java

@@ -0,0 +1,42 @@
+package com.github.ipk2015.coding2017.basic.stack;
+
+import com.github.ipk2015.coding2017.basic.queue.Queue;
+
+public class StackWithTwoQueues {
+
+	private Queue queue1 = new Queue();
+	private Queue queue2 = new Queue();
+
+    public void push(Object data) {       
+    	queue1.enQueue(data);
+    }
+
+    public Object pop() {
+    	if(queue1.size() == 1){
+    		return queue1.deQueue();
+    	}
+    	if(queue2.isEmpty()){
+    		moveElements(queue1,queue2);
+    	}
+       return queue2.deQueue();
+    }
+
+    private void moveElements(Queue oirQueue,Queue aimQueue){
+    	if(oirQueue.isEmpty()){
+    		return;
+    	}else{
+    		Object element = oirQueue.deQueue();
+    		moveElements(oirQueue,aimQueue);
+    		aimQueue.enQueue(element);
+    	}
+    }
+
+    public boolean isEmpty(){
+		return queue1.isEmpty() && queue2.isEmpty();
+	}
+
+    public int size(){
+		return queue1.size()+queue2.size();
+	}
+
+}

group24/121111914/src/com/github/ipk2015/coding2017/basic/stack/TwoStackInOneArray.java

@@ -0,0 +1,83 @@
+package com.github.ipk2015.coding2017.basic.stack;
+
+/**
+ * 用一个数组实现两个栈
+ * 将数组的起始位置看作是第一个栈的栈底，将数组的尾部看作第二个栈的栈底，压栈时，栈顶指针分别向中间移动，直到两栈顶指针相遇，则扩容。
+ * @author liuxin
+ *
+ */
+public class TwoStackInOneArray {
+	Object[] data = new Object[10];
+	private int pointer1 = 0;
+	private int pointer2 = 9;
+
+	/**
+	 * 向第一个栈中压入元素
+	 * @param o
+	 */
+	public void push1(Object o){
+		if(pointer1 == pointer2){
+			enlargeDataArray();
+		}
+		data[pointer1++] = o;
+	}
+
+	private void enlargeDataArray(){
+		Object[] newData = new Object[data.length+100];
+		for(int i = 0;i < pointer1;i++){
+			newData[i] = data[i];
+		}
+		for(int i = pointer2+1;i < data.length;i++){
+			newData[i+100] = data[i];
+		}
+		pointer2 += 100;
+		data = newData;
+	}
+	/**
+	 * 从第一个栈中弹出元素
+	 * @return
+	 */
+	public Object pop1(){
+		Object object = data[pointer1-1];
+		data[pointer1-1] = null;
+		pointer1--;
+		return object;
+	}
+
+	/**
+	 * 获取第一个栈的栈顶元素
+	 * @return
+	 */
+
+	public Object peek1(){
+		return data[pointer1-1];
+	}
+	/*
+	 * 向第二个栈压入元素
+	 */
+	public void push2(Object o){
+		if(pointer1 == pointer2){
+			enlargeDataArray();
+		}
+		data[pointer2--] = o;
+	}
+	/**
+	 * 从第二个栈弹出元素
+	 * @return
+	 */
+	public Object pop2(){
+		Object object = data[pointer2+1];
+		data[pointer2+1] = null;
+		pointer2++;
+		return object;
+	}
+	/**
+	 * 获取第二个栈的栈顶元素
+	 * @return
+	 */
+
+	public Object peek2(){
+		return data[pointer2+1];
+	}
+
+}

group24/121111914/src/com/github/ipk2015/coding2017/basic/test/QuickMinStackTest.java

@@ -0,0 +1,56 @@
+package com.github.ipk2015.coding2017.basic.test;
+
+import static org.junit.Assert.*;
+
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+
+import com.github.ipk2015.coding2017.basic.stack.QuickMinStack;
+
+public class QuickMinStackTest {
+	QuickMinStack stack;
+	@Before
+	public void setUp() throws Exception {
+		stack = new QuickMinStack();
+	}
+
+	@After
+	public void tearDown() throws Exception {
+	}
+
+	@Test
+	public void testPush() {
+		stack.push(11);
+		assertEquals(11, stack.peek());
+		stack.push(22);
+		assertEquals(22, stack.peek());
+	}
+
+	@Test
+	public void testPop() {
+		stack.push(11);
+		stack.push(22);
+		stack.push(33);
+		assertEquals(33, stack.pop());
+		assertEquals(22, stack.pop());
+		assertEquals(11, stack.pop());
+	}
+
+	@Test
+	public void testFindMin() {
+
+		stack.push(4);
+		stack.push(2);
+		stack.push(3);
+		stack.push(5);
+		assertEquals(2, stack.findMin());
+		stack.pop();
+		assertEquals(2, stack.findMin());
+		stack.pop();
+		assertEquals(2, stack.findMin());
+		stack.pop();
+		assertEquals(4, stack.findMin());
+	}
+
+}