数据结构与算法——Java实现单向链表的增删改查

数据结构与算法——Java实现单向链表的增删改查

单向链表增删改查，通过no进行插入排序

//定义SingleLinkedList管理单链表
class SingleLinkedList {
    //先初始化一个头节点，头节点不要随意修改
    private HeroNode head = new HeroNode(0, "", "");


    //添加节点到单向链表
    //不考虑顺序编号，先找到最后一个节点，最后节点的next指向新节点即可
    public void add(HeroNode heroNode) {
        //1.创建一个temp节点辅助遍历
        HeroNode temp = head;

        //2.遍历链表
        while (true) {
            //找到链表的最后节点
            if (temp.next == null) {
                break;
            }
            //如果没有找到，继续后移
            temp = temp.next;
        }
        //当退出while循环时，temp指向最后的节点
        temp.next = heroNode;
    }

    //第二种添加的方式，安装顺序添加
    public void addByOrder(HeroNode heroNode) {

        //因为头节点不能动，仍然通过辅助节点进行遍历
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {  //已经是链表最后
                break;
            }
            if (temp.next.no > heroNode.no) {   //已经找到，就在temp后面
                break;
            } else if (temp.next.no == heroNode.no) {
                flag = true;//说明变化存在
                break;
            }
            temp = temp.next;  //后移，遍历当前链表
        }

        //通过flag的值进行判断是否可以添加
        if (flag) {
            System.out.printf("准备插入的%d已经存在了，不能重复添加\n", heroNode.no);
        } else {
            heroNode.next = temp.next;
            temp.next = heroNode;
        }

    }


    //遍历显示链表
    public void list() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }

        //因为头节点不能移动，因此我们需要一个辅助变量来遍历
        HeroNode temp = head.next;
        while (true) {
            //判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出节点的信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;
        }

    }

    //修改节点信息，根据no编号来修改
    public void update(HeroNode newheroNode) {

        //判断是否空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点
        HeroNode temp = head.next;
        boolean flag = false;
        while (true){
            if (temp==null){
                break;   //到链表最后
            }
            if (temp.no == newheroNode.no){
                flag=true;  //找到要修改的节点
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.name = newheroNode.name;
            temp.nickname = newheroNode.nickname;
        }else{
            System.out.printf("没有找到编号为%d的节点，不能操作\n",newheroNode.no);
        }
    }

    //删除节点
    //head不能动，需要一个temp节点辅助遍历
    //用temp与需要删除的节点比较
    public void del(int no){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if (temp.next == null){
                System.out.println("没有找到待删除的节点，不能操作");
                return;
            }
            if (temp.next.no == no){
                flag = true;
                break;
            }

            temp = temp.next;
        }

        if (flag){ //找到节点
            temp.next = temp.next.next;
        }else{
            System.out.printf("要删除的%d节点不存在\n",no);
        }


    }

}


//带头节点的单向链表
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;

    public HeroNode(int no, String name, String nickname) {
        this.no = no;
        this.name = name;
        this.nickname = nickname;
    }

    //为了显示方便，重写toString方法


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