数据结构之双向链表

package oder;
/*JAVA实现双向链表*/
public class DoubleLink<T> {

    //表头
    private DNode<T> mHead;
    
    //节点个数
    private int mCount;
    
    private class DNode<T>{
        public DNode prev;
        public DNode next;
        public T value;
        
        public DNode(DNode prev, DNode next, T value) {
            super();
            this.prev = prev;
            this.next = next;
            this.value = value;
        }
    }
    
    //构造函数
    public DoubleLink(){
        //创建表头，表头没有存储数据
        mHead = new DNode<T>(null, null, null);
        mHead.prev = mHead.next = mHead;
        mCount = 0;
    }
    
    //返回节点数
    public int size(){
        return mCount;
    }
    
    //返回链表是否为空
    public boolean isEmpty(){
        return mCount == 0;
    }
    
    //获取第index位置的节点
    private DNode<T> getNode(int index){
        if(index < 0 || index > mCount){
            throw new IndexOutOfBoundsException();
        }
        //正向查找
        if(index <= mCount/2){
            DNode<T> node = mHead.next;
            for(int i= 0; i< index; i++){
                node = node.next;
                return node;
            }
        }
        //反向查找
        DNode<T> rnode = mHead.prev;
        int rindex = mCount - index - 1;
        for(int j = 0; j < rindex; j++){
            rnode = rnode.prev;
        }
        return rnode;
    }
    
    //获取第index位置节点的值
    public T get(int index){
        return getNode(index).value;
    }
    
    //获取第一个节点的值
    public T getFirst(){
        return getNode(0).value;
    }
    
    //获取最后一个节点的值
    public T getLast(){
        return getNode(mCount-1).value;
    }
    
    //将节点插入到第index位置之前
    public void insert(int index,T t){
        if(index == 0){
            DNode<T> node = new DNode<T>(mHead.next, mHead, t);
            mHead.next.prev = node;
            mHead.next = node;
            mCount++;
            return;
        }
        DNode<T> inode = getNode(index);
        DNode<T> tnode = new DNode<T>(inode.prev, inode, t);
        inode.prev.next = tnode;
        inode.next = tnode;
        mCount++;
        return;
    }
    
    //将节点插入第一个节点处
    public void insertFirst(T t){
        insert(0,t);
    }
    
    //将节点追加到链表的末尾
    public void appendLast(T t){
        DNode<T> node = new DNode<T>(mHead.prev, mHead, t);
        mHead.prev.next = node;
        mHead.prev = node;
        mCount++;
    }
    
    //删除index位置的节点
    public void del(int index){
        DNode<T> inode = getNode(index);
        mHead.next.prev = inode.prev;
        mHead.prev.next = inode.next;
        inode = null;
        mCount--;
    }
    
    //删除第一个节点
    public void delFirst(){
        del(0);
    }
    
    //删除最后一个节点
    public void delLast(){
        del(mCount - 1);
    }
}