数据结构之栈和队列

1.基本概念

栈 (Stack)是一种后进先出(last in first off，LIFO)的数据结构，而队列(Queue)则是一种先进先出 (fisrt in first out，FIFO)的结构，如下图：

2.链表实现的栈 

/** 
 * @Title: LinkedStack.java 
 * @Package io.shaoshuai.datastructure 
 * @Description: TODO
 * @author 帅 
 * @date 2015年5月15日 下午6:27:32 
 * @version V1.0 
 */  
package io.shaoshuai.datastructure;

import java.util.Iterator;

/** 
 * @ClassName: LinkedStack 
 * @Description: TODO
 * @author 帅
 * @date 2015年5月15日 下午6:27:32 
 *  
 */
public class LinkedStack implements Iterable{
	
	/**
	 * 往栈中添加一个新的元素
	 * @param item
	 */
	public void push(E item){
		Node oldFirst = first;
		first = new Node(item);
		first.next = oldFirst;
		size ++;
	}
	
	/**
	 * 移除并返回最近添加的元素
	 * @return
	 */
	public E pop(){
		E item = first.item;
		first = first.next;
		size --;
		return item;
	}
	
	/**
	 * 栈是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return size == 0;
	}
	
	/**
	 * 栈中元素的个数
	 * @return
	 */
	public int size(){
		return size;
	}
	
	private Node first;
	private int size;
	
	/**
	 * 单向链表数据结构
	 * @ClassName: Node 
	 * @Description: TODO
	 * @author 帅
	 * @date 2015年5月18日 上午12:19:53 
	 * 
	 * @param 
	 */
	private static class Node {
		public E item;
		public Node next;
		
		public Node(E item) {
			this.item = item;
		}
	}

	/**
	 * 栈的迭代器
	 */
	@Override
	public Iterator iterator() {
		return new Iterator(){
			private Node current = first;
			
			@Override
			public boolean hasNext() {
				return current != null;
			}
	
			@Override
			public E next() {
				E item = current.item;
				current = current.next;
				return item;
			}
	
			@Override
			public void remove() {
				first = first.next;
				size --;
			}
		};
	}
	
	public static void main(String[] args) {
		LinkedStack linkedStack = new LinkedStack();
		linkedStack.push(new String("1"));
		linkedStack.push(new String("2"));
		linkedStack.push(new String("3"));
		linkedStack.push(new String("4"));
		linkedStack.push(new String("5"));
		linkedStack.push(new String("6"));
		System.out.println(linkedStack.size());
		System.out.println(linkedStack.isEmpty());
		System.out.println(linkedStack.pop());
		System.out.println(linkedStack.size());
	}
}

3.数组实现的栈

/** 
 * @Title: ArrayStack.java 
 * @Package io.shaoshuai.datastructure 
 * @Description: TODO
 * @author 帅 
 * @date 2015年5月15日 下午7:21:39 
 * @version V1.0 
 */  
package io.shaoshuai.datastructure;


/** 
 * @ClassName: ArrayStack 
 * @Description: TODO
 * @author 帅
 * @date 2015年5月15日 下午7:21:39 
 *  
 */
public class ArrayStack {
	
	private static final int DEFAULT_CAPACITY = 1<<4;
	
	private E[] elements;
	private int size;
	
	@SuppressWarnings("unchecked")
	public ArrayStack() {
		elements = (E[]) new Object[DEFAULT_CAPACITY];
	}
	
	@SuppressWarnings("unchecked")
	public ArrayStack(int capacity) {
		elements = (E[]) new Object[capacity];
	}
	
	/**
	 * 往栈中添加一个新的元素
	 * @param item
	 */
	public void push(E item){
		if(size == elements.length) {
			resize(elements.length * 2);
		}
		elements[size++] = item;
	}
	
	/**
	 * 移除并返回最近添加的元素
	 * @return
	 */
	public E pop(){
		E element = elements[--size];
		//elements[size] = default(E);
		if(size > 0 && size == elements.length/4) {
			resize(elements.length/2);
		}
		return element;
	}
	
	/**
	 * 栈是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return size == 0;
	}
	
	/**
	 * 栈中元素的个数
	 * @return
	 */
	public int size(){
		return size;
	}
	
	@SuppressWarnings("unchecked")
	private void resize(int capacity){
		E[] tmp = (E[]) new Object[capacity];
		for (int i = 0; i < capacity; i++) {
			tmp[i]=elements[i];
		}
		elements = tmp;
	}
	
	public static void main(String[] args) {
		ArrayStack stack = new ArrayStack();
		stack.push(new String("1"));
		stack.push(new String("2"));
		stack.push(new String("3"));
		stack.push(new String("4"));
		stack.push(new String("5"));
		stack.push(new String("6"));
		System.out.println(stack.size());
		System.out.println(stack.isEmpty());
		System.out.println(stack.pop());
		System.out.println(stack.size());
	}
}

