单链表和双链表

单链表

链表是有序的列表，但是它在内存中的存储如下：

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

单链表的应用实例

使用带 head 头的单向链表实现 –水浒英雄排行榜管理完成对英雄人物的增删改查操作， 注: 删除和修改,查找 可以考虑学员独立完成，也可带学员完成 1) 第一种方法在添加英雄时，直接添加到链表的尾部

2. 第二种方式在添加英雄时， 根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)

public class SingleLinkedListDemo {
    public static void main(String[] args) {
        // 先创建节点
        HeroNode her1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode her2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode her3 = new HeroNode(3, "吴用", "智多星");
        HeroNode her4 = new HeroNode(4, "林冲", "豹子头");

        // 创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        // 无顺序加入节点
//        singleLinkedList.add(her1);
//        singleLinkedList.add(her2);
//        singleLinkedList.add(her3);
//        singleLinkedList.add(her4);
        // singleLinkedList.add(her4); （不考虑排序）如果重复添加一个对象就会死循环，因为第一次添加到队尾的时候next还为空，再次添加next就为自己本身就死循环了

        // 按照编号顺序加入节点
        singleLinkedList.addByOrder(her1);
        singleLinkedList.addByOrder(her4);
        singleLinkedList.addByOrder(her2);
        singleLinkedList.addByOrder(her3);
        singleLinkedList.addByOrder(her3); // 不能重复插入

        // 显示
        singleLinkedList.list();

        // 测试修改节点
        HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
        singleLinkedList.update(newHeroNode);
        System.out.println("修改之后的链表存储情况：");
        singleLinkedList.list();

        // 删除节点
        singleLinkedList.delete(1);
        singleLinkedList.delete(4);
        singleLinkedList.delete(3);
        singleLinkedList.delete(2);
        System.out.println("删除之后的链表存储情况：");
        singleLinkedList.list();
    }
}

// 定义SingleLinkedList 管理我们的英雄
class SingleLinkedList {
    // 初始化一个头节点，头节点不动，不存放具体的数据
    private HeroNode head = new HeroNode(0, "", "");
    // 初始化一个尾节点，指向最后一个元素，默认等于head
    private HeroNode tail = head;

    // 添加节点到单向链表
    // 不考虑编号顺序时
    // 1. 找到当前链表的最后节点
    // 2. 将最后这个节点的next指向新的节点
    public void add(HeroNode heroNode) {
        tail.setNext(heroNode);
        tail = heroNode;
    }

