数据结构——链表

链表分类

1. 普通链表
2. 双端链表 链表中保存着对最后一个链节点引用的链表。
   方便从尾结点插入数据。
3. 双向链表 每个节点除了保存对下一个对象的引用，同时还保存着对前一个节点的引用。

特点：

• 查询慢,修改也慢
• 增删快

普通链表Java实现

创建节点类

/**
 * 链节点类
 * 
 * @author tiger
 * 
 */
public class Node {
	// 数据域（保存节点的数据）
	public long data;
	// 指针域（下一个节点的引用）
	public Node next;

	public Node(long value) {
		this.data = value;
	}
	
	/**
	 * 显示方法
	 */
	public void display(){
		System.out.print(data+" ");
	}
	
}

创建链表类

/**
 * 链表
 * 
 * @author tiger
 * 
 */
public class LinkList {
	// 头结点
	private Node first;

	public LinkList() {
		first = null;
	}

	/**
	 * 插入一个节点，在头结点后进行插入
	 * 
	 * @param value
	 */
	public void insertFirst(long value) {
		Node node = new Node(value);
		node.next = first;
		first = node;
	}

	/**
	 * 删除一个节点，在头结点进行删除
	 */
	public Node deleteFirst() {
		Node tmp = first;
		first = tmp.next;
		return tmp;
	}

	/**
	 * 显示方法
	 */
	public void display() {
		Node current = first;
		while (current != null) {
			current.display();
			current = current.next;
		}
	}

	/**
	 * 通过节点中的数据查找指定节点
	 * 
	 * @param value
	 * @return
	 */
	public Node find(long value) {
		Node current = first;
		while (current.data != value) {
			if (current.next == null) {
				return null;
			}
			current = current.next;
		}
		return current;
	}

	/**
	 * 删除方法，根据数据域进行删除
	 * 
	 * @param value
	 * @return
	 */
	public Node delete(long value) {
		Node current = first;
		Node previous = first;
		while (current.data != value) {
			if (current.next == null) {
				return null;
			}
			previous = current;
			current = current.next;
		}
		if (current == first) {
			first = first.next;
		} else {
			previous.next = current.next;
		}
		return current;
	}

}

双端链表Java实现
节点类同上。
创建一个双端链表类

/**
 * 双端链表
 * 
 * @author tiger
 * 
 */
public class FirstLastLinkList {
	// 头结点
	private Node first;
	// 尾结点
	private Node last;

	public FirstLastLinkList() {
		first = null;
		last = null;
	}

	/**
	 * 插入一个节点，在头结点后进行插入
	 * 
	 * @param value
	 */
	public void insertFirst(long value) {
		Node node = new Node(value);
		if (isEmpty()) {
			last = node;
		}
		node.next = first;
		first = node;
	}

	/**
	 * 插入一个节点，从尾节点进行插入
	 * 
	 * @param value
	 */
	public void insertLast(long value) {
		Node node = new Node(value);
		if (isEmpty()) {
			first = node;
		} else {
			last.next = node;
		}
		last = node;
	}

	/**
	 * 删除一个节点，在头结点进行删除
	 */
	public Node deleteFirst() {
		Node tmp = first;
		if (first.next == null) {
			last = null;
		}
		first = tmp.next;
		return tmp;
	}

	/**
	 * 显示方法
	 */
	public void display() {
		Node current = first;
		while (current != null) {
			current.display();
			current = current.next;
		}
	}

	/**
	 * 通过节点中的数据查找指定节点
	 * 
	 * @param value
	 * @return
	 */
	public Node find(long value) {
		Node current = first;
		while (current.data != value) {
			if (current.next == null) {
				return null;
			}
			current = current.next;
		}
		return current;
	}

	/**
	 * 删除方法，根据数据域进行删除
	 * 
	 * @param value
	 * @return
	 */
	public Node delete(long value) {
		Node current = first;
		Node previous = first;
		while (current.data != value) {
			if (current.next == null) {
				return null;
			}
			previous = current;
			current = current.next;
		}
		if (current == first) {
			first = first.next;
		} else {
			previous.next = current.next;
		}
		return current;
	}

	/**
	 * 判断是否为空
	 */
	public boolean isEmpty() {
		return first == null;
	}

}

双向链表Java实现

创建一个节点类

/**
 * 链节点类
 * 
 * @author tiger
 * 
 */
public class Node {
	// 数据域（保存节点的数据）
	public long data;
	// 指针域（下一个节点的引用）
	public Node next;
	// 指针域（上一个节点的引用）
	public Node previouse;
	
	public Node(long value) {
		this.data = value;
	}
	
	/**
	 * 显示方法
	 */
	public void display(){
		System.out.print(data+" ");
	}
	
}

创建一个双向链表类

/**
 * 双向链表
 * 
 * @author tiger
 * 
 */
public class DoubleLinkList {
	// 头结点
	private Node first;
	// 尾结点
	private Node last;

	public DoubleLinkList() {
		first = null;
		last = null;
	}

	/**
	 * 插入一个节点，在头结点后进行插入
	 * 
	 * @param value
	 */
	public void insertFirst(long value) {
		Node node = new Node(value);
		if (isEmpty()) {
			last = node;
		} else {
			first.previouse = node;
		}
		node.next = first;
		first = node;
	}

	/**
	 * 插入一个节点，从尾节点进行插入
	 * 
	 * @param value
	 */
	public void insertLast(long value) {
		Node node = new Node(value);
		if (isEmpty()) {
			first = node;
		} else {
			last.next = node;
			node.previouse = last;
		}
		last = node;
	}

	/**
	 * 删除一个节点，在头结点进行删除
	 */
	public Node deleteFirst() {
		Node tmp = first;
		if (first.next == null) {
			last = null;
		} else {
			first.next.previouse = null;
		}
		first = tmp.next;
		return tmp;
	}

	/**
	 * 删除节点，从尾部进行删除
	 * 
	 * @return
	 */
	public Node deleteLast() {
		Node tmp = last;
		if (first.next == null) {
			first = null;
		} else {
			last.previouse.next = null;
		}
		last = last.previouse;
		return tmp;
	}

	/**
	 * 显示方法
	 */
	public void display() {
		Node current = first;
		while (current != null) {
			current.display();
			current = current.next;
		}
	}

	/**
	 * 通过节点中的数据查找指定节点
	 * 
	 * @param value
	 * @return
	 */
	public Node find(long value) {
		Node current = first;
		while (current.data != value) {
			if (current.next == null) {
				return null;
			}
			current = current.next;
		}
		return current;
	}

	/**
	 * 删除方法，根据数据域进行删除
	 * 
	 * @param value
	 * @return
	 */
	public Node delete(long value) {
		Node current = first;
		while (current.data != value) {
			if (current.next == null) {
				return null;
			}
			current = current.next;
		}
		if (current == first) {
			first = first.next;
		} else {
			current.next.previouse = current.previouse;
			current.previouse.next = current.next;
		}
		return current;
	}

	/**
	 * 判断是否为空
	 */
	public boolean isEmpty() {
		return first == null;
	}

}