数据结构之单链表

链表

• Linked list

• 有序的列表，在内存中的存储方式为链式存储，即可以不用位置相连续

• 特点

  • 链表是以节点的方式来存储，链式存储
  • 每个节点包含数据域（data）和指针域（next）
  • data域存放数据，next域存放下一个节点
  • 链表的各个节点不一定是连续存储
  • 链表分为带头节点的链表和没有头节点的链表

• 链表分为

1. 单向链表
2. 循环链表
3. 双向链表

单链表
单方向的链表结构
单链表带头结点逻辑结构

使用单链表模拟实现水浒传英雄排行榜对英雄人物进行增删改查操作
说明：HeroNode相当于单链表的节点，只是增加了几个属性，相当于data域，next相当于下一个next域

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, "林冲", "豹子头");
        //创建要给链表
        System.out.println("测试直接添加和显示链表的操作");
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        System.out.println("------------------------");
        singleLinkedList.list();
        System.out.println("------------------------");
        System.out.println("测试按照顺序添加的操作");
        SingleLinkedList singleLinkedList1 = new SingleLinkedList();
        singleLinkedList1.addByOrder(hero1);
        singleLinkedList1.addByOrder(hero4);
        singleLinkedList1.addByOrder(hero3);
        singleLinkedList1.addByOrder(hero2);
        singleLinkedList1.list();
        System.out.println("------------------------");
        System.out.println("测试修改的操作");
        HeroNode newhero = new HeroNode(2, "卢俊义222", "玉麒麟");
        singleLinkedList1.update(newhero);
        singleLinkedList1.list();
        System.out.println("------------------------");
        System.out.println("测试删除的操作");
        singleLinkedList1.del(1);
        singleLinkedList1.del(3);
        singleLinkedList1.del(2);
        singleLinkedList1.del(4);
        singleLinkedList1.del(1);
        singleLinkedList1.list();
        System.out.println("------------------");
    }

}
//带头结点的单链表，管理英雄类
class SingleLinkedList{
    //初始化头结点，头结点不动，不放具体的数据
    private HeroNode head = new HeroNode(0,"","");
    //定义一个方法，获得头结点
    //返回头结点
    public HeroNode getHead(){
        return head;
    }
    //定义一个方法
    //添加节点到单向链表的尾部
    public void add(HeroNode heroNode){
        //因为需要遍历然后找到尾节点，所以创建一个临时变量来移动
        HeroNode temp = head;
        while(true){
            if(temp.next == null){  //链表为空
                break; //直接退出循环，在尾部增加新添节点即可
            }else{
                //否则，依次遍历
                temp = temp.next;
            }
        }
        //退出循环，找到尾节点，添加需要插入的那个节点
        temp.next = heroNode;
    }
    //定义一个方法
    //根据排名将英雄插入到指定位置
    public void addByOrder(HeroNode heroNode){
        //因为需要遍历然后找到尾节点，所以创建一个临时变量来移动
        HeroNode temp = head;
        //创建一个判断类型的Boolean，根据此值来判断是否能够插入
        boolean flag = false;
        //循环遍历
        while(true){
            if(temp.next == null){ //说明链表为空，直接退出循环
                break;
            }
            //否则，判断当前节点与新插入的节点的no的大小关系
            if(temp.next.no > heroNode.no){
                //说明当前节点的下一个节点的no比新插入的节点的no大
                //退出循环之后，直接在temp当前节点的next插入即可
                break;
            }else if(temp.next.no == heroNode.no){ //说明已经存在
                //flag修改为true，便于下面的操作
                flag = true;
                break;
            }
            //依次遍历
            temp = temp.next;
        }
        //flag为true，则已经存在
        if(flag){
            System.out.printf("准备插入的英雄编号%d存在,不能加入\n",heroNode.no);
        }else{
            //否则，插入，将插入的节点的next设置为temp当前节点的next节点
            //将当前节点temp的next设置为新插入的节点
            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;
            }
            //已经重写了toString方法，直接输出即可
            System.out.println(temp);
            //依次遍历
            temp = temp.next;
        }
    }
    //定义修改方法
    //参数是新的节点
    public void update(HeroNode newHeroNode) {
        if(head.next == null){
            System.out.println("链表为空");
        }
        //因为需要遍历然后找到尾节点，所以创建一个临时变量来移动
        HeroNode temp = head.next;
        boolean flag = false;
        while(true){
            //判断链表是否为空，
            if(temp == null){
                //为空，退出
                break;
            }
            //否则，根据no找到修改的位置
            if(temp.no == newHeroNode.no){
                //修改flag状态，退出
                flag = true;
                break;
            }
            //依次遍历
            temp = temp.next;
        }
        //根据flag，修改
        if(flag){
            temp.name = newHeroNode.name;
            temp.nickname = newHeroNode.nickname;
        }else{
            //否则，无法修改
            System.out.printf("没有找到 编号 %d 的节点，不能修改\n", newHeroNode.no);

        }
    }
    //定义删除方法
    //参数是需要删除的节点位置
    public void del(int no) {
        if(head.next == null){
            System.out.println("链表为空");
        }
        //因为需要遍历然后找到尾节点，所以创建一个临时变量来移动
        HeroNode temp = head;
        boolean flag = false;
        while(true){
            if(temp.next == null){
                break;
            }
            if(temp.next.no == no){
                //找到删除节点位置
                //重置flag状态为true，退出循环之后，根据此状态删除
                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;
    }

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