【HuoLe的学习笔记】--单链表

链表（Linked List）

• 链表是有序的列表

  • 链表是以节点的方式来存储
  • 每个节点包含data域，next域：指向下一个节点
  • 链表各个节点并不一定是连续存储
  • 链表分带头节点的链表和没有头节点的链表，根据实际需求确定
  • 

• 单链表的创建：

  • 添加（创建）：
    1. 先创建一个head头节点，作用就是表示单链表的头
    2. 后面我们每添加一个节点，就直接加入到链表的最后
  • 遍历：
    1. 通过一个辅助变量遍历，帮助遍历整个链表。

• 单链表的修改：

  • 修改节点：
    1. 先找到需要修改的节点
    2. 修改对应信息

• 单链表的删除：

  • 删除节点：
    1. 找到需要删除的这个节点的前一个节点temp
    2. temp.next = temp.next.next

• Java实现：

public class SingleLinkedList {
    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 hero5 = new HeroNode(4, "侯靖琳", "傻大个");

        //创建链表
        SingleLinkedList1 singleLinkedList1 = new SingleLinkedList1();
        singleLinkedList1.addPlus(hero1);
        singleLinkedList1.addPlus(hero4);
        singleLinkedList1.addPlus(hero3);
        singleLinkedList1.addPlus(hero2);

        //输出链表内容
        System.out.println("添加addPlus后的链表：");
        singleLinkedList1.list();

        //测试修改节点
        singleLinkedList1.update(hero5);
        System.out.println("修改update后的链表：");
        singleLinkedList1.list();

        //测试修改节点
        singleLinkedList1.delete(hero5);
        System.out.println("删除delete后的链表：");
        singleLinkedList1.list();
        singleLinkedList1.delete(hero5);
    }
}

//定义一个SingleLinkedList管理Hero
class SingleLinkedList1{
    //先初始化一个头节点，头节点不要动,不存放具体数据
    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){
                break;
            }
            //如果没有找到，将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        temp.next = heroNode;
    }

    //第二种方式添加英雄，根据排名将英雄插入到指定位置
    //（如果有这个排名，则添加失败，并给出提示）
    public void addPlus(HeroNode heroNode){
        //因为head节点不能动，因此我们需要一个辅助遍历temp
        //因为时单链表，所以我们找的temp是位于添加位置的前一个节点，否则插入不了
        HeroNode temp = head;
        boolean flag = false;//标志添加的编号是否存在，默认false
        //遍历链表，找到最后
        while (true){
            //找到链表的最后
            if (temp.next == null){
                break;
            }
            if (temp.next.No > heroNode.No){//位置找到，就在temp的后面插入
                break;
            }else if (temp.next.No == heroNode.No){//说明希望添加的heroNode的编号已经存在
                flag = true;
                break;
            }
            //如果没有找到，将temp后移
            temp = temp.next;
        }
        if (flag){//不能添加，说明编号存在
            System.out.printf("准备插入的英雄编号%d已经存在了，不能加入\n",heroNode.No);
        }else {
            //添加到链表中
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点信息，根据No修改
    public void update(HeroNode heroNode){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空~");
            return;
        }
        HeroNode temp = head;
        while (true){
            if (temp.No == heroNode.No){//找到对应节点，修改信息
                temp.name = heroNode.name;
                temp.nickname = heroNode.nickname;
                break;
            }
            if (temp.next == null){
                break;
            }
            temp = temp.next;
        }
    }

    //删除
    //思路
    //1. head不能动，因此需要一个temp辅助节点找到待删除节点的前一个节点
    //2. 说明我们在比较时，是temp.next.No 和需要删除的节点的No比较
    public void delete(HeroNode heroNode){
        //判断链表是否为空
        if (head.next == null){
            System.out.println("链表为空~");
            return;
        }
        HeroNode temp = head;
        boolean flag = false;// 标志是否找到待删除节点
        while (true){
            if (temp.next == null){//已经到链表的最后
                break;
            }
            if (temp.next.No == heroNode.No){//找到对应节点，修改信息
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag){//找到，可以删除
            temp.next = temp.next.next;
        }else {
            System.out.printf("要删除的%s节点不存在",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;
        }
    }
}

//定义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;
    }

    //重新toString方法
    @Override
    public String toString() {
        return "HeroNode{" +
                "No=" + No +
                ", name='" + name + '\'' +
                ", nickname='" + nickname + '\'' +
                '}';
    }
}

• 输出结果：

SingleLinkedList
添加addPlus后的链表：
HeroNode{No=1, name='宋江', nickname='及时雨'}
HeroNode{No=2, name='卢俊义', nickname='玉麒麟'}
HeroNode{No=3, name='吴用', nickname='智多星'}
HeroNode{No=4, name='林冲', nickname='豹子头'}
修改update后的链表：
HeroNode{No=1, name='宋江', nickname='及时雨'}
HeroNode{No=2, name='卢俊义', nickname='玉麒麟'}
HeroNode{No=3, name='吴用', nickname='智多星'}
HeroNode{No=4, name='侯靖琳', nickname='傻大个'}
删除delete后的链表：
HeroNode{No=1, name='宋江', nickname='及时雨'}
HeroNode{No=2, name='卢俊义', nickname='玉麒麟'}
HeroNode{No=3, name='吴用', nickname='智多星'}
要删除的HeroNode{No=4, name='侯靖琳', nickname='傻大个'}节点不存在
Process finished with exit code 0