4.链表实现的队列

/** 
 * @Title: LinkedQueue.java 
 * @Package io.shaoshuai.datastructure 
 * @Description: TODO
 * @author 帅 
 * @date 2015年5月15日 下午3:08:43 
 * @version V1.0 
 */  
package io.shaoshuai.datastructure;

import java.util.Iterator;

/** 
 * @ClassName: LinkedQueue 
 * @Description: TODO
 * @author 帅
 * @date 2015年5月15日 下午3:08:43 
 *  
 */
public class LinkedQueue implements Iterable{

	private Node first;
	private Node last;
	private int size;
	
	public LinkedQueue(){
	}
	
	/**
	 * 往队列中添加一个新的元素
	 * @param item
	 */
	public void enLinkedQueue(E item){
		Node oldLast = last;
		last = new Node(item);
		if(isEmpty()) {
			first = last;
		}else {
			oldLast.next = last;
		}
		size++;
	}
	
	/**
	 * 移除队列中最早添加的元素
	 * @return
	 */
	public E deLinkedQueue(){
		E item = first.item;
		first = first.next;
		size --;
		if(isEmpty()) {
			last = null;
		}
		return item;
	}
	
	/**
	 * 队列是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return size == 0;
	}
	
	/**
	 * 队列中元素的个数
	 * @return
	 */
	public int size(){
		return size;
	}

	@Override
	public Iterator iterator() {
		return null;
	}
	
	private static class Node {
		private E item;
		private Node next;
		
		public Node(E item) {
			this.item = item;
		}
		

	}
	
	public static void main(String[] args) {
		LinkedQueue linkedQueue = new LinkedQueue();
		linkedQueue.enLinkedQueue("1");
		linkedQueue.enLinkedQueue("2");
		linkedQueue.enLinkedQueue("3");
		linkedQueue.enLinkedQueue("4");
		linkedQueue.enLinkedQueue("5");
		System.out.println("size:" + linkedQueue.size());
		System.out.println(linkedQueue.deLinkedQueue());
		System.out.println(linkedQueue.deLinkedQueue());
		System.out.println("size:" + linkedQueue.size());
	}
}

5.数组实现的队列

/** 
 * @Title: ArrayQueue.java 
 * @Package io.shaoshuai.datastructure 
 * @Description: TODO
 * @author 帅 
 * @date 2015年5月15日 下午10:51:59 
 * @version V1.0 
 */  
package io.shaoshuai.datastructure;

import java.util.Iterator;

/** 
 * @ClassName: ArrayQueue 
 * @Description: TODO
 * @author 帅
 * @date 2015年5月15日 下午10:51:59 
 *  
 */
public class ArrayQueue implements Iterable{

	private static final int DEFAULT_CAPACITY = 1<<4;
	
	private E[] elements;
	private int head;
	private int tail;
	private int size;
	
	@SuppressWarnings("unchecked")
	public ArrayQueue() {
		elements = (E[]) new Object[DEFAULT_CAPACITY];
	}
	
	@SuppressWarnings("unchecked")
	public ArrayQueue(int capacity) {
		elements = (E[]) new Object[capacity];
	}
	
	/**
	 * 往队列中添加一个新的元素
	 * @param item
	 */
	public void enqueue(E element){
		if((head - tail + 1) == elements.length) {
			resize(elements.length * 2);
		}
		elements[tail] = element;
		tail = (++tail == elements.length ? 0 : tail);
		size ++;
	}
	
	/**
	 * 移除队列中最早添加的元素
	 * @return
	 */
	public E dequeue(){
		E element = elements[head];
		if(head > 0 && (tail - head + 1) == elements.length/4){
			resize(elements.length/2);
		}
		head = (++head == elements.length ? 0 : head);
		size--;
		return element;
	}
	
	/**
	 * 队列是否为空
	 * @return
	 */
	public boolean isEmpty(){
		return size == 0;
	}
	
	/**
	 * 队列中元素的个数
	 * @return
	 */
	public int size(){
		return size;
	}
	
	@SuppressWarnings("unchecked")
	public void resize(int capacity){
		E[] tmp = (E[]) new Object[capacity];
		for(int i=0;i iterator() {
		return null;
	}
	
	
	public static void main(String[] args) {
		ArrayQueue queue = new ArrayQueue();
		queue.enqueue("1");
		queue.enqueue("2");
		queue.enqueue("3");
		queue.enqueue("4");
		queue.enqueue("5");
		System.out.println("size:" + queue.size());
		System.out.println(queue.dequeue());
		System.out.println(queue.dequeue());
		System.out.println(queue.dequeue());
		System.out.println("size:" + queue.size());
	}
}

6.Stack和Queue的应用

未完待续