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(){}
}

java模拟实现SingleLinkedList类

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

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

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

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

    //得到单链表的长度
    public int size1(){
        int count = 0;
        Node temp = head;
        while(temp != null){
            count++;
            temp = temp.next;
        }
        return count;
    }

    public int size2(){
        return this.usedSize;
    }

    //头插法
    public void addFirst(int data){
        Node node = new Node(data);
        //空
        if(this.head == null){
            this.head = node;
        }
        else{//非空
            node.next = this.head;
            this.head = node;
        }
        this.usedSize++;
    }

    //尾插法
    public void addLast(int data){
        Node node = new Node(data);
        Node temp = this.head;
        if(this.head == null){
            this.head = node;
        }
        else{
            while(temp.next != null){
                temp = temp.next;
            }
            temp.next = node;
        }
        this.usedSize++;
    }

    //任意位置插入,第一个数据节点为0号下标
    public boolean addIndex(int index,int data){
        //index越界
        if(index < 0 || index >size1()){
            System.out.println("下标越界，操作失败!");
            return false;
        }
        //首插
        if(index == 0){
            addFirst(data);
            return true;
        }
        //尾插
        if(index == size1() - 1){
            addLast(data);
            return true;
        }
        //其他情况
        Node node = new Node(data);
        Node prev = head;
        while(--index != 0){//找到前一个节点
            prev = prev.next;
        }
        node.next = prev.next;
        prev.next = node;
        //长度++
        usedSize++;
        return true;
    }

    //删除第一次出现关键字为key的节点
    public void remove(int key){
        //链表为空
        if(head == null)
            return;
        Node prev = head;//前一个节点
        //首部
        if(head.val == key){
            head = head.next;
            usedSize--;
            return;
        }
        //其他情况
        while(prev.next != null){
            if(prev.next.val == key){
               Node cur = prev.next;
               prev.next = cur.next;
               usedSize--;
               return;
            }
            prev = prev.next;
        }
    }

    //删除所有值为key的节点
    public void removeAllKey(int key){
        //判空
        if(head == null){
            return;
        }
        //其他情况
        Node prev = head;//前一个节点
        Node cur = head.next;//当前节点

        while(cur != null){
            if(cur.val == key){
                prev.next = cur.next;
                cur = cur.next;
                usedSize--;
            }
            else{//未匹配成功
                prev = cur;
                cur = cur.next;
            }
        }
        //首部
        if(head.val == key){
            head = head.next;
            usedSize--;
        }
        return;
    }

    //清空LinkList
    public void clear(){
        /*方法1：直接去掉
        this.head = null;
        usedSize = 0;*/

        //方法2：一个一个去掉
        Node temp = head;
        Node tempNext;
        while(temp != null){
            tempNext = temp.next;
            temp.next = null;//当前的置为null
            temp = tempNext;
        }
        this.head = null;
        this.usedSize = 0;
    }


}

注意：实现过程中容易出现空指针异常，一定要全面思考！！！