java模拟实现LinkedList＜一＞

大体框架：一个Node类，一个LinkedList类（单向、不循环、带头节点）

class Node{
    private int val;//数据域
    private Node next;//指向下一个节点

    public Node(int val){//构造方法
        this.val = val;
    }
}
public class LinkedList {//单向、不循环、带头结点

    public Node head;//链表的头结点
    public int usedSize;//当前链表中节点的个数

    //头插法
    public void addFirst(int data){};
    //尾插法
    public void addLast(int data){};
    //任意位置插入,第一个数据节点为0号下标
    public boolean addIndex(int index,int data){
        return false;
    };
    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        return false;
    };
    //删除第一次出现关键字为key的节点
    public void remove(int key){};
    //删除所有值为key的节点
    public void removeAllKey(int key){};
    //得到单链表的长度
    public int size(){
        return -1;
    };
    //输出所有元素
    public void MyTtoString(){};
    //清空LinkList
    public void clear(){};
}

实现LinkedList类

class Node{
    public int val;//数据域
    public Node next;//指向下一个节点
    public Node(){};//构造方法
    public Node(int val){
        this.val = val;
    }
}
public class MyLinkedList {//单向、不循环、带头结点

    public Node head = new Node();//链表的头结点
    public int usedSize;//当前链表中节点的个数

    //判空
    public boolean isEmpty() {
        //方法一：
        if (usedSize == 0) {
            return true;
        }
        return false;
    }

    //头插法
    public void addFirst(int data){
        Node node = new Node(data);
        if(this.isEmpty()){//链表中无节点的情况
            head.next = node;
        }
        else{//非空情况
            node.next = head.next;
            head.next = node;
        }
        usedSize++;//长度加一
    }

    //尾插法
    public void addLast(int data){
        Node node = new Node(data);
        Node temp = head;
        if(this.isEmpty()){//链表中为无节点的情况
            head.next = node;
        }
        else{//非空情况
            while(temp.next != null){//循环看下一个节点是否存在
                temp = temp.next;
            }
            temp.next = node;//挂上去
        }
        usedSize++;//长度加一

    }

    //任意位置插入,第一个数据节点为0号下标
    public boolean addIndex(int index,int data){
        //1.是否合法
        if(index < 0 || index > size() - 1 ){
            System.out.println("index为："+index+"，该下标不合法");
            return false;
        }
        if(head.next == null){
            System.out.println("链表为空，无法插入！！！请先添加节点");
        }
        //2.进行插入
        Node node = new Node(data);//要插入的节点
        Node pre = head;//前一个节点
        while(index-- != 0){//寻找index前一个位置
            pre = pre.next;
        }
        node.next = pre.next;
        pre.next = node;
        return true;
    }

    //查找是否包含关键字key是否在单链表当中
    public boolean contains(int key){
        Node temp  = head;
        while(temp.next != null){
            temp = temp.next;
            if(key == temp.val){
                return true;
            }
        }
        return false;
    }

    //删除第一次出现关键字为key的节点
    public void remove(int key){
        if(head.next == null){
            System.out.println("当前链表中无节点，请添加节点后进行删除！！！");
        }
        Node prev = head;
        while(prev.next != null){//循环寻找
            if(prev.next.val == key){
                Node cur = prev.next;
                if(cur.next == null){//寻找到的节点为最后一个节点
                    prev.next = null;//删除最后一个
                }
                else{
                    prev.next = cur.next;//连接下一个元素
                }
                usedSize--;
                return;//否则会继续循环寻找
            }
            prev = prev.next;
        }
        //未找到
        System.out.println("链表中无"+key+"值");
        return;
    }

    //删除所有值为key的节点
    public void removeAllKey(int key){
        if(head.next == null){
            System.out.println("当前链表中无节点，请添加节点后进行删除！！！");
        }
        Node prev = head;//前一个节点
        Node cur;//匹配到的节点
        while(prev.next != null){//循环寻找
            if(prev.next.val == key){
                 cur = prev.next;
                if(cur.next == null){//寻找到的节点为最后一个节点
                    prev.next = null;//删除最后一个
                    usedSize--;
                    return;
                }
                else{
                    prev.next = cur.next;//连接下一个元素
                    usedSize--;
                }
            }
            prev = prev.next;
        }
    }

    //得到单链表的长度
    public int size(){
        return usedSize;
    }

    //输出所有元素
    public void myTtoString(){
        if(head == null ||head.next == null){
            return ;
        }
        Node temp = head;
        while(temp.next != null){
            temp = temp.next;
            System.out.print(temp.val+" ");
        }
        System.out.println();//换行
    }

    //清空LinkList
    public void clear(){
        Node temp = head;
        Node nextNode;
        while(temp.next != null){//下一个节点存在
            nextNode = temp.next;//nextNode指向下一个节点
            temp.next = null;//与后面断开
            temp = nextNode;
        }
        head = null;
        usedSize = 0;
    }
}