回顾数据结构---链表

链表真不是个东西

 

附上灵魂画图一张

 

 

package lianbiao;

public class LinkedList<E>{

    //内部类---作为链表的结构
    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);
        }
        public String toString(){
            return e.toString();
        }
    }


    private Node dummyHead;//虚拟头节点
    int size;

    //无参创建链表
    public LinkedList(){
        dummyHead = new Node(null,null);
        size = 0;
    }
    //创建链表，并将数组放到链表上
    public LinkedList(E[] e ){
        dummyHead = new Node(null,null);
        size = 0;
        for(int i = 0;i < e.length;i++)
            addFirst(e[i]);
    }

    //获得链表长度
    public int getSize()
    {
        return size;
    }
    //判断是否为空
    public boolean isEmpty(){
        return size == 0;
    }
    //在链表头添加元素
    public void addFirst(E e){
        add(0,e);

    }
    //在链表的index位置添加新的元素e
    public  void add (int index,E e){
        //判断是否非法
        if(index < 0 || index > size)
            throw new IllegalArgumentException("add failed.Illegal index.");

        Node prev = dummyHead;//指向头节点的前一个节点，为了找到index的前一个节点
        for(int i = 0 ;i < index;i++){
            prev = prev.next;
        }
         Node node = new Node(e);//新建节点
        node.next = prev.next;//将新节点的指针域指向index所在节点
        prev.next = node;//将新节点接到index的前一个节点指针域，完成新节点的插入

        size++;
    }
    //在末尾添加元素
    public void addLast(E e){
        add(size,e);
    }

    //获得链表第index个位置的元素
    public E get(int index){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("get failed.Illegal index.");

        Node cur = dummyHead.next;//从第一个元素开始遍历
        for(int i = 0;i < index;i++)//找到index所在的节点，返回数据体
            cur = cur.next;

        return cur.e;

    }

    //获得第一个元素
    public E getFirst(E e){
        return get(0);
    }
    public E getLast(E e){
        return get(size - 1);
    }
    //修改index下标的元素值
    public void set(int index,E e){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("set failed.Illegal index.");

        Node cur = dummyHead.next;
        for(int i = 0;i< index;i++)//循环找到Index下标的节点
            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;
    }
    //删除下标为index的元素
    public  E remove(int index){
        if(index < 0 || index >= size)
            throw new IllegalArgumentException("remove failed.Illegal index.");

        Node prev = dummyHead;//prev初始为虚拟节点，为了找到Index下标的前一个节点
        for(int i = 0;i < index;i++){
            prev = prev.next;
        }
        Node retNode = prev.next;//将index-1下标的节点所指向的下一个节点赋值给新节点
        //reNode--就相当于index下标节点
        prev.next = retNode.next;//将index下标所在节点的下一个节点赋值给prev的指针域
        retNode.next = null;//令retNode和链表断开
        size--;

        return retNode.e;
    }

    public E removeFirst(){
        return remove(0);
    }
    public E removeLast(){
        return remove(size-1);
    }
    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 [] arg){
        LinkedList<Integer> l = new LinkedList<>();
        for(int i = 0;i < 5;i++){
            l.addFirst(i);
            System.out.println(l);
        }
        l.add(3,666);
    System.out.println(l);
    l.remove(2);
    System.out.println(l);
    l.set(4,888);
    System.out.println(l);

}
}