链表-双向链表

一、双向链表

1.单向链表的缺点分析：

1、单向链表，查找的方向只能是一个方向，而双向链表可以向前或者向后查找
2、单向链表不能自我删除，需要靠辅助结点，而双向链表则可以自我删除。

2、双向链表的遍历、增删改查操作

① 遍历：和单链表一样，只是可以向前，也可以向后
② 增加：（默认添加到双向链表的最后）
1）先找到双向链表的最后结点
2）temp.next=newHeroNode;
3) newHeroNode.pre=temp;
③ 修改：思路和单向链表一样
④ 删除：可以自我删除某个结点
1）先找到想要删除的这个结点
2）temp.pre.next=temp.next;
3) temp.next.pre=temp.pre;

3.结点类的创建，双向链表类的创建、功能实现：

① 结点类的创建，代码如下：

// 定义HeroNode2，每个HeroNode2的实例对象就是一个结点
class HeroNode2{
    public int no;
    public String name;
    public String nickname;
    public HeroNode2 next;  // 指向下一个结点
    public HeroNode2 pre;   // 指向上一个结点

    public HeroNode2(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 + '\''  +
                '}';
    }
}

② 双向链表类的创建、功能实现 代码如下：

// 创建一个双向链表的类
class DoubleLinkedListt {
    // 先初始化一个头结点，头结点不要动，不存放具体数据
    private HeroNode2 head = new HeroNode2(0, "", "");

    //   返回头结点
    public HeroNode2 getHead() {
        return head;

    }

    // 显示链表【遍历】
    public void showlist() {
        // 判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        // 因为头结点，不能动，因此要一个辅助遍历temp来遍历
        HeroNode2 temp = head.next;
        while (true) {
            // 判断是否到链表最后
            if (temp == null) {
                break;
            }
            //输出结点信息
            System.out.println(temp);
            // 将temp后移,一定要小心
            temp = temp.next;

        }
    }

    // 添加操作  按结点编号顺序插入链表中
    public void doubleAdd(HeroNode2 heroNode2){
        boolean flag=false;
        HeroNode2 temp =head;
        while (true){
            if (temp.next==null){
                break;
            }
            if (temp.next.no>heroNode2.no){
                break;
            }
            if (temp.next.no==heroNode2.no){
                flag=true;
                break;
            }
            temp=temp.next;
        }
        if (flag){
            System.out.printf("需要添加的结点编号%d：已存在",heroNode2.no);
        }else {
            if (temp.next!=null){
                temp.next.pre=heroNode2;
                heroNode2.next=temp.next;
                heroNode2.pre=temp;
                temp.next=heroNode2;
            }else {
                temp.next=heroNode2;
                heroNode2.pre=temp;
            }
        }
    }

    // 修改一个结点的内容  与点链表一样
    // 修改节点的信息，根据no编号来修改，即no编号不能改
    // 说明：根据newHeroNode 的no来修改
    public void updata(HeroNode2 newHeroNode2){
        if(head.next==null){
            System.out.println("链表为空");
            return;
        }
        HeroNode2 temp=head.next;
        boolean flag=false;
        while (true){
            if(temp==null) {
                break;  // 到链表的最后 已经遍历完链表了
            }
            if(temp.no==newHeroNode2.no){
                flag=true;  // 找到了
                break;
            }
            temp=temp.next;
        }
        // 根据flag判断是否找到要修改的结点
        if (flag){
            temp.name= newHeroNode2.name;
            temp.nickname=newHeroNode2.nickname;
        }else {
            System.out.printf("没有找到编号%d的结点 ",newHeroNode2.no);
        }
    }

    //根据no值来判断删除  与单链表不同，双链表可以再定位到要删除结点的地方实现自我删除
    public void del(int no){
        if (head.next==null){
            System.out.println("链表为空，无法删除");
            return;
        }

        HeroNode2 temp=head.next;
        boolean flag=false;  //  标识是否找到
        while (true){
            if (temp==null){ //到最后
                break;
            }
            if (temp.no==no) {
                // 找到待删除结点的temp
                flag = true;
                break;
            }
            temp=temp.next; // temp后移，继续遍历
        }
        if (flag){
            temp.pre.next=temp.next;
            // 如果是最后一个结点，就不要执行下面这句话，否则出现空指针异常
            if (temp.next!=null){
                temp.next.pre=temp.pre;
            }

        }else {
            System.out.printf("要删除的编号%d的结点不存在\n",no);
        }
    }
}

③主类测试，代码如下：

public class DoubleLinkedList {
    public static void main(String[] args) {

        // 进行测试
        // 先创建结点
        HeroNode2 sj = new HeroNode2(1, "宋江", "及时雨");
        HeroNode2 ljy = new HeroNode2(2, "卢俊义", "玉麒麟");
        HeroNode2 wy = new HeroNode2(3, "吴用", "智多星");
        HeroNode2 lc = new HeroNode2(4, "林冲", "豹子头");

        // 创建双向链表
        DoubleLinkedListt doubleLinkedList = new DoubleLinkedListt();

        // 结点编号方式添加  （根据no来排列添加）
        doubleLinkedList.doubleAdd(sj);
        doubleLinkedList.doubleAdd(lc);
        doubleLinkedList.doubleAdd(wy);
        doubleLinkedList.doubleAdd(ljy);

        // 显示
        doubleLinkedList.showlist();

        // 修改一个结点
        HeroNode2 gss = new HeroNode2(2, "公孙胜", "入云龙");
        doubleLinkedList.updata(gss);

        System.out.println("修改后的双向链表");
        //修改后显示
        doubleLinkedList.showlist();

        //删除操作
        doubleLinkedList.del(3);

        System.out.println("删除后的双向链表");
        //删除后显示
        doubleLinkedList.showlist();
    }
}

