数据结构 02 - 单链表的使用 && 环形链表的实现与应用

一、单链表的使用

1.链表

定义：链表是有序的列表
关键点：链表是学树和图的基础
特点：
（1）链表是以节点的方式来存储的，即所谓的链式存储
（2）每个节点包含data域和next域，后者的作用是指向下一个节点
（3）链表的各个节点不一定是连续存储
（4）链表分为带头节点的链表和没有头节点的链表，这需要根据实际需求来确定

2.使用单链表使用红楼梦人物排列：

（1）完成对人物的增删改查操作
（2）第一种添加方法：直接添加到链表的尾部
（3）第二种添加方法：按照序号排名将人物插入到指定位置（如果该位置已有数据，则提示已有数据，无法添加）

代码实现：

public class SingleLinkedListTest {
    public static void main(String[] args) {
        //先创建节点
        HeroNode heroNode1 = new HeroNode(1, "贾宝玉", "宝二爷");
        HeroNode heroNode2 = new HeroNode(2, "林黛玉", "林妹妹");
        HeroNode heroNode3 = new HeroNode(3, "薛宝钗", "宝姐姐");
        HeroNode heroNode4 = new HeroNode(4, "王熙凤", "二奶奶");
        HeroNode heroNode5 = new HeroNode(5, "贾琏", "琏二爷");
        HeroNode heroNode6 = new HeroNode(6, "贾雨村", "假语村言");
        HeroNode heroNode7 = new HeroNode(7, "甄士隐", "真事隐");
        HeroNode heroNode8 = new HeroNode(8, "贾迎春", "二呆子");
        HeroNode heroNode9 = new HeroNode(9, "贾元春", "贤德妃");
        HeroNode heroNode10 = new HeroNode(10, "柳湘莲", "美男子");

        HeroNode heroNode11 = new HeroNode(6, "薛蟠", "大傻子");
        //把节点添加到链表中
        singleLinkedList s1 = new singleLinkedList();
        s1.add2(heroNode1);
        s1.add2(heroNode3);
        s1.add2(heroNode2);
        s1.add2(heroNode4);
        s1.add2(heroNode5);
        s1.add2(heroNode6);
        s1.add2(heroNode7);
        s1.add2(heroNode8);
        s1.add2(heroNode9);
        s1.add2(heroNode10);

        //s1.delete(heroNode1);
        //s1.modify(heroNode11);
        HeroNode find = s1.find(3);
        System.out.println(find);
        System.out.println();
        //s1.list();
    }
}

//创建一个singleLinkedList
class singleLinkedList{
    //先初始化一个头节点，头节点不要动，不存放具体数据
    private HeroNode head = new HeroNode(0,"","");
    //添加节点到单向链表
    //当不考虑编号的顺序时，1.找到当前链表的最后节点；2.将最后这个节点的next指向新的节点
    public void add1(HeroNode heroNode){
        //因为head节点不能动，因此需要一个辅助遍历temp
        HeroNode temp = head;
        //遍历链表，找到最后
        while (true){
            if(temp.next == null){
                break;
            }
            //如果没有找到，则将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向了链表的最后
        //将最后这个节点的next,指向新的节点
        temp.next = heroNode;
    }
    public void add2(HeroNode heroNode){
        //因为head节点不能动，因此需要一个辅助遍历temp
       HeroNode temp = head;
       boolean flag = false;
       while (true){
           if(temp.next == null){
               break;
           }
           if(temp.next.number > heroNode.number){
               break;
           }else if(temp.next.number == heroNode.number){//说明该编号的数据已经添加进链表了
               flag = true;
               break;
           }
           temp = temp.next;
       }
        if(flag){
            System.out.println("该编号的数据已添加进链表中，不能再添加了");
        }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.next == null){
                System.out.println(temp);
                break;
            }
            System.out.println(temp);
            temp = temp.next;
        }
    }
    //删除人物
    public void delete(HeroNode heroNode) {
        HeroNode temp = head;
        while (true) {
            if (temp.next == null) {
                System.out.println("链表为空 ");
                break;
            } else if (temp.next.number == heroNode.number) {
                temp.next = heroNode.next;//没有指向的节点会被垃圾回收机制回收
                break;
            }
            temp = temp.next;
        }
    }
    //修改人物
    public void modify(HeroNode heroNode){
        HeroNode temp = head;
        while (true){
            if(temp.next == null){
                System.out.println("链表为空");
                break;
            }else if(temp.next.number == heroNode.number){
                heroNode.next = temp.next.next;
                temp.next = heroNode;
                break;
            }
            temp = temp.next;
        }
    }
    //寻找指定人物
    public HeroNode find(int number){
        HeroNode temp = head;
        boolean flag = false;
        while (true){
            if(temp.next == null){
                System.out.println("链表为空");
                break;
            }else if(temp.next.number == number){
                return temp.next;
            }
            temp = temp.next;
        }
        return null;
    }
}
//每个HeroNode对象，就是一个节点
class HeroNode{
    public int number;
    public String name;
    public String nickname;
    public HeroNode next;//类中又实例化一个类，这个类就是当前已声明类的下一个类，即当前节点的下一个节点，就达到了next的效果

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

