单向链表的基本操作

单向链表的遍历、插入、查找、删除、搜索结点

import java.util.Iterator;
import java.util.function.Consumer;

//单向链表
public class SinglyLinkedList implements Iterable<Integer>{ //整体
     private Node head=new Node(666,null);//头指针指向哨兵结点
//迭代器遍历
    @Override
    public Iterator<Integer> iterator() {
        //匿名内部类->带名字的类（重构->移动类）
        return new Iterator<Integer>() {
            SinglyLinkedList.Node p=head.next;
            @Override
            public boolean hasNext() {//是否有下一个元素
                return p!=null;
            }

            @Override
            public Integer next() {//返回当前元素的值，指向下一个元素
                int v=p.value;
                p=p.next;
                return v;
            }
        };
    }

    /**
     * 节点类
     */
    private static class Node{
        int value;//值
        Node next;//下一个节点指针

        public Node(int value, Node next) {
            this.value = value;
            this.next = next;
        }
    }
//插入
    public void addFirst(int value){
        insert(0,value);
        //1.链表为空
//        head=new Node(value,null);
        //2.链表非空
        //head=new Node(value,head);
    }
//while遍历
    public void loop1(Consumer<Integer>consumer){
        Node p=head.next;
        while(p!=null){
            consumer.accept(p.value);
            p=p.next;
        }
    }
//for遍历
    public void loop2(Consumer<Integer>consumer) {
        for (Node p=head;p!=null;p=p.next){
            consumer.accept(p.value);
        }
    }
//递归遍历
    public void loop3(Consumer<Integer>before,
                      Consumer<Integer>after){
        recursion(head,before,after);
    }
    //针对某一个结点进行的操作
    private void recursion(Node curr,
               Consumer<Integer> before, Consumer<Integer> after){
        if(curr==null){
            return;
        }
        before.accept(curr.value);
        recursion(curr.next, before, after);
        after.accept(curr.value);
//        SinglyLinkedList list=getLinkedList();
//       list.loop3(value->{
//            System.out.println("before:"+value);
//       },value->{
//           System.out.println("after:"+value);
//       });
    }
//尾部插入结点
    private Node findLast() {
        Node p;
        for (p = head.next; p.next != null; p = p.next) {

        }
        return p;
    }
    public void addLast(int value){
        Node last=findLast();
        last.next=new Node(value,null);
    }
//计算索引值
    public void test(){
        int i=0;
        for(Node p=head;p!=null;p=p.next,i++){
            System.out.println(p.value+"索引是"+i);
        }
    }
//根据给定索引查找结点对象
    private Node findNode(int index){
        int i=-1;
        for(Node p=head.next;p!=null;p=p.next,i++){
           if(i==index){
               return p;
           }
        }
        return null;//没找到
    }
//根据结点索引返回值
    public int get(int index) {
        Node node = findNode(index);
        if (node == null) {
            try {
                throw new IllegalAccessException(
                        String.format("index [%d] 不合法%n", index));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return node.value;
    }
//向索引位置插入
    public void insert(int index,int value){
        Node prev=findNode(index-1);//找到上一个节点
        if(prev==null) {//找不到
            try {
                throw new IllegalAccessException(
                        String.format("index [%d] 不合法%n", index));
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        prev.next=new Node(value,prev.next);
    }
//删除结点
    public void removeFirst(){
        if(head==null) {
//            throw illegalIndex(0);
        }
        head=head.next;
    }
//删除指定索引的结点
    public void remove(int index){
        Node prev=findNode(index-1);//上一个结点
        if(prev==null){//没有上一个结点
 //           throw illegalIndex(index);
        }
        Node removed = prev.next;//被删除的节点
        if(removed==null){//没有要删除的结点
 //           throw illegalIndex(index);
        }
        prev.next=removed.next;
    }
}