JAVA 单向链表 存在环 java的单向链表

单链表

概述

在内存中不是连续的，以节点储存的，每个节点包含data域（存储数据），next域（存储下一个节点的内存地址）

其中头节点：不存放数据，仅有next域。作用就是表示单链表的头部

最后一个节点的 next域的值为null

百度百科：单链表是一种链式存取的数据结构，用一组地址任意的存储单元存放线性表中的数据元素。链表中的数据是以结点来表示的，每个结点的构成：元素(数据元素的映象) + 指针(指示后继元素存储位置)，元素就是存储数据的存储单元，指针就是连接每个结点的地址数据。

实现思路

需要一个节点的bean类，节点类包含你需要储存的数据和一个节点类型的 next

需要一个操作链表的类

添加节点分为添加到末尾，和添加到中间

添加到末尾：需要一个临时节点作为指针，开始时指向头节点，遍历时根据节点的next找到下一个节点，每次让temp=temp.next，直到next == null，则让临时节点（末尾节点）的next指向新加入的节点即完成添加

添加到中间 ：定义一个临时节点，先找到要添加的位置前面的节点，赋值给临时节点，此时让新节点先指向临时节点的next 即后一个节点，然后再让临时节点（前一个节点）的next指向新的节点，顺序不能反过来。

修改：需要一个新的节点参数，遍历链表，判断新的节点的no有没有在原链表中存在，找到则给此节点的data赋值为新节点的data。或者直接让新的节点的next指向此节点的后一个节点，前一个节点的next指向新的节点，废弃的节点会被jvm的垃圾回收机制回收。

删除：需要传入要删除的节点的序号，遍历节点对比序号进行删除，将要删除的节点的前一个节点的next，指向要删除节点的后一个节点即可。

实现代码

public class SingleLinkedList {
    public static void main(String[] args) {
        SingleNode node1 = new SingleNode(1,"张三");
        SingleNode node2 = new SingleNode(2,"李四");
        SingleNode node3 = new SingleNode(3,"王五");
        SingleLinkedList linkedList = new SingleLinkedList();
        linkedList.addBySort(node2);
        linkedList.addBySort(node1);
        linkedList.addBySort(node3);
        linkedList.show();
        System.out.println("======修改=======");
        SingleNode node4 = new SingleNode(3,"王五2");
        linkedList.update(node4);
        linkedList.show();
        System.out.println("======删除=======");
        linkedList.delete(3);
        linkedList.show();
    }
    SingleNode headNode = new SingleNode(0, "");
    //添加节点到链表的末尾
    public void addTail(SingleNode singleNode){
        //定义一个临时节点，开始时代替头节点依次遍历链表
        SingleNode tempNode = headNode;
        //遍历链表。找到最后一个节点，即 next == null 的节点
        while (tempNode.next != null){
            tempNode = tempNode.next;
            //这里每一次循环赋值 tempNode都重新代表了tempNode的下一个节点，内存地址都一样
            //不用头节点进行遍历的原因是，头节点的位置不能改变
            //第一次添加节点的时候，temp就相当于头节点，temp.next = singleNode就相当于头节点的next赋值了
            //而第二次、第三次则代表的最后一个节点，这个时候头节点的next是不改变的。
        }
        tempNode.next = singleNode;

    }
    //根据序号no进行排序添加，如果序号相同，则提示失败
    //添加到链表中间而非末尾
    public void addBySort(SingleNode singleNode){
        SingleNode tempNode = headNode;
        //true表示已经存在此序号
        boolean flag = false;
        while (tempNode.next != null){
            if (tempNode.next.no > singleNode.no){
                break;
            } else if (tempNode.next.no == singleNode.no){
                flag = true;
                break;
            }
            tempNode = tempNode.next;
        }
        if (flag){
            System.out.println("该序号节点已存在");
        }else {
            //添加到temp指向的节点之后
            //向链表中间添加节点需要前一个节点next指向新的节点，而新的节点的next指向后一个节点
            singleNode.next =tempNode.next;
            tempNode.next = singleNode;
        }
    }
    //修改
    public void update(SingleNode node) {
        SingleNode tempNode = headNode;
        boolean flag = false;
        while (tempNode.next != null) {
            if (node.no == tempNode.next.no){
                //找到了
                flag = true;
                break;
            }
            tempNode = tempNode.next;
        }
        if (flag){
            tempNode.next.name = node.name;
        }else {
            System.out.println("不存在"+node.no+"号的节点");
        }
    }
    //删除
    public void delete(int no) {
        SingleNode tempNode = headNode;
        boolean flag = false;
        while (tempNode.next != null) {
            if (no == tempNode.next.no){
                //找到了
                flag = true;
                break;
            }
            tempNode = tempNode.next;
        }
        if (flag){
            tempNode.next = tempNode.next.next;
        }else {
            System.out.println("不存在"+no+"号的节点");
        }
    }
    //展示链表
    public void show(){
        if (headNode.next == null){
            System.out.println("链表为空===");
            return;
        }
        SingleNode tempNode = headNode;
        while (tempNode.next != null){
            System.out.println(tempNode.next);
            tempNode = tempNode.next;
        }
    }
    //根据no查找节点
    public SingleNode findNodeByNo(int no){
        if (headNode.next == null){
            return null;
        }
        SingleNode tempNode = headNode;
        while (tempNode.next != null){
            if (no == tempNode.next.no){
                return tempNode.next;
            } else {
                tempNode = tempNode.next;
            }
        }
        return null;
    }
}

public class SingleNode {
    public int no;
    public String name;
    public SingleNode next;

    public SingleNode(int no, String name) {
        this.no = no;
        this.name = name;
    }
    @Override
    public String toString() {
        return "SingleLinkedListNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }
}

执行结果：