第九周数据结构作业done

group24/75939388/learning2017/src/main/java/basic/dataStructure/stack/QuickMinStack.java

@@ -0,0 +1,82 @@
+package basic.dataStructure.stack;
+
+/**
+ * 设计一个栈，支持栈的push和pop操作，以及第三种操作findMin, 它返回改数据结构中的最小元素
+ * finMin操作最坏的情形下时间复杂度应该是O(1) ， 简单来讲，操作一次就可以得到最小值
+ * @author liuxin
+ *
+ */
+public class QuickMinStack {
+
+	private int defaultSize = 10;
+	private int extendSize = 10;
+	Object[] elements = new Object[defaultSize];
+
+	private int min = -1;
+
+	private int size = 0;
+	public QuickMinStack(){}
+
+	public boolean isEmpty(){
+		boolean flag = false;
+		for(int i = 0; i < elements.length; i++){
+			if(elements[i] != null){
+				return false;
+			}
+
+			flag = elements == null;
+		}
+		return flag;
+	}
+
+	public void push(int data){
+		if(isEmpty()){
+			this.min = data;
+		}else{
+			this.min = data < min ? data : min;
+		}
+		size ++;
+		elements[size - 1] = data;
+		if(size >= elements.length){
+			extend();
+		}
+	}
+	public int pop(){
+		Integer d = (Integer)elements[size - 1];
+		elements[size - 1] = null;
+		size--;
+		return d;
+	}
+
+	public int findMin(){
+		return this.min;
+	}
+
+	public int size(){
+		return this.size;
+	}
+
+	private void extend(){
+		int curSize = elements.length;
+		Object[] arr = new Object[curSize + extendSize];
+
+		System.arraycopy(elements, 0, arr, 0, curSize);
+
+		this.elements = arr;
+	}
+
+	@Override
+	public String toString() {
+		StringBuilder sb = new StringBuilder("[");
+		for(int i = size - 1; i >= 0; i--){
+			sb.append(elements[i]);
+			if(i > 0){
+				sb.append(",");
+			}else{
+				sb.append("]");
+			}
+		}
+
+		return sb.toString();
+	}
+}

group24/75939388/learning2017/src/main/java/basic/dataStructure/stack/StackWithTwoQueues.java

@@ -0,0 +1,50 @@
+package basic.dataStructure.stack;
+
+import basic.dataStructure.queue.Queue;
+
+/**
+ * 用两个队列实现一个栈
+ */
+public class StackWithTwoQueues {
+
+    Queue queue1 = null;
+    Queue queue2 = null;
+
+    private int data = -1;
+
+    public StackWithTwoQueues(){
+        queue1 = new Queue();
+        queue2 = new Queue();
+    }
+    public void push(int data) {       
+        queue1.enQueue(data);
+    }
+
+    public int pop() {
+        move();
+        return this.data;
+    }
+
+
+    /**
+     * queue1是数据保存队列， queue2是缓存队列
+     * 每次取之前将queue1的n-1个数据移动至queue2
+     * 取出queue的最后一个数据即可
+     */
+    private void move(){
+        if(queue2.isNotEmpty()){
+            throw new RuntimeException("queue2 is not empty, operation aborted");
+        }
+
+        int size = queue1.size();
+        for(int i = 0; i < size - 1; i++){
+            queue2.enQueue(queue1.deQueue());
+        }
+
+        data = (Integer)queue1.deQueue();
+
+        for(int i = 0; i < size - 1; i++){
+            queue1.enQueue(queue2.deQueue());
+        }
+    }
+}

group24/75939388/learning2017/src/main/java/basic/dataStructure/stack/TwoStackInOneArray.java