二、单向环形链表以及（约瑟夫问题）

1.构建一个单向环形链表思路

1、先创建第一个结点，让first指向该结点，并形成环形（first不能动，需要辅助变量temp来移动）
2、后面当每创建一个新的结点，就把该结点，加入到已有的环形链表中即可。

遍历单向环形链表
1、先让辅助指针temp（变量），以及指针first指向第一个结点
2、然后通过while循环遍历该环形链表 temp.next==first（表示遍历一圈结束）

2.环形链表的创建的过程

① 创建一个结点类（Person）

// 创建一个Person类表示一个结点
class Person{
    public int no; // 编号
    public Person next; // 指向下一个结点，默认null

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

    public int getNo() {
        return no;
    }

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

    @Override
    public String toString() {
        return "Person{" +
                "no=" + no +
                '}';
    }
}

② 创建一个环形链表的类，其中先创建一个类似头结点的第一个结点first（作为指针），后续在添加结点的方法中给其指向第一个数据结点

// 创建一个环形链表的类
class CircleSingLinkedList{
    // 创建一个first结点，当前没有编号  // 类似头结点，不过后面要赋值
    // private Person first =null;
    private Person first = new Person(-1);

    //添加结点的方法
    public void CircleAdd(int nums){
        // nums做一个数据校验
        if (nums<1){
            System.out.println("输入的nums的值不正确");
            return;
        }
        Person temp=null;  // 创建辅助变量 temp
        // 使用for来创建我们的环形链表
        for (int i=1;i<=nums;i++){
            // 根据编号，创建person结点
            Person person = new Person(i);
            // 如果是第一个人
            if (i==1){
                first=person;      // 第一个结点first指向新结点，编号1
                first.next=first; // 形成一个元素的环形链表
                temp=first;  // 由于first不能动，让temp辅助变量也指向它来替代
            }else {
                temp.next=person;  // 第一个/添加上一个循环中的person结点指向这一循环中的person
                person.next=first; // 这轮循环中的person结点指向，第一个结点
                temp=person;  // temp后移到这轮循环person结点的位置
            }
        }
    }

    // 遍历环形链表
    public void ShowCircleList(){
        if (first.no==-1){  //没有链表
            System.out.println("没有任何人员");
            return;
        }
        // 因为first不能动，因此我们使用一个辅助指针temp（变量）来完成
        Person temp=first;
        while (true){
            System.out.printf("人员的编号为%d：\n",temp.no);
            if (temp.next==first){
                break;
            }
            temp=temp.next;
        }
    }
}

③ 测试环形链表

public class Josephu {
    public static void main(String[] args) {
        // 测试创建一个环形链表和它的遍历
        CircleSingLinkedList circleSingLinkedList = new CircleSingLinkedList();

        // 加入9个Person成员结点进入链表
        circleSingLinkedList.CircleAdd(9);

        // 遍历显示
        circleSingLinkedList.ShowCircleList();
    }
}

3.约瑟夫问题

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

例如：

生成9个成员的出圈小队。
n=9，即有9个成员
k=1，从第一个人开始报数
m=2，每次数2下

思路： 此方法由于first没有使用辅助指针，一直在变化，因此链表的结构受到改变
1、需求创建开始报数结点的例如（first）和指向从开始报数的结点的前一个结点位置的一个辅助指针helper
补充：报数前，先让first和helper移动k-1次
2、当成员报数时，让开始报数的结点和helper指针同时移动m-1次
3、这时就可以将temp指向的小孩结点出圈
first=first.next （first要后移一位）
helper.next=first （helper没有移动，只是它的指向）
原来的first指向的结点就没有任何引用，就会被自动回收

//

根据用户的输入，计算出成员出圈的顺序

/*
 * startNo 表示从第几个成员开始报数
 * countNum 表示数几下
 * nums 表示最初有多少个成员在圈中
 * */

代码如下：

public void countPerson(int startNo,int countNum ,int nums){
        // 先进行数据校验
        if (first==null || startNo<1 || startNo>nums){
            System.out.println("参数输入有误，请重新输入...");
            return;
        }
        // 创建辅助指针，帮助出圈   因为直接移动first，helper的存在保证一直是个环形链表
        Person helper = first;
        // 需求创建一个辅助指针(变量)helper，事先应该指向环形链表最后的结点
        while (true){
            if (helper.next==first){
                break;
            }
            helper=helper.next;
        }
        // 成员报数前，先让first和helper移动k-1次
        for (int j=0;j<startNo-1;j++){
            first=first.next;
            helper=helper.next;
        }
        // 当成员报数时，让first和helper指针同时移动m-1次，然后出圈
        // 这里是一个循环操作，直到圈中只有一个结点
        while (true){
            if (helper==first){
                break;   //圈中只有一个结点
            }

            // 让first和helper指针同时移动到 countNum-1
            for (int j=0;j<countNum-1;j++){
                first=first.next;
                helper=helper.next;
            }

            // 这时first指向的结点，就是要出圈的成员结点
            System.out.printf("成员%d出圈\n",first.no);
            // 这时将first指向的成员结点出圈
            first=first.next;   // first要后移一位
            helper.next=first; //  helper没有移动，只是它的指向
        }
        System.out.printf("最后留在圈中的成员编号%d\n",first.no);
    }

测试如下：

// 测试成员出圈
        circleSingLinkedList.countPerson(1,2,5);