链表（java版）

链表

链表是一种真正的动态数据结构，不需要处理固定容量的问题，但是丧失了随机访问的能力，是最简单的动态数据结构，链表是一种递归的数据结构，我们可以通过链表来了解递归。
我们一般把数据储存在节点（Node）中，节点是一个可能含有任意数据类型的抽象实体。在java中，我们一般会用一个内部类来表示节点。

class Node{
    public E e;
	public Node next;
 }

对于链表来说，我们对其进行一般的操作，具体代码如下：

/**
 *一般链表头为head，在这里我们用的是虚拟头结点（dummyhead）
 * 链表的大小为size
 */
public class LinkedList<E> {
    //inner class,来定义指针域和元素
    private class Node{
        public E e;
        public Node next;
        public Node(E e,Node next){
            this.e = e;
            this.next= next;
        }
        public Node(E e){
            this(e,null);
        }
        public Node(){
            this(null,null);
        }

        @Override
        public String toString() {
            return e.toString();
        }
    }
    private Node dummyhead;
    private int size;
    public LinkedList(){
        dummyhead = new Node(null,null);
        size = 0;
    }
    public int getSize(){
        return size;
    }
    //返回链表是否为空
    public boolean isEmpty(){
        return size==0;
    }
    //任意位置添加一个元素
    public void add(int index,E e){
        if (index<0 || index > size){
            throw new IllegalArgumentException("索引不合法");
        }
        Node prev = dummyhead;
        for (int i = 0;i < index ; i++){
            prev = prev.next;
        }
//        Node node = new Node(e);
//        node.next = prev.next;
//        prev.next = node;
        prev.next = new Node(e,prev.next);
        size++;
    }
    //链表头添加元素
    public void addFirst(E e){
        add(0,e);
    }
    //链表末尾添加一个元素e
    public void addLast(E e){
        add(size,e);
    }
    //获得链表index元素
    public E get(int index){
        if (index<0||index>size){
            throw new IllegalArgumentException("索引违法");
        }
        Node cur =dummyhead.next;
        for (int i = 0; i<index ;i++){
            cur = cur.next;
        }
        return cur.e;
    }
    //获取链表第一个元素
    public E getFirst(){
      return   get(0);
    }
    //获取最后一个元素
    public E getLast(){
        return get(size-1);
    }
    //修改元素
    public void set(int index,E e){
        if (index <0 ||index > size){
            throw new IllegalArgumentException("索引违法");
        }
        Node cur = dummyhead;
        for (int i = 0;i<index ;i++){
            cur = cur.next;
        }
        cur.e = e;
    }
    //查找链表中是否有元素e
    public  boolean contains(E e){
        Node cur = dummyhead.next;
        while (cur !=null){
            if (cur.e.equals(e))
                return true;
            cur = cur.next;
        }
        return false;
    }
    //删除链表中的元素
    public E remove(int index){
        if (index <0 ||index > size){
            throw new IllegalArgumentException("索引违法");
        }
        Node prev = dummyhead;
        for (int i=0;i < index;i++){
            prev = prev.next;
        }
        Node retNode = prev.next;
        prev.next=retNode.next;
        retNode.next = null;
        size--;
        return retNode.e;
    }
    //删除第一个元素
    public E removeFirst(){
        return remove(0);
    }
    //删除最后一个元素
    public E removeLast(){
        return remove(size-1);
    }
    @Override
    public String toString() {
        StringBuilder res = new StringBuilder();
        Node cur = dummyhead.next;
        while (cur !=null){
            res.append(cur+"->");
            cur = cur.next;
        }
        res.append("NULL");
        return res.toString();
    }

    public static void main(String[] args) {
        LinkedList <Integer> linkedList=new LinkedList<>();
        for (int i = 0;i<5;i++){
            linkedList.addFirst(i);
            System.out.println(linkedList);
        }
        linkedList.add(3,6);
        linkedList.remove(2);
        System.out.println(linkedList.get(2));
        linkedList.removeLast();
        System.out.println(linkedList);
    }
}

对于add方法，我们可以通过画图来进行一个清晰的操作
我们需要将节点4插入到第二个位置，我们应该这样做：将节点4的next指向2，在将节点1的next指向4.这样就完成了添加的逻辑
对于删除来说，我们需要将节点1的next指向2这个节点，将节点4的next指向null：
值得注意的是我们对于链表的遍历我们一般是

for(Node x = first; x! = null; x=x.next ){
		
}