双向链表的实现

 　　链表一般有单向链表，双向链表和双向循环链表三种

　　双向链表的每一个结点有着三个主要部分：1，存储数据的数据域   2，存储前指针的指针域   3，存储后指针的指针域 

　　

　　

　　1.MyList接口定义功能

public interface MyList<T>{
    //新增一个元素
    void add(T element);
    //删除与输入元素相同的元素
    void delete(T element);
    //根据索引删除元素
    void delete(int index);
    //更新元素
    void update(int index,T newelement);
    //查询1
    boolean contains(T element);
    
    T at(int index);
    
    int indexOf(T element);
}

　　2.ListNode结点类

public class ListNode<T> {
      T data;    
      ListNode pre; //前驱结点
      ListNode next; //后驱结点
    
    public ListNode()
    {
        
    }
    public ListNode(T element)
    {
        this.data=element;
    }
    
    
}

　　3.DoubleLinkedList类

public class DoubleLinkedList<T> implements MyList<T>{
    private ListNode<T> first=new ListNode<T>(); //头结点哑元
    private ListNode<T> last=new ListNode<T>(); //尾结点哑元
    private int size=0; //记录添加的个数
    
    public DoubleLinkedList()
    {
        first.next=last;
        last.pre=first;
    }
    
    @Override
    public void add(T element) {
        ListNode<T> newNode=new ListNode<T>(element);
        //注意添加结点的顺序
        last.pre.next=newNode;
        newNode.pre=last.pre;
        newNode.next=last;
        last.pre=newNode;
        size++;
    }

    @Override
    public void delete(T element) {
        ListNode<T> p=first.next; //复制一个头结点，以免后面操作影响头结点
        while(p!=null)
        {
            if(p.data.equals(element))
            {
                p.pre.next=p.next;
                p.next.pre=p.pre;
                size--;
                return ;
            }
            p=p.next;
        }
        
    }

    @Override
    public void delete(int index) {
        int i=0;
        ListNode<T> p=first.next;
        while(p!=last)
        {
            if(i==index)
            {
                p.pre.next=p.next;
                p.next.pre=p.pre;
                p.pre=null;
                p.next=null;
                size--;
                return ;
            }
            p=p.next;
            i++;
        }
        
    }

    @Override
    public void update(int index, T newelement) {
        int i=0;
        ListNode<T> p=first.next;
        while(p!=null)
        {
            if(i==index)
            {
                p.data=newelement;
            }
            p=p.next;
            i++;
        }
        
        
    }

    @Override
    public boolean contains(T element) {
        return indexOf(element)>=0;
    }

    @Override
    public T at(int index) {
        int i=0;
        ListNode<T> p=first.next;
        while(p!=null)
        {
            if(i==index)
            {
                return (T) p.data;
            }
            p=p.next;
            i++;
        }
        return null;
    }

    @Override
    public int indexOf(T element) {
        int i=0;
        ListNode<T> p=first.next;
        while(p!=null)
        {
            if(p.data.equals(element))
            {
                return i;
            }
            p=p.next;
            i++;
        }
        return -1;
    }
    
    @Override
    public String toString()
    {
        StringBuilder sb=new StringBuilder("[");
        ListNode<T> p=first.next;
        while(p!=last)
        {
            sb.append(p.data+(p.next!=last?",":""));
            
            p=p.next;
        }
        sb.append("]");
        return sb.toString();
    }

    public int getSize()
    {
        return this.size;
    }
    

}

单向链表：只有一个指向下一个节点的指针。

优点：单向链表增加删除节点简单。遍历时候不会死循环；

缺点：只能从头到尾遍历。只能找到后继，无法找到前驱，也就是只能前进。

适用于节点的增加删除。

双向链表：有两个指针，一个指向前一个节点，一个后一个节点。

优点：可以找到前驱和后继，可进可退；

缺点：增加删除节点复杂，多需要分配一个指针存储空间。

适用于需要双向查找节点值的情况。