    @Override
    public String toString() {
        return "[number=" + number + ",name=" + name + ",nickname=" + nickname + "]";//当ssot对象时，调的是该对象的toString方法
    }
}

二、环形链表的实现与应用

1.构建单向形链表

（1）.先创建一个节点，让first指向该节点，并形成环形
（2）.后面每创建一个新的节点，就把该节点加入到已有的环形链表中

2.环形链表的遍历

（1）.先让一个辅助指针curBoy指向first节点
（2）.然后通过while循环遍历该环形链表，知道curBoy.next == first结束

3.实现游戏

假设有n个小孩围成一圈，从第k个小孩开始报数，数m下后指向的这个小孩淘汰，直到剩下最后一个小孩，则游戏结束

1.首先构建一个辅助变量helper，开始指向环形链表的最后一个节点
2.小孩报数前，先让first和helper移动k-1次
3.当小孩报数时，让first和helper移动m-1次
4.此时first指向的小孩淘汰
first = first.next
helper.first = first
（原来first指向的节点没有任何引用，将会被回收）

代码实现：

public class CircleLinkedListTest {
    public static void main(String[] args) {
        CircleSingleLinkedList circle= new CircleSingleLinkedList();
        circle.addBoy(10);
        circle.gameBoy(3,5,10);
        //circle.showBoy();
    }
}
class CircleSingleLinkedList{
    private Boy first = null;

    public void addBoy(int number){
        if(number < 1){
            System.out.println("输入参数有误，请重新输入");
            return;
        }
        Boy curBoy = null;
        for (int i = 1; i <= number; i++) {
            Boy boy = new Boy(i);
            if(i == 1){
                first = boy;
                first.setNext(first);
                curBoy = first;
            }else {
                curBoy.setNext(boy);
                boy.setNext(first);
                curBoy = boy;
            }
        }
    }
    public void showBoy(){
        Boy temp = first;
        if(first == null){
            System.out.println("链表为空");
            return;
        }
        while (true){
            if(temp.getNext() == first){
                System.out.println("小孩编号为：" + temp.getNumber());
                break;
            }else {
                System.out.println("小孩编号为：" + temp.getNumber());
            }
            temp = temp.getNext();
        }
    }
    public void gameBoy(int startnumber,int countnumber,int totalnumber){
        if(first == null || startnumber > totalnumber){
            System.out.println("输入参数有误，请重新输入");
            return;
        }
        Boy helper = first;
        while (true){
            if(helper.getNext() == first){
                break;
            }
            helper = helper.getNext();
        }
        while (true){
            if(first.getNext() == first){
                System.out.println("最后剩下的小孩为："  + first.getNumber());
                break;
            }
            //helper和first同时移动startnumber - 1
            for (int i = 0; i < countnumber - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            //helper和first同时移动startnumber - 1
            for (int i = 0; i < countnumber - 1; i++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            //淘汰最终点到的小孩
            System.out.println("淘汰的小孩为：" + first.getNumber());
            first = first.getNext();
            helper.setNext(first);
        }
    }
}
class Boy{
    private int number;
    private Boy next;

    public Boy(int number) {
        this.number = number;
    }

    public int getNumber() {
        return number;
    }

    public void setNumber(int number) {
        this.number = number;
    }

    public Boy getNext() {
        return next;
    }

    public void setNext(Boy next) {
        this.next = next;
    }
}