java_单链表的编写方式二_带有增删改查

public class Node {
    public int value;
    public Node next;
    public Node(){}

    public Node(int value) {
        this.value = value;
    }

    public Node(int value, Node next) {
        this.value = value;
        this.next = next;
    }
}
----------------------------------------
public class ListNode {
    //    头结点
    private Node head;
    //    临时节点
    private Node temp;
    //    节点个数
    public int size;

    public ListNode() {
        head = new Node();
//      相当于Node node = new Node();
    }
//set/get方法可以选择写，我是有用处才写的
    public Node getHead() {
        return head;
    }

    public void setHead(Node head) {
        this.head = head;
    }

    public Node getTemp() {
        return temp;
    }

    public void setTemp(Node temp) {
        this.temp = temp;
    }

    public int getSize() {
        return size;
    }

    public void setSize(int size) {
        this.size = size;
    }

    //    头插法:即将新的节点插入到头结点的后方一个位置，即插入在头结点和头结点后面一个节点之间的位置。
    public void addNodeAtHead(int value) {
        Node node = new Node(value);
        if (head.next == null) {
            head.next = node;
            return;
        }
        temp = head.next;
        head.next = node;
        node.next = temp;
        size++;
    }

    //    尾插法
    public void addNodeAtTail(int value) {
        Node node = new Node(value);
        temp = head;
//        从头结点开始遍历
        while (temp.next != null) {
            temp = temp.next;
        }
//        当遍历到尾部节点时，添加新节点
        temp.next = node;
        size++;
    }

    //    指定位置插入
    public void add(int value, int index) throws IllegalAccessException {
        if (index < 0 || index > size) {
            throw new IllegalAccessException("索引越界");
        }
        if (index == 0) {
            addNodeAtHead(value);
            return;
        }
        temp = head;
//        遍历到索引位置的前一个节点
        for (int i = 0; i < index; i++) {
            temp = temp.next;
        }
        Node node = new Node(value);
        node.next = temp.next;
        temp.next = node;
        size++;
    }

    //    有序链表插入，从小到大
    public void addNodeSeq(int value) {
        Node node = new Node(value);
        if (head.next == null) {
            addNodeAtTail(value);
            return;
        }
        if (value < head.next.value) {
            addNodeAtHead(value);
        } else {
            temp = head.next;
//            循环结束条件：value小于temp.value或者temp.next==null
            while (value > temp.value) {
                if (temp.next == null) {
                    break;
                }
                temp = temp.next;
            }
            if (temp.next == null) {
                temp.next = node;
                size++;
            } else {
//                此处情况是：value小于temp.value
                node.next = temp.next;
                temp.next = node;
                size++;
            }
        }
    }

    //    删除指定索引的节点
    public void deleteNode(int index) throws IllegalAccessException {
        if (index < 0 || index > size){
            throw new IllegalAccessException("索引越界");
        }
        temp = head;
//        遍历至需要删除的节点的前一个节点。
        for (int i = 0;i<index;i++){
            temp = temp.next;
        }
//        将指针断开即可
        temp.next = temp.next.next;
        size --;
    }
//    删除所有指定值的节点
    public void deleteAll(int value){
        temp = head;
        while(temp.next !=null){
            if (temp.next.value == value){
                temp.next = temp.next.next;
                size--;
                continue;
            }
            temp = temp.next;
        }
    }
//修改指定索引位置节点的值
    public void modefyNode(int value,int index) throws IllegalAccessException {
        if (index <0 || index>size){
            throw new IllegalAccessException("索引越界");
        }
        temp = head;
//        遍历至需要修改的节点
        for (int i =0 ;i<=index;i++){
            temp = temp.next;
        }
        temp.value = value;
    }
//    查询功能
    public boolean findNode(int value){
        boolean flag = false;
        temp = head.next;
        while (temp != null){
            if(temp.value == value){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        return flag;
    }
//    遍历
    public void printListNode(){
//        头节点为空，因此直接让指针指向第一个装有值的节点
        temp= head.next;
        while(temp != null){
            if (temp.next == null){
                System.out.println(temp.value);
            }else {
                System.out.print(temp.value+",");
            }
            temp = temp.next;
        }
    }
}
-----------------------------------------------------
执行类
public class RunListNode {
    public static void main(String[] args) throws IllegalAccessException {
        ListNode listNode = new ListNode();
//        用于测试一件事情：对象创建时会自动生成一个头结点
//        System.out.println("新的对象未插入数据时，value："+listNode.getHead().value+",size值："+listNode.size);
        listNode.addNodeSeq(3);
        listNode.addNodeSeq(2);
        listNode.addNodeSeq(5);
        listNode.addNodeSeq(7);
        listNode.addNodeSeq(9);
        listNode.addNodeSeq(10);
        listNode.addNodeSeq(5);
        listNode.addNodeSeq(1);
        listNode.add(4,8);
        System.out.print("指定位置插入后：");
        listNode.printListNode();
        listNode.modefyNode(3,8);
        System.out.print("指定位置修改之后：");
        listNode.printListNode();
        System.out.println("该链表共有"+listNode.size+"个节点");
        System.out.println(listNode.findNode(8));
        listNode.deleteNode(7);
        listNode.printListNode();
        System.out.println("删除节点后，该链表共有"+listNode.size+"个节点");
        listNode.deleteAll(3);
        listNode.printListNode();
        System.out.println("删除节点后，该链表共有"+listNode.size+"个节点");
    }
}