数据结构之链表、栈和队列 java代码实现

定义抽象节点类Node：

package cn.wzbrilliant.datastructure;

/**
 * 节点
 * @author ice
 *
 */
public abstract class Node {
	private Node next;
	
	public Node(){
		next=null;
	}
	
	public void setNext(Node nextNode){
		next=nextNode;
	}
	
	public Node getNext(){
		return next;
	}
}

链表类，实现了插入首尾节点、指定位置节点，删除节点、指定位置节点，链表的逆序以及判空操作：

package cn.wzbrilliant.datastructure;

/**
 * 链表
 * @author ice
 *
 */
public class Link {
	
	protected Node head;
	protected Node tail;
	protected int size;

	public Link() {
		this.head = null;
		this.tail = null;
		this.size = 0;
	}
	
	public void addAtFirst(Node node){
		node.setNext(head);
		head=node;
		if(size==0)
			tail=node;
		size++;
	}
	
	public void addAtLast(Node node){
		if(size==0){
			head=tail=node;
		}else{
			tail.setNext(node);
			tail=node;
		}
		node.setNext(null);
		size++;
	}
	
	public void removeFirst(){
		if(size==0)
			throw new RuntimeException("link size is 0...");
		head=head.getNext();
		if(size==1){
			tail.setNext(null);
		}
		size--;
	}
	
	public void removeLast(){
		if(size==0)
			throw new RuntimeException("link size is 0...");
		
		if(size==1){
			head=tail=null;
			size--;
			return ;
		}
		
		Node node=head;
		while(node.getNext()!=tail){
			node=node.getNext();
		}
		node.setNext(null);
		tail=node;
		size--;
	}

	/**
	 * 队列逆序
	 */
	public void reverse() {
		Node preNode, node, tempNode;
		if (size == 0)
			return;
		preNode = head;
		node = preNode.getNext();
		preNode.setNext(null);
		tail = preNode;
		while (node != null) {
			tempNode = node.getNext();
			node.setNext(preNode);
			preNode = node;
			node = tempNode;
		}
		head = preNode;
	}

	/**
	 * 在第index个节点后插入newNode
	 * 
	 * @param newNode
	 * @param index
	 */
	public void insert(Node newNode, int index) {
		if (index < 0 || index > size)
			throw new RuntimeException("索引错误");

		if (index == 0) {
			newNode.setNext(head);
			head = newNode;
			size++;
			return;
		}

		if (index == size) {
			newNode.setNext(null);
			tail.setNext(newNode);
			tail = newNode;
			size++;
			return;
		}

		Node node = head;
		for (int i = 1; node != null; i++, node = node.getNext()) {
			if (i == index) {
				newNode.setNext(node.getNext());
				node.setNext(newNode);
				size++;
				return;
			}
		}

	}

	/**
	 * 移除Node节点    Node节点需重写equals()方法
	 * 
	 * @param node
	 */
	public void remove(Node node) {
		if (node == null || size == 0)
			throw new RuntimeException("remove error...");
		for (Node temp = head; temp != null; temp = temp.getNext()) {
			if (temp == head) {
				if (temp.equals(node)) {
					head = head.getNext();
					size--;
					continue;
				}
			}
			if (temp.getNext().equals(node)) {
				temp.setNext(temp.getNext().getNext());
				size--;
			}

		}
	}

	public Node getFirst() {
		if (size == 0)
			return null;
		return head;
	}

	public Node getLast() {
		if (size == 0)
			return null;
		return tail;
	}

	public int size() {
		return size;
	}

	public boolean isEmpty() {
		if (size == 0)
			return true;
		return false;
	}
}

栈类，实现了入栈、出战、获取栈顶元素以及判空的操作：

package cn.wzbrilliant.datastructure;

/**
 * 栈
 * @author ice
 *
 */
public class Stack {
	private int size;
	private Node top;

	public Stack() {
		size = 0;
		top = null;
	}

	public void push(Node node) {
		node.setNext(top);
		top = node;
		size++;
	}

	public Node pop() {
		if (top == null)
			return null;
		Node node = top;
		top = top.getNext();
		size--;
		return node;
	}

	public Node top() {
		return top;
	}

	public int size() {
		return size;
	}

	public boolean isEmpty() {
		if (size == 0)
			return true;
		return false;
	}
}

队列类，实现了入队、出队、判空的操作：

package cn.wzbrilliant.datastructure;

/**
 * 队列
 * @author ice
 *
 */
public class Queue {

	private Node head;
	private Node tail;
	private int size;

	public Queue() {
		this.head = null;
		this.tail = null;
		this.size = 0;
	}

	public void enQueue(Node node) {
		tail.setNext(node);
		tail = node;
		size++;
	}

	public Node deQueue() {
		if (size == 0)
			return null;
		Node node = head;
		head = head.getNext();
		size--;
		return node;
	}

	public int size() {
		return size;
	}

	public boolean isEmpty() {
		if (size == 0)
			return true;
		return false;
	}

}