@@ -0,0 +1,156 @@
+package basic.dataStructure.stack;
+
+/**
+ * 用一个数组实现两个栈
+ * 将数组的起始位置看作是第一个栈的栈底，将数组的尾部看作第二个栈的栈底，
+ * 压栈时，栈顶指针分别向中间移动，直到两栈顶指针相遇，则扩容。
+ *
+ * @author liuxin
+ */
+public class TwoStackInOneArray {
+    Object[] data = new Object[10];
+
+    private int index1 = 0;
+    private int index2 = 9;
+
+    private int size1 = 0;
+    private int size2 = 0;
+
+    /**
+     * 向第一个栈中压入元素
+     *
+     * @param o
+     */
+    public void push1(Object o) {
+        data[index1] = o;
+        this.index1++;
+        this.size1 += 1;
+
+        if (size1 + size2 >= data.length) extend();
+    }
+
+    /**
+     * 从第一个栈中弹出元素
+     *
+     * @return
+     */
+    public Object pop1() {
+        int index = index1 - 1;
+        Object obj = data[index];
+        //直接置空
+        data[index] = null;
+        this.index1 = index;
+        this.size1--;
+        return obj;
+    }
+
+    /**
+     * 获取第一个栈的栈顶元素
+     *
+     * @return
+     */
+
+    public Object peek1() {
+        int index = index1 - 1;
+        Object obj = data[index];
+
+        return obj;
+    }
+
+    /*
+     * 向第二个栈压入元素
+     */
+    public void push2(Object o) {
+        data[index2] = o;
+        index2--;
+        this.size2 += 1;
+
+        if (size1 + size2 >= data.length) extend();
+    }
+
+    /**
+     * 从第二个栈弹出元素
+     *
+     * @return
+     */
+    public Object pop2() {
+        int index = index2 + 1;
+        Object obj = data[index];
+
+        data[index] = null;
+        this.index2 = index;
+        this.size2--;
+        return obj;
+    }
+
+    /**
+     * 获取第二个栈的栈顶元素
+     *
+     * @return
+     */
+
+    public Object peek2() {
+        int index = index2 + 1;
+        Object obj = data[index];
+        return obj;
+    }
+
+    public int size1() {
+        return this.size1;
+    }
+
+    public int size2() {
+        return this.size2;
+    }
+
+    /**
+     * 扩容
+     */
+    private void extend() {
+        int size = data.length;
+        int extendSize = 10;
+        Object[] extended = new Object[size + extendSize];
+
+        //stack1
+        //因为指针在数据添加后已经加上了，所以要减回去
+        for (int i = 0; i <= index1 - 1; i++) {
+            extended[i] = data[i];
+        }
+
+        //stack2
+        //因为指针在添加后已经减掉了1，所以要加回去
+        for (int i = index2 + 1; i <= size - 1; i++) {
+            int index = i + extendSize;
+            extended[index] = data[i];
+        }
+        this.data = extended;
+        this.index2 += extendSize;
+    }
+
+    @Override
+    public String toString() {
+
+        StringBuilder sb = new StringBuilder();
+        sb.append("stack1 -> [");
+        for (int i = index1 - 1; i >= 0; i--) {
+            sb.append(data[i]);
+            if (i == 0) {
+                sb.append("]");
+            } else {
+				sb.append(",");
+            }
+        }
+
+        sb.append("\nstack2 -> [");
+        int length = data.length;
+        for (int i = index2 + 1; i < length; i++) {
+            sb.append(data[i]);
+            if (i == length - 1){
+                sb.append("]");
+            } else {
+                sb.append(",");
+            }
+        }
+        return sb.toString();
+    }
+}

group24/75939388/learning2017/src/main/java/designPattern/decorator/Beverage.java

@@ -0,0 +1,23 @@
+package designPattern.decorator;
+
+/**
+ * @author : 温友朝
+ * @date : 2017/5/5
+ */
+public abstract class Beverage {
+    public static final int TALL = 0;
+    public static final int GRANDE = 1;
+    public static final int VENTI = 2;
+
+
+    public String description = "";
+    public static int size = TALL;
+
+    public String getDescription(){
+        return description;
+    }
+
+    public abstract double cost();
+
+    public abstract int size();
+}

group24/75939388/learning2017/src/main/java/designPattern/decorator/CondimentDecorator.java

@@ -0,0 +1,9 @@
+package designPattern.decorator;
+
+/**
+ * @author : 温友朝
+ * @date : 2017/5/5
+ */
+public abstract class CondimentDecorator extends Beverage {
+    public abstract String getDescription();
+}

group24/75939388/learning2017/src/main/java/designPattern/decorator/beverages/DarkRoast.java

@@ -0,0 +1,24 @@
+package designPattern.decorator.beverages;
+
+import designPattern.decorator.Beverage;
+
+/**
+ * @author : 温友朝
+ * @date : 2017/5/5
+ */
+public class DarkRoast extends Beverage {
+
+    public DarkRoast(){
+        description = "Dark Roast";
+    }
+
+    @Override
+    public double cost() {
+        return 0.99;
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+}

group24/75939388/learning2017/src/main/java/designPattern/decorator/beverages/Decaf.java

@@ -0,0 +1,24 @@
+package designPattern.decorator.beverages;
+
+import designPattern.decorator.Beverage;
+
+/**
+ * @author : 温友朝
+ * @date : 2017/5/5
+ */
+public class Decaf extends Beverage {
+
+    public Decaf(){
+        description = "Decaf";
+    }
+
+    @Override
+    public double cost() {
+        return 1.99;
+    }
+
+    @Override
+    public int size() {
+        return 0;
+    }
+}