数据结构之单链表

介绍

1.链表是有序的列表，但是链表在内存中是分散存储的
2.可以根据实际需求决定是否带头节点head

应用实例

使用带head头指针的单向链表实现-水浒英雄排行榜管理
1.完成对英雄人物的增删改查操作
2.第一种方法在添加英雄时，直接添加到链表的尾部
3.第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败)

添加(创建)
1.先创建一个head头节点，作用就是表示单链表的头
2.后面我们每添加一个节点，就直接加入到链表的最后
遍历

代码实现

package demo;

/**
 * @author zwj
 * @date 2022/2/21 - 11:30
 */
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,"林冲","豹子头");

        HeroNode newHero3 = new HeroNode(3,"wuyong","zhiduoxing");
        HeroNode newHero5 = new HeroNode(5,"鲁智深","和尚");

        //创建初始链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //正常添加
//        singleLinkedList.add(hero1);
//        singleLinkedList.add(hero2);
//        singleLinkedList.add(hero3);
//        singleLinkedList.add(hero4);
        //乱序添加
        singleLinkedList.addByOrder(hero2);
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero4);

        //修改前遍历
        System.out.println("修改前遍历============");
        singleLinkedList.list();

        //更新节点
        singleLinkedList.update(newHero3);
        singleLinkedList.update(newHero5);

        //修改后遍历
        System.out.println("修改后遍历===============");
        singleLinkedList.list();

        //删除节点
        singleLinkedList.delete(1);
        //删除后遍历
        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){
            if(temp.next == null){ //如果next为空，指向链表最后
                break;
            }
            //如果不是最后一个节点，将节点赋给temp,继续遍历
            temp = temp.next;
        }
        //将最后一个节点的next指针指向新节点
        temp.next = heroNode;
    }

    //按照排名顺序添加到单向列表
    /**
     * 1.首先找到新添加节点的位置，通过辅助变量(指针)
     * 2.新的节点的指针指向插入位置的下一个节点
     * 3.将上一个节点指向新的节点
     */
    public void addByOrder(HeroNode heroNode){
        //创建辅助变量
        HeroNode temp = head;
        boolean flag = false;   //排名是否存在的标识
        //循环遍历节点，判断排名
        while (true) {
            if (temp.next == null){
                break;
            }
            if (temp.next.no > heroNode.no){    //如果下一个节点大于新节点，将新节点的指针指向下一个节点，上一个节点的指针指向新节点
                break;
            }else if (temp.next.no == heroNode.no){ //如果下一个编号与新节点编号相等，说明已经存在
                flag = true;
                break;
            }
            temp = temp.next;   //后移，遍历当前链表
        }
        if (flag){   //不能添加
            System.out.println("编号已经存在,不能加入了");
        }else { //添加到链表
            heroNode.next = temp.next;  //将新节点的指针指向下一个节点
            temp.next = heroNode;   //将当前节点的指针指向新节点
        }
    }

    //修改节点数据
    public void update(HeroNode heroNode){
        // 创建辅助变量
        HeroNode temp = head;
        boolean flag = false;   //表示是否找到
        if (temp.next == null){
            //如果为空，直接添加节点
            System.out.println("链表为空，直接添加节点："+heroNode.no);
            temp.next = heroNode;
            return;
        }
        // 循环遍历链表中的数据，根据编号找到对应节点
        while(true){
            if (temp == null){ //
                break;
            }
            if (temp.no == heroNode.no){
                flag = true;    //表示找到了节点
                break;
            }
            temp = temp.next;
        }

        if (flag){  //找到节点，更新节点
            temp.name = heroNode.name;
            temp.nickName = heroNode.nickName;
        } else {
            System.out.println("链表中不存在节点，直接按排名添加节点");
            addByOrder(heroNode);
        }


    }

    //删除节点数据
    /**
     * 1.找到需要删除节点的上一个节点，然后将删除节点的下一个节点赋值给上一个节点,被删除的节点没有引用，就会被gc垃圾回收
     */
    public void delete(int no){
        //创建辅助变量
        HeroNode temp = head;
        boolean flag = false;   //有没有删除节点编号
        while (true){
            if (temp.next == null){
                break;
            }
            if (temp.next.no == no){
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){
            temp.next = temp.next.next; //上一个节点指向删除节点的下一个节点
            System.out.println("删除成功");
        }else {
            System.out.println("当前链表中没有找到排名为"+no+"的好汉");
        }
    }

    //显示链表[遍历]
    public void list(){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空");
            return;
        }
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        HeroNode temp = head;
        while(true){
            //判断是否到数组最后
            if (temp.next == null){
                break;
            }
            //输出节点信息
            System.out.println(temp.next);
            //将temp后移
            temp = temp.next;
        }
    }

}

//定义HeroNode,每个HeroNode对象就是一个节点
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;
    }


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