java链表、数组实现栈、队列

栈和队列： 栈和队列是在程序中被广泛使用的两种重要的线性结构，都是在一个特定范围的储存单元中存储的数据。二者的区别在于：栈先进去的数据只能最后被取出来，即先进后出。队列就像人们买东西，先排队的人先买，即先进先出。
链表实现栈
构建结点：

class Node<E>{
	Node<E> next=null;
	E data;
	public Node(E data) {
		this.data=data;
	}
}

实现：

public class Stack<E>{
	Node<E> top=null;
	public boolean isEmpty() {		
		return top==null;
	}
	
	public void push(E data) {//入栈
		Node<E> newNode=new Node<E>(data);//建立一个新结点
		newNode.next=top;
		top=newNode;
	}

	public E pop() {//出栈
		if(this.isEmpty())//判断栈是否为空 
			return null;
		E data=top.data;
		top=top.next;
		return data;
		}
	
	public E peek() {//获取栈顶元素
		if(isEmpty()) {
			return null;
		}
		return top.data;
	}
	public void print() {//打印栈中元素
		Node<E> tmp;
		for(tmp=top;tmp!=null;tmp=tmp.next) {
			System.out.println(tmp.data);
		}
	}
}

数组实现栈：

public class MyStack<E>{
	private Object[] stack;
	private int size;
	public MyStack() {
		stack=new Object[10];
	}
	
	public boolean isEmpty() {
		return size==0;
	}
	// 返回栈顶的一个元素，但是不进行出栈操作
	
	public E peek() {
		if(isEmpty()) {
			return null;
		}
		return(E) stack[size-1];//返回栈顶元素
	}
	
	public E pop() {
		E e=peek();
		stack[size-1]=null;
		size--;
		return e;
	}
	
	public E push(E item) {
		ensureCapacity(size+1);
		stack[size++]=item;
		return item;
	}
	//当栈满的时候，对栈进行扩容
	public void ensureCapacity(int size) {
		int len=stack.length;
		if(size>len) {
			int newLen=10;//数组已满
			stack=Arrays.copyOf(stack, newLen);//每次数组扩充的容量
		}
	}
}

用链表实现队列:
构建结点

class Node<E>{
	Node<E> next=null;
	E data;
	public Node(E data) {
		this.data=data;
	}
}

实现：

public class MyQueue<E> {
	private Node<E> head=null;//定义头结点
	private Node<E> tail=null;//定义尾结点
	
	public boolean isEmpty() {
		return head==tail;
	}
	
	public void put(E data) {
		Node<E> newNode=new Node<E>(data);
		if(head==null&&tail==null) //队列为空
			head=tail=newNode;
		else {
			tail.next=newNode;
			tail=newNode;
		}
	}
	public E pop() {
		if(this.isEmpty()) {
			return null;
		}
		E data=head.data;
		head=head.next;
		return data;
	}
	
	public void size() {
		Node<E> tmp=head;
		int n=0;
		while(tmp!=null) {
			n++;
			tmp=tmp.next;			
		}
		System.out.println(n);
	}
	
	public void print() {
		Node tmp=head;
		while(tmp!=null) {
			System.out.println(tmp.data);
			tmp=tmp.next;
		}
	}
}

数组实现队列：

public class MyQueue1<E>{
	private LinkedList<E> list=new LinkedList<E>();
	private int size=0;
	public synchronized void put(E e) {
		list.addLast(e);
		size++;
	}
	public synchronized E pop() {
		size--;
		return list.removeFirst();
	}
	public synchronized boolean empty() {
		return size==0;
	}
	public synchronized int size() {
		return size;
	}
}