    // 第二种方式在添加英雄时， 根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode) {
        // 因为头节点不能动，需要一个辅助指针（变量）来帮助涨找到添加的位置
        // 因为时单链表，所以我们找的temp是位于添加位置的前一个节点，否则加入不了
        HeroNode temp = head;
        boolean flag = false; // 添加的编号是否存在，默认为false
        while(true) {
            if(temp.getNext() == null) { // 说明链表已经在链表的最后
                break;
            }
            if(temp.getNext().getNo() > heroNode.getNo()) { // 位置已经找到，应该在temp和temp.getNext()之间
                break;
            } else if (temp.getNext().getNo() == heroNode.getNo()) { // 说明希望添加heroNode的编号已经存在
                flag = true; // 说明编号存在
                break;
            }
            temp = temp.getNext(); // 后移，遍历当前列表
        }
        // 判断flag的值
        if(flag) { // 不能添加，说明编号存在
            System.out.printf("准备插入的英雄编号%d已经存在了\n", heroNode.getNo());
        } else {
            // 插入到链表中
            heroNode.setNext(temp.getNext());
            temp.setNext(heroNode);
        }
    }

    // 修改节点的信息，根据编号来修改
    public void update(HeroNode newHeroNode) {
        // 判断是否为空
        if (head.getNext() == null){
            System.out.println("链表为空~~");
            return;
        }
        // 找到需要修改的节点
        // 定义一个辅助变量
        HeroNode temp = head.getNext();
        boolean flag = false; // 表示是否找到这个节点
        while (true) {
            if (temp == null) {
                break; // 已经遍历完了链表
            }
            // 如果no是Integer服装类型，不能使用 == ，而应该用 equals
            if (temp.getNo() == newHeroNode.getNo()) {
                // 找到节点
                flag = true;
                break;
            }
            temp = temp.getNext();
        }
        // 根据flag判断是否找到要修改的节点
        if (flag) {
            temp.setName(newHeroNode.getName());
            temp.setNickname(newHeroNode.getNickname());
        } else { // 没有找到
            System.out.printf("没有找到编号为 %d 的节点，不能修改\n", newHeroNode.getNo());
        }
    }

    // 删除节点
    public void delete(int no) {
        HeroNode temp = head;
        boolean flag = false; // 标志是否找到待删除节点
        while (true) {
            if (temp.getNext() == null) { // 已经到节点的最后
                break;
            }
            if (temp.getNext().getNo() == no) {
                // 找到待删除节点的前一个节点temp
                flag = true;
                break;
            }
            temp = temp.getNext();
        }
        // 判断flag
        if (flag) { // 找到
            // 可以删除
            temp.setNext(temp.getNext().getNext());
        } else {
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }

    // 显示链表
    public void list() {
        if (head.getNext() == null) {
            System.out.println("链表为空");
            return;
        }
        // 因为头节点，不能动。因此我们需要一个辅助遍历来遍历
        HeroNode temp = head.getNext();
        while (temp != null){
            System.out.println(temp);
            temp = temp.getNext();
        }
    }
}
// 定义HeroNode，每个HeroNode对象就是一个节点
class HeroNode {
    private int no;
    private String name;
    private String nickname;
    private 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 + "]";
    }

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getNickname() {
        return nickname;
    }

    public void setNickname(String nickname) {
        this.nickname = nickname;
    }

    public HeroNode getNext() {
        return next;
    }

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

双向链表

单向链表的缺点分析

单向链表，查找的方向只能是一个方向，而双向链 表可以向前或者向后查找
单向链表不能自我删除，需要靠辅助节点 ，而双向 链表，则可以自我删除，所以前面我们单链表删除 时节点，总是找到temp,temp是待删除节点的前一 个节点

双向链表分析

分析 双向链表的遍历，添加，修改，删除的操作思路
遍历方法和单链表一样，只是可以向前，也可以向后查找
添加 (默认添加到双向链表的最后)
先找到双向链表的最后这个节点
temp.next = newHeroNode
newHeroNode.pre = temp
修改思路和 原来的单向链表一样
删除
因为是双向链表，因此可以实现自我删除某个节点
直接找到要删除的这个节点，比如 temp
temp.pre.next = temp.next
temp.next.pre = temp.pre

单向环形链表

单向环形链表应用场景

Josephu(约瑟夫、约瑟夫环) 问题 Josephu 问题为：设编号为 1，2，… n 的 n 个人围坐一圈，约定编号为 k（1<=k<=n）的人从 1 开始报数，数 到 m 的那个人出列，它的下一位又从 1 开始报数，数到 m 的那个人又出列，依次类推，直到所有人出列为止，由 此产生一个出队编号的序列。

提示：用一个不带头结点的循环链表来处理 Josephu 问题：先构成一个有 n 个结点的单循环链表，然后由 k 结 点起从 1 开始计数，计到 m 时，对应结点从链表中删除，然后再从被删除结点的下一个结点又从 1 开始计数，直 到最后一个结点从链表中删除算法结束

算法分析

根据用户的输入，生成一个小孩出圈的顺序
n=7，即有7个人
k=1，从第1个人开始报数
m=3，每次数3下
需求创建一个辅助指针（变量）helper，事先应该指向环形链表的最后这一个节点
小孩报数前，先让first和helper指针同时移动m-1此
当这个小孩报数的时候，让first和hepler指针同时的移动m-1次
first = first.getNext()
helper.setNext(first)
原来的first指向的节点就没有了任何引用(计数无法解决循环引用的问题，现在JVM都不使用引用计数算法了，不过这样确实会通过可达性分析算法被回收，是不可达对象)

