数据结构---连表

1.链表是一种物理存储单元上非连续、非顺序的存储结构，数据元素的逻辑顺序是通过链表中的指针链接次序实现的。链表由一系列结点（链表中每一个元素称为结点）组成，结点可以在运行时动态生成。每个结点包括两个部分：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域。 相比于线性表顺序结构，操作复杂。由于不必须按顺序存储，链表在插入的时候可以达到O(1)的复杂度，比另一种线性表顺序表快得多，但是查找一个节点或者访问特定编号的节点则需要O(n)的时间，而线性表和顺序表相应的时间复杂度分别是O(logn)和O(1)。

2.自己实现一个简单的链表的过程 

 /**
     * 虚拟头结点
     */
    private Node dummyHead;
    private int size;

    private class Node{
        private E e;
        private Node next;
        public Node(E e,Node next){
            this.e=e;
            this.next=next;
        }

        public Node(E e){
            this(e,null);
        }
        public Node(Node next){
            this(null,next);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }

    public MyLinkedList(){
        dummyHead=new Node(null,null );
        size=0;
    }

    public int getSize(){
        return size;
    }

    public boolean isEmpty(){
        return size==0;
    }



    public void add(E e,int index){
        if(index<0 || index>size){
            throw new IllegalArgumentException("the index is illegal");
        }
            Node pre=dummyHead;
            for(int i=0;i<index;i++){
                pre=pre.next;
            }
            Node node=new Node(e);
            node.next=pre.next;
            pre.next=node;
            size++;
    }

    /**
     *在连表头部添加一个元素
     * @param e
     */
    public void addFirst(E e){
      add(e,0);
    }

    /**
     *  在连表尾部
     * @param e
     */
    public void addLast(E e){
        add(e,size);
    }

    /**
     * 查询连表中的指定索引的元素
     * @param index
     * @return
     */
    public E get(int index){
        if(index<0 || index>size){
            throw new IllegalArgumentException("the index is illegal");
        }
        Node curr=dummyHead.next;
        for(int i=0;i<index;i++){
            curr=curr.next;
        }
        return curr.e;
    }

    /**
     * 获取第一个连表中的元素
     * @return
     */
    public E getFirst() {
        return get(0);
    }

    /**
     * 获取最后一个元素
     * @return
     */
    public E getLast(){
        return get(size-1);
    }

    /**
     *  更新指定位置的元素
     * @param index
     * @param e
     */
    public void update(int index,E e){
        if(index<0 || index>size){
            throw new IllegalArgumentException("the index is illegal");
        }
        Node curr=dummyHead.next;
        for(int i =0;i<index;i++){
            curr=curr.next;
        }
        curr.e=e;
    }

    /**
     * 判断连表中是否包含某个元素
     * @param e
     * @return
     */
    public boolean contains(E e){
        Node curr=dummyHead.next;
        while (curr.next!=null){
            if(curr.e.equals(e)){
                return true;
            }
            curr=curr.next;
        }
        return false;
    }


    @Override
    public String toString() {
        StringBuilder sb=new StringBuilder();
         Node curr=dummyHead.next;
         while (curr!=null){
             sb.append(curr + "->");
             curr=curr.next;
         }
         sb.append("NULL");
         return sb.toString();
    }

    /**
     * 删除指定位置元素
     * @param index
     * @return
     */
    public E delete(int index){
        if(index<0 || index>size){
            throw new IllegalArgumentException("the index is illegal");
        }
        Node pre=dummyHead;
        for(int i=0;i<index;i++){
            pre=pre.next;
        }
        Node delNode=pre.next;
        pre.next=delNode.next;
        delNode.next=null;
        size--;
        return delNode.e;
    }

    /**
     * 删除第一个元素
     * @return
     */
    public E deleteFirst(){
        return delete(0);
    }


    /**
     * 删除最后一个元素
     * @return
     */
    public E deleteLast(){
        return delete(size-1);
    }