链式栈、顺序栈

Author: githubofrico

src/cn/edu/tju/rico/stack/LinkedStack.java

@@ -1,38 +1,76 @@
 package cn.edu.tju.rico.stack;
 
+import java.util.Comparator;
+
 /**
- * Title: 自定义链式栈 
- * Description: 链式栈的实现
- * 
+ * Title: 增强自定义链式栈 [通过维护一个栈来保证用O(1)的时间复杂度求栈中的最小元素 (空间换取时间)]
+ * Description: 使用额外的栈结构存储栈中的最小元素
+ * 				如果当前入栈的元素比原来栈中的最小值还小，则将其保存到最小值栈中；否则，不做任何操作。
+ *              如果当前出栈的元素正好是当前栈中的最小值，那么将最小值栈中的该最小值也一并弹出；否则，不做任何操作。
  * @author rico
  * @created 2017年4月6日 下午7:52:34
  */
 public class LinkedStack<E> {
-
+	
 	private Node<E> top; // 栈顶元素
 	private int size; // 链式栈的大小
-
+	
+	/**  最小值栈   (@author: rico) */    
+	private LinkedStack<E> min;
+	
 	// 构造函数
 	public LinkedStack(){
-		
 	}
-	
-	// 栈是否为空
+	  
+	/**     
+	 * @description 判断栈是否为空
+	 * @author rico       
+	 * @created 2017年5月14日 上午10:54:44     
+	 * @return     
+	 */
 	public boolean isEmpty() {
 		return size == 0;
 	}
 
-	// 压栈
+	/**     
+	 * @description 压栈
+	 * @author rico       
+	 * @param data     
+	 */
 	public void push(E data) {
-		Node<E> node = new Node<E>(data, top); // 新加入的元素指向栈顶元素
+		Node<E> node = new Node<E>(data); 
+		// 新加入的元素指向栈顶元素
+		node.next = top;
 		top = node;
 		size++;
 	}
+	
+	/**     
+	 * @description 压栈操作,使用最小值栈
+	 * @author rico       
+	 * @param data     
+	 */
+	public void push(E data, Comparator<? super E> c) {
+		push(data);
+		if(min == null){
+			min = new LinkedStack<E>();
+		}
+		if(min.peek() == null){
+			min.push(data);
+		}else if(c.compare(this.peek().data, min.peek().data) < 0){
+			min.push(data);
+		}
+	}
 
-	//弹栈(弹出并删除栈顶元素)
-	public Node<E> pop() throws Exception {
+	/**     
+	 * @description 弹出并删除栈顶元素
+	 * @author rico       
+	 * @return
+	 * @throws Exception     
+	 */
+	public Node<E> pop(){
 		if (isEmpty()) {
-			throw new Exception("栈为空...");
+			return null;
 		}
 
 		Node<E> node = top;
@@ -41,41 +79,75 @@ public Node<E> pop() throws Exception {
 		size--;
 		return node;
 	}
+	
+	/**     
+	 * @description 弹出并删除栈顶元素,使用最小值栈
+	 * @author rico       
+	 * @return
+	 * @throws Exception     
+	 */
+	public Node<E> pop(Comparator<? super E> c){
+		Node<E> temp = this.pop();
+		if(temp != null && min.peek() != null){
+			if(c.compare(temp.data, min.peek().data) == 0){
+				min.pop();
+			}
+		}
+		return temp;
+	}
+	
+	/**     
+	 * @description 弹出栈顶元素(不执行删除操作)
+	 * @author rico       
+	 * @return     
+	 */
+	public Node<E> peek(){
+		if (isEmpty()) {
+			return null;
+		}
+		return top;
+	}
 
-	// 打印栈
+	/**     
+	 * @description 获取当前栈中的最小值 
+	 * @author rico       
+	 * @return     
+	 */
+	public Node<E> min() {
+		if(min.peek() == null){
+			return null;
+		}else{
+			return min.peek();
+		}
+	}
+	
+	/**     
+	 * @description 打印栈
+	 * @author rico       
+	 */
 	public void print() {
 		Node<E> index = top;
 		while (index != null) {
 			System.out.print(index.data + " ");
 			index = index.next;
 		}
+		System.out.println();
 	}
-
-	
-	// 私有内部类
-	private class Node<T> {
-		private Node<T> next;
-		private T data;
-
-		public Node(T data, Node<T> node) {
-			this.data = data;
-			next = node;
-		}
+	  
+	/**     
+	 * @description 返回栈的大小
+	 * @author rico       
+	 * @return     
+	 */
+	public int size(){
+		return size;
 	}
 
-	//测试
-	public static void main(String[] args) throws Exception {
-		LinkedStack<String> stack = new LinkedStack<String>();
-		stack.push("Rico");
-		stack.push("TJU");
-		stack.push("Livia");
-		stack.push("NEU");
-
-		stack.print();
-
-		System.out.println();
+	public LinkedStack<E> getMin() {
+		return min;
+	}
 
-		stack.pop();
-		stack.print();
+	public void setMin(LinkedStack<E> min) {
+		this.min = min;
 	}
 }

src/cn/edu/tju/rico/stack/Node.java

@@ -0,0 +1,34 @@
+package cn.edu.tju.rico.stack;
+
+/**
+ * Title: 结点类 
+ * Description: 链表的基本元素
+ * 
+ * @author rico
+ * @created 2017年4月6日 下午9:55:58
+ */
+ public class Node<T> {
+	//包可见性
+	Node<T> next;   
+	T data;
+
+	/**
+	 * 构造函数
+	 * 
+	 * @description 构造一个新节点
+	 * @author rico
+	 * @created 2017年4月6日 下午9:56:56
+	 * @param data
+	 *            新元素数据
+	 * @param next
+	 *            新元素与链表结合节点
+	 */
+	public Node(T data) { 
+		this.data = data;
+	}
+
+	@Override
+	public String toString() {
+		return data.toString();
+	}
+}

src/cn/edu/tju/rico/test/LinkedStackTest.java

@@ -0,0 +1,44 @@
+package cn.edu.tju.rico.test;
+
+import java.util.Comparator;
+import cn.edu.tju.rico.stack.LinkedStack;
+  
+public class LinkedStackTest {
+	// 测试
+	public static void main(String[] args) throws Exception {
+		
+		LinkedStack<Integer> stack = new LinkedStack<Integer>();
+		Comparator<Integer> c = new Comparator<Integer>() {
+			@Override
+			public int compare(Integer o1, Integer o2) {
+				// TODO Auto-generated method stub
+				if(o1 > o2)
+					return 1;
+				else if(o1 < o2)
+					return -1;
+				else
+					return 0;
+			}
+		};
+		stack.push(7,c);
+		stack.push(6,c);
+		stack.push(8,c);
+		stack.push(5,c);
+		stack.push(3,c);
+		
+		System.out.println("原栈(最左边元素是栈顶元素)：");
+		stack.print();
+		System.out.println();
+		
+		System.out.println("弹出栈顶元素：");
+		System.out.println(stack.peek());
+		System.out.println("栈中的最小值：" + stack.min());
+		System.out.println();
+
+		System.out.println("弹出并删除栈顶元素后的链表：");
+		stack.pop(c);
+		stack.print();
+		System.out.println("栈中的最小值：" + stack.min());
+		System.out.println();
+	}
+}