单链表的应用（英雄排行管理）

单链表的应用：

使用带head头的单向链表实现-王者英雄排行管理

1. 完成对英雄人物的增删改查操作
2. 第一种方法在添加英雄时，直接添加到链表的尾部
3. 第二种方式在添加英雄时，根据排名蒋英雄插入到指定位置

package DataStructures.LinkedList;

import java.util.Arrays;

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //进行测试
        //先创建节点
        HeroNode hero1 = new HeroNode(1, "武安君", "白起");
        HeroNode hero2 = new HeroNode(2, "小短腿", "鲁班");
        HeroNode hero3 = new HeroNode(3, "齐天大圣", "孙悟空");
        HeroNode hero4 = new HeroNode(4, "子龙", "赵云");
        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //加入
//        singleLinkedList.add(hero1);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);
//        singleLinkedList.add(hero4);
        //加入按照编号的顺序
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero2);
        //显示一下
        singleLinkedList.list();
        //测试修改的节点的代码
        HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟-");
        singleLinkedList.update(newHeroNode);
        System.out.println("修改后的链表状态");
        singleLinkedList.list();
        //删除一个节点
        singleLinkedList.del(1);
        singleLinkedList.del(2);
        singleLinkedList.del(3);
        singleLinkedList.del(4);
        System.out.println("删除后的数据");
        singleLinkedList.list();

    }
}

//定义一个singlelinkedlist，来管理我们的英雄
class SingleLinkedList {
    //先初始化一个头节点，头节点不要动。不存放具体的数据
    private HeroNode head = new HeroNode(0, "", "");

    //添加节点到单向链表
    //思路，当不考虑编号顺序时
    // 1.找到当前链表的最后节点
    // 2.将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode) {
//因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true) {
            //找到链表的最后  为null
            if (temp.next == null) {
                break;
            }
            //如果没有找到最后，那么就后移
            temp = temp.next;
        }
        //档推出while循环时，temp指向了链表的最后
        //将最后这个节点的next指向新的节点
        temp.next = heroNode;
    }
    //第二种方式在添加英雄时，根据排名将英雄插入到指定位置
    // （如果有这个排名，则添加失败，并给出提示）
    //显示链表【遍历】

    public void addByOrder(HeroNode heroNode) {
        //因为头节点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
        //因为单链表，因为我们找的temp是位于添加位置的前一个节点，否则加入不成功
        HeroNode temp = head;
        boolean flag = false;//标志添加的编号是否存在，默认为false
        while (true) {
            if (temp.next == null) {
                //说明temp已经在链表的最后
                break;
            }
            if (temp.next.no > heroNode.no) {
                //位置找到了，就在temp的后面插入
                break;
            } else if (temp.next.no == heroNode.no) {//说明希望添加的heronode的编号存在了，添加失败
                flag = true;
                break;
            }
            temp = temp.next;//后移，遍历当前链表

        }
        if (flag) {//不能添加，说明编号存在
            System.out.println("准备插入的影响的编号%d已经存在了，不能加入\n" + heroNode.no);
        } else {
            //插入到链表中，temp的后面
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点的信息，根据no编号来修改，即no编号不能改
    //根据newHeroNode 的no来修改即可
    public void update(HeroNode newHeroNode) {
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //找到需要修改的节点，根据no编号
        //定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false;//表示是否找到该节点
        while (true) {
            if (temp == null) {
                break;//等于null的时候，已经遍历完这个链表了
            }
            if (temp.no == newHeroNode.no) {
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        //根据flag判断是否找到要修改的节点
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
            ;
        } else {
            System.out.println("没有找到编号%d的节点，不能修改\n" + newHeroNode.no);
        }

    }

    //删除节点
    // 思路
    //1.head不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
    //2.说明我们在比较时，是temp。next.no和需要删除的节点的no比较
    public void del(int no) {
        HeroNode temp = head;
        boolean flag = false;//标志是否找到待删除的节点
        while (true) {
            if (temp.next == null) {//已经到了链表的最后
                break;
            }
            if (temp.next.no == no) {
                //找到了待删出节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.next;//temp后移。遍历
        }
        //判断flag
        if (flag) {
            //可以删除
            temp.next = temp.next.next;
        } else {
            System.out.printf("要删除的%d节点不存在\n", no);
        }
    }

    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;
        }
    }
}

//定义heronode,每个heronode对象就是一个节点
class HeroNode {
    public int no;
    public String name;
    public String nickname;
    public HeroNode next;//指向下一个节点

    //创建构造器
    public HeroNode(int hNo, String hName, String hNickname) {
        this.no = hNo;
        this.name = hName;
        this.nickname = hNickname;
    }
    //为了显示，重写Tostring方法；

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

标签：单链,temp,no,HeroNode,next,链表,英雄,排行,节点
来源： https://blog.csdn.net/qq_37215985/article/details/120580787