Java实现链式存储的线性表

package com.test.mylinkedlist;


import javax.swing.border.EmptyBorder;


import com.test.myarraylist.MyArrayList;


/**
 * 链式结构的线性表的实现
 * @author Wangjie
 * @version 1.0
 * 
 */
public class MyLinkedList <T>{
/**
* 节点抽象类
* @author Administrator
*
*/
private class Node{
//存放节点数据
private T data;
//存放下一个节点的引用
private Node next;
/**
* 无参构造器
*/
public Node(){
}
/**
* 通过数据，下一个节点的引用来的构造器
* @param data 数据
* @param next 下一个节点的引用
*/
public Node(T data,Node next){
this.data = data ;
this.next = next ;
}
}
private final String INDEX_OUT_OF_BOUNDS_WARN = "线性表索引越界";
//记录链表的头节点
private Node header;
//记录链表的尾节点
private Node tail;
//记录链表的大小，即包含的节点数
private int size;
/**
*创建空链表 
*/
public MyLinkedList(){
header = null ;
tail = null ;
}
/**
* 以一个元素创建链表
* @param element 传入的元素
*/
public MyLinkedList(T element){
header = new Node (element , null) ;
tail = header;
size++;
}
/**
* 返回链表的长度
* @return 链表的长度
*/
public int length(){
return size;
}
/**
* 返回索引处的元素
* @param index 索引
* @return 元素
*/
public T get(int index){
return getNodeByIndex(index).data;
}
/**
* 返回索引处的节点
* @param index
* @return
*/
private Node getNodeByIndex(int index){
if(index<0 || index>size-1){
throw new IndexOutOfBoundsException(INDEX_OUT_OF_BOUNDS_WARN);
}
Node _current = header;
for(int i = 0; i < size && _current != null; i++ ,_current = _current.next ){

if(i == index){
return _current;
}
}
return null;
}
/**
* 查找元素的索引，找不到返回-1
* @param element 元素
* @return 索引
*/
public int locate(T element){
Node _current = header;
for(int i = 0; i < size && _current != null; i++ ,_current = _current.next ){

if(_current.data.equals(element)){
return i;
}
}
return -1;

} 
/**
* 在链表的指定位置插入元素
*/
public void insert(T element , int index){
if(index<0 || index>size-1){
throw new IndexOutOfBoundsException(INDEX_OUT_OF_BOUNDS_WARN);
}
if(header == null){
add(element);
}
else{
if(index == 0){
addAtHeader(element);
}
else{
Node _prvNode = getNodeByIndex(index);
_prvNode.next = new Node(element , _prvNode.next);
size++;
}
}
}
/**
* 用尾插法为链表添加新的节点
* @param element 元素
*/
public void add(T element){
if(header == null){
header = new Node(element , null);
}
else{
Node _newNode = new Node(element , null);
tail.next = _newNode;
tail = _newNode;
}
size++;
}
/**
* 用头插法为链表添加新的节点
* @param element 节点数据
*/
public void addAtHeader(T element){
header = new Node(element , header);
//如果插入之前是空链表，则更新tail节点
if(tail == null ){
tail = header;
}
size++;
}
/**
* 删除指定索引处的节点
* @param index 索引
* @return 返回被删除的节点
*/
public T delete(int index){
if(index < 0 || index > size-1){
throw new IndexOutOfBoundsException(INDEX_OUT_OF_BOUNDS_WARN);
}
Node _oldNode = null;
if(index == 0){
_oldNode = header;
header = header.next;
}
else if(index == size - 1){
_oldNode = tail ;
tail=getNodeByIndex(size-1);
tail.next = null;
}else{
_oldNode = getNodeByIndex(index);
Node prvNode = getNodeByIndex(index-1);
prvNode.next = getNodeByIndex(index+1);
}
size--;
return (T) _oldNode;
}
/**
* 从尾部删除节点
* @return 返回被删除的节点
*/
public T remove(){
return (T)delete(size-1);
}
/**
* 判断链表是否为空
* @return 返回是否为空
*/
public boolean empty(){
return size==0;
}
/**
*清空链表 
*/
public void clear(){
header = null;
tail = null;
size = 0;
}
}