单向链表 理解按序存储元素

节点类

        其中的  T data  是存储数据的地方。

         no 是后面排序用的辅助变量, name 也是辅助变量，方便观察。

class MyNode<T> {
    private MyNode next;   //next 域
    //data 域
    private T data;
    private int no;
    private String name;

    public MyNode(T data, int no, String name) {
        this.data = data;
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "MyNode{" +
                "data=" + data +
                ", no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    //是否有下个元素
    public boolean hasNext() {
        return next != null;
    }
    // getter、setter
｝

链表类

        其中 head 是头指针 不动， temp 临时节点是用来作为中转的辅助节点。

class MyLinkedList<T> {
    private MyNode head;
    private MyNode temp;

    public MyLinkedList() {
        this.head = new MyNode(null, 0, "");
        temp = null;
    }
}

在链表类中添加 遍历打印、找到最后一个元素、在末尾添加元素的 方法

    //遍历打印
    public void list() {
        if (!head.hasNext()) {
            System.out.println("链表为空");
            return;
        }
        temp = head.getNext();
        while (true) {
            if (!temp.hasNext()) {
                System.out.println(temp);
                break;
            }
            System.out.println(temp);
            temp = temp.getNext();
        }
    }
    //找到最后一个节点
    public MyNode findLastNode() {
        //如果链表为空直接在头结点下一个存放
        if (!head.hasNext()) {
            return head;
        }
        //不为空循环遍历到没有下一个子节点的节点存放
        temp = head.getNext();
        while (true) {
            if (!temp.hasNext()) {
                return temp;
            }
            temp = temp.getNext();
        }
    }
    //在末尾插入数据
    public void add(T data, int no, String name) {
        findLastNode().setNext(new MyNode(data, no, name));
    }

 按 no 顺序 插入元素

        自己写的时候 可以先把所有的条件情况列出来，列完了之后合并重复的条件，最后在每个条件下面写好对应条件的操作即可。

    //按 no 顺序插入
    public void addByOrder(T data, int no, String name) {
        //如果链表为空 head 后加入第一个元素
        if (!head.hasNext()) {
            head.setNext(new MyNode(data, no, name));
            return;
        }
        //链表不为空，传入 no 小于第一个元素时
        if (head.getNext().getNo() > no) {
            temp = head.getNext();
            MyNode newNode = new MyNode(data, no, name);
            newNode.setNext(temp);
            head.setNext(newNode);
            return;
        }
        //链表不为空，传入 no >= 第一个元素时，循环找到介于 temp 指针和指针下一个之间的位置
        temp = head.getNext();
        while (true) {
            if (temp.getNo() == no) {//重复了
                System.out.println("no:"+no +" 重复了 name: " + name);
                break;
            }
            if (!temp.hasNext() || temp.getNext().getNo() > no) {//插入 temp 之后
                MyNode newNode = new MyNode(data, no, name);
                newNode.setNext(temp.getNext());
                temp.setNext(newNode);
                break;
            }
            temp = temp.getNext();
        }
    }

 最后测试用的主方法

    public static void main(String[] args) throws InterruptedException {

        MyLinkedList<LocalDateTime> myLinkedList = new MyLinkedList<>();
        myLinkedList.addByOrder(LocalDateTime.now(), 5, "宋江");
        Thread.sleep(TimeUnit.MILLISECONDS.toMillis(500L));
        myLinkedList.addByOrder(LocalDateTime.now(), 11, "哈哈");
        myLinkedList.addByOrder(LocalDateTime.now(), 10, "哈哈");
        myLinkedList.addByOrder(LocalDateTime.now(), 13, "哈哈");
        myLinkedList.addByOrder(LocalDateTime.now(), 19, "哈哈");
        Thread.sleep(TimeUnit.MILLISECONDS.toMillis(500L));
        myLinkedList.addByOrder(LocalDateTime.now(), 11, "欠欠");
        myLinkedList.list();
    }