/**
 * 解决约瑟夫问题
 * @author 22130
 */
public class Josepfu {
    public static void main(String[] args) {
        // 测试构建环形链表和遍历
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        // 加入7个小孩
        circleSingleLinkedList.addBoy(7);
        circleSingleLinkedList.showBoy();

        // 测试小孩出圈 3->6->2->7->5->1->4
        circleSingleLinkedList.countBoy(1, 3, 7);
    }
}

/**
 * 创建一个环形的单向链表
 */
class CircleSingleLinkedList {
    /**
     * 创建一个first节点，当前没有编号
     */
    private Boy first = null;

    /**
     * 添加小孩节点，构建一个环形链表
     * @param nums
     */
    public void addBoy(int nums) {
        // nums做一个数据校验
        if (nums < 1) {
            System.out.println("nums的值不正确");
        }
        // 辅助指针，帮助构建环形链表
        Boy temp = null;
        // 使用for来创建我们的环形链表
        for (int i = 1; i <= nums; i++) {
            // 根据编号，创建小孩节点
            Boy boy = new Boy(i);
            // 如果是第一个小孩
            if (i == 1) {
                first = boy;
                // 构成环
                first.setNext(first);
                // 让temp指向第一个小孩
                temp = first;
            } else {
                temp.setNext(boy);
                boy.setNext(first);
                temp = boy;
            }
        }
    }

    /**
     * 遍历当前的环形链表
     */
    public void showBoy() {
        // 判断链表是否为空
        if (first == null) {
            System.out.println("没有任何小孩~");
            return;
        }
        // 因为first不能动，所以我们还需要使用一个辅助指针完成遍历
        Boy temp = first;
        while (true) {
            System.out.printf("小孩的编号%d \n", temp.getNo());
            // 说明遍历完毕
            if (temp.getNext() == first){
                break;
            }
            // temp后移
            temp = temp.getNext();
        }
    }

    /**
     * 根据用户的输入，计算出小孩出圈的顺序
     * @param firstNo 表示小孩从第几个小孩开始报数
     * @param countNum 表示一次数几下
     * @param nums 表示最初有多少个小孩在圈中
     */
    public void countBoy(int firstNo, int countNum, int nums) {
        // 先对数据进行校验
        if (first == null || firstNo < 1 || firstNo > nums) {
            System.out.println("参数输入有误，请重新输入");
            return;
        }
        // 创建辅助指针
        Boy helper = first;
        // 需求创建一个辅助指针变量helper，事先应该指向环形链表的最后这个节点
        while (true) {
            // 说明helper指向了最后小孩节点
            if (helper.getNext() == first) {
                break;
            }
            helper = helper.getNext();
        }
        // 小孩报数前，先让first和helper移动firstNo-1次
        for (int j = 0; j < firstNo - 1; j++) {
            first = first.getNext();
            helper = helper.getNext();
        }
        // 当小孩报数时，，让first和helper指针同时移动m-1此，然后出圈
        while (true) {
            // 说明圈中只有一节点
            if (helper == first) {
                break;
            }
            // 让first和helper指针同时的移动countNum-1
            for (int j = 0; j < countNum - 1; j++) {
                first = first.getNext();
                helper = helper.getNext();
            }
            // 这时first指向的节点，就是小孩要出圈的节点
            System.out.printf("小孩%d出圈\n", first.getNo());
            // 这是将first指向的小孩出圈
            first = first.getNext();
            helper.setNext(first);
        }
        System.out.printf("最后留在圈中的小孩编号%d\n", first.getNo());
    }

}

/**
 * 创建一个Boy类，表示一个节点
 */
class Boy {
    /**
     * 编号
     */
    private int no;
    /**
     * 指向下一个节点，默认为null
     */
    private Boy next;

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

    public int getNo() {
        return no;
    }

    public void setNo(int no) {
        this.no = no;
    }

    public Boy getNext() {
        return next;
    }

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