线性表——链表

public class LNode<T> {
	T data;
	LNode<T> pre;
	LNode<T> next;
	
	public LNode() {
		this.data = null;
		this.next = null;
		this.pre = null;
	}
	public LNode(T data, LNode<T> pre, LNode<T> next) {
		this.data = data;
		this.pre = pre;
		this.next = next;
	}
	

}

import java.util.Iterator;

public class LinkList<T> {
	
	int length; //计算链表长度
	private LNode<T> header; 
	private LNode<T> tail;
	/**
	 * 构造有头尾结点的双向链表，链表长度为0
	 */
	public LinkList() {
		header = new LNode<T>();
		tail = new LNode<T>();
		header.next = tail;
		tail.pre = header;
		length = 0;
	}
	/**
	 * 获得pre结点
	 */
	public LNode<T> getPreNode(LNode<T> node) {
		return node.pre;
	}
	/**
	 * 获得next结点
	 */
	public LNode<T> getNextNode(LNode<T> node) {
		return node.next;
	}

	/**
	 * 传入数据，将该数据生成结点添加到链表尾部
	 * @param data
	 * @param pre
	 * @param next
	 */
	public void addNodeInLast(T data) {
		LNode<T> node = new LNode<T>(data, null, null);
		tail.pre.next = node;
		node.next = tail;
		node.pre = tail.pre;
		tail.pre = node;
		this.length++;
	}
	/**
	 * 传入值，获得与该值相等的结点
	 */
	public LNode<T> getNodeByValue(T data) {
		LNode<T> temp = header.next;
		while(temp.next!=null) {
			if(temp.data.equals(data)) {
				return temp;
			}
			temp = temp.next;
		}
		return null;
	}
	/**
	 * 传入索引,获得索引的结点
	 */
	public LNode<T> getNodeByIndex(int index) {
		if(index>this.length) {
			System.out.println("该索引大于链表长度!");
			return null;
		}
		LNode<T> temp = header.next;
		for(int i=0; i<index; i++) {
			temp = temp.next;
		}
		return temp;
	}	
	
	/**
	 * 传入值，删除与该值相等的结点
	 */
	public boolean removeNodeByValue(T value) {
		if(this.length==0) {
			System.out.println("链表为空,无法删除!");
			return false;
		}
		LNode<T> node = this.getNodeByValue(value);
		LNode<T> pre = node.pre;
		LNode<T> next = node.next;
		pre.next = next;
		next.pre = pre;
		node.pre = node.next = null;
		node.data = null;
		this.length--;
		System.gc();
		return true;
	}
	/**
	 * 出入索引，删除该位置的结点
	 * @param args
	 */
	public boolean removeNodeByIndex(int index) {
		if(index<0 || index>this.length) {
			System.out.println("索引越界!");
			return false;
		}
		LNode<T> theNode = this.getNodeByIndex(index);
		theNode.next.pre = theNode.pre;
		theNode.pre.next = theNode.next;
		theNode.next = theNode.pre = null;
		theNode.data = null;
		System.gc();
		return true;
	}
	/**
	 * 清空链表
	 * @param args
	 */
	public boolean clearList() {
		LNode<T> theNode = header.next;
		for(int i=0; i<this.length && theNode!=null; i++) {
			theNode.pre = theNode.next = null;
			theNode.data = null;
			theNode = theNode.next;
		}
		this.length=0;
		System.gc();
		return true;
	}
	
	public static void main(String[] args) {
		LinkList<Integer> ll = new LinkList<Integer>();
		for(int i=1; i<10; i++)
			ll.addNodeInLast(i);
		//ll.clearList();
		LNode<Integer> temp = ll.header.next;
		while(temp.next != null) {
			System.out.println(temp.data);
			temp=temp.next;
		}
	}

}