单向链表的实现

　　单链表结构：物理存储结构上不连续，逻辑上连续，大小不固定。

　　单链表主要是以一个个节点组成，结点中又包含了两个域：1.存储数据的数据域 2.存储指针的指针域(java是以一个变量存储下一个结点的内存地址)

　　

　　单链表插入操作：

　　s.next=p.next;

　　p.next=s;(注意插入的顺序)

　　

　　单链表的删除操作：

　　 ....----->p(结点)------>z(结点)------>.....

　　如果要删除Z结点

　　p.next=z.next;

　　

　　1.结点类

public class ListNode {
     Object data;
     ListNode next;
    
    public ListNode(Object element)
    {
        this.data=element;
    }
}

　　2.MyList接口

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

　　3.SingleLinkedList类

public class SingleLinkedList<T> implements MyList<T>{
    private ListNode first;
    private ListNode last;
    private int size=0;
    
    @Override
    public void add(T element) {
        if(first==null)
        {
            first=new ListNode(element);
            last=first;
        }else {
            last.next=new ListNode(element);
            last=last.next;
        }
        size++;
    }

    @Override
    public void delete(T element) {
        ListNode p=first;
        ListNode pre=null;
        while(p!=null)
        {
            if(p.data.equals(element))
            {
                if(p==first)
                {
                    first=first.next;//first等于first的下一个结点
                }
                else
                {
                    pre.next=p.next;//相等结点的前驱结点的指针指向该结点的后驱结点
                }
                size--;
                break;
            }
            pre=p;
            p=p.next;
        }
    }

    @Override
    public void delete(int index) {
        int i=0;//计数
        ListNode p=first;
        ListNode pre=null;
        while(p!=null)
        {
            if(i==index)
            {
                if(p==first)
                    first=first.next;
                else
                    pre.next=p.next;
                size--;
                break;
            }
            pre=p;
            p=p.next;
            i++;
        }
        
    }

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

    @Override
    public boolean contains(T element) {
        ListNode p=first;
        while(p!=null)
        {
            if(p.data.equals(element))
                return true;
            p=p.next;
        }
        return false;
    }

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

    @Override
    public int indexOf(T element) {
        int i=0;
        ListNode p=first;
        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 p=first;
        while(p!=null)
        {
            sb.append(p.data);
            if(p.next!=null)
                sb.append(",");
            p=p.next;
        }
        sb.append("]");
        return sb.toString();
    }
    
    public int getSize()
    {
        return size;
    }

}

　　

　　顺序表和单链表的比较：

顺序表：

　　优点：主要优点是支持随机读取，以及内存空间利用效率高；

　　缺点：主要缺点是需要预先给出数组的最大数据元素个数，而这通常很难准确作到。当实际的数据元素个数超过了预先给出的个数，会发生异常。另外，顺序表插入和删除操作时需要移动较多的数据元素。

单链表：

　　优点：主要优点是不需要预先给出数据元素的最大个数。另外，单链表插入和删除操作时不需要移动数据元素；

　　缺点：主要缺点是每个结点中要有一个指针，因此单链表的空间利用率略低于顺序表的。另外，单链表不支持随机读取，单链表取数据元素操作的时间复杂度为O（n）；而顺序表支持随机读取，顺序表取数据元素操作的时间复杂度为O（1）。