第 4 章 链表

最新推荐文章于 2024-03-05 13:46:58 发布
最新推荐文章于 2024-03-05 13:46:58 发布
阅读量156 收藏 1
点赞数
分类专栏： 【数据结构与算法(Java)】 文章标签： 算法 java 链表 单链表
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51899357/article/details/118494442
版权
本文深入探讨了单向链表的内存结构、逻辑特性和应用场景，如水浒英雄榜的管理，以及单链表的创建、修改、删除和遍历技巧。进一步介绍了双向链表的概念，对比单向链表，展示了其查找和删除操作的优势。重点讲解了Josephus问题的解决方法，以及单向环形链表的应用。
摘要由CSDN通过智能技术生成

第 4 章 链表

1 链表(Linked List)介绍

1.1 内存结构

内存上来看：链表存储空间不连续（不像数组,地址一直在变）

1.2 逻辑结构

img00

逻辑上来看：链表属于线性结构

1.3 链表特点

IMG01
1.链表是以节点的方式来存储，是链式存储；
2.data 域存放数据，next 域指向下一个节点，最后为null代表结束；
3. 链表的各个节点并不是连续的；
4.链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定。

1.4 思路分析

1）单链表的创建示意图(添加), 显示单链表的分析

  • 不考虑顺序
  1. 先创建一个Head 头节点， 作用是表示单链表的头；
  2. 后面我们每添加一个节点， 就直接加入到 链表 的最后。

不

  • 考虑顺序
  1. 首先要找到新添加的节点的位置，通过辅助的temp， 遍历
  2. 新的节点.next = temp.next
  3. 将 temp.next = 新的节点

有

2 链表应用场景

2.1 水浒英雄榜

使用带 head 头的单向链表实现【水浒英雄排行榜管理】

第一种方法：在添加英雄时，直接添加到链表的尾部【不考虑顺序】
第二种方式：在添加英雄时，根据排名将英雄插入到指定位置 (如果有这个排名，则添加失败，并给出提示)【考虑顺序】

2.2 代码实现

2.2.1 不考虑顺序
package practice;
//此时为不考虑顺序， 只能按照加入的先后来排序
public class SingleLinkedListDemo {
    public static void main(String[] args) {
        //测试
        // 1 先创建节点
        HeroNode hero1 = new HeroNode(1, "宋江", "及时雨");
        HeroNode hero2 = new HeroNode(2, "卢俊义", "玉麒麟");
        HeroNode hero3 = new HeroNode(3, "吴用", "智多星");
        HeroNode hero4 = new HeroNode(4, "林冲", "豹子头");

        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //加入
        singleLinkedList.add(hero1);
        singleLinkedList.add(hero2);
        singleLinkedList.add(hero3);
        singleLinkedList.add(hero4);
        //显示
        singleLinkedList.list();
    }
}

//定义一个SingleLinkedList 管理我们的英雄
class SingleLinkedList {
    // 1 创建一个头节点， 头节点不要动， 且不存放任何数据
    private HeroNode head = new HeroNode(0, "", "");

    // 2 添加节点到单向链表
    // 思路： 当不考虑编号顺序时
    //      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 list() {
        //判断链表是否为空
        if (head.next == null) {
            System.out.println("链表为空。");
            return;
        }
        //因为头节点不能动， 我们需要一个 辅助变量
        HeroNode temp = head.next;
        while (true) {
        //判断是否到链表最后了
            if (temp == null) {
                break;
            }
//            System.out.println(temp.toString());
            System.out.println(temp);
            //将temp 后移， 一定要
            temp = temp.next;
        }
    }
}

//定义一个 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 + '\'' +
                '}';
    }
}

程序运行结果：

HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]
2.2.2 考虑顺序

代码实现：

package practiceOrder;

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

        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //加入
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero2);
        //显示
        singleLinkedList.list();
    }
}

//定义一个SingleLinkedList 管理我们的英雄
class SingleLinkedList {
    // 1 创建一个头节点， 头节点不要动， 且不存放任何数据
    private HeroNode head = new HeroNode(0, "", "");

    // 2 添加节点到单向链表
    // 思路： 当考虑编号顺序时
    //       1、 首先要找到新添加的节点的位置，通过辅助的temp， 遍历
    //       2、 `新的节点.next` = `temp.next`
    //       3、 将 `temp.next` = 新的节点
    public void addByOrder(HeroNode heroNode) {

        // 因为 head 节点不能动， 所以我们需要一个辅助遍历 temp
        HeroNode temp = head;
        boolean flag = false;
        // 遍历链表， 找到最后
        while (true) {
            if (temp.next == null) {//temp 已在链表最后
                break;
            }
            if (temp.next.no > heroNode.no) { //位置找到了， 就在 temp 后面插入
                break;
            } else if (temp.next.no == heroNode.no) {//说明希望添加的heroNode的编号已经存在
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;
        }
        //判断flag 的值
        if (flag) {
            System.out.printf("准备添加的英雄编号 %d 已经存在，不能能再添加。", heroNode.no);
        } 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 == null) {
                break;
            }
//            System.out.println(temp.toString());
            System.out.println(temp);
            //将temp 后移， 一定要
            temp = temp.next;
        }
    }
}

//定义一个 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 + '\'' +
                '}';
    }
}

程序运行结果：

HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]

2.3 修改节点信息

2.3.1 代码思路

定义辅助变量 temp ，相当于一个指针，指向当前节点
如何找到指定节点？temp.no = newHeroNode.no

2.3.2 代码实现
package practiceOrder;

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

        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        //加入
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero2);

        //测试修改节点的代码
        HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
        singleLinkedList.update(newHeroNode);
        //显示
        singleLinkedList.list();
    }
}

//定义一个SingleLinkedList 管理我们的英雄
class SingleLinkedList {
    // 1 创建一个头节点， 头节点不要动， 且不存放任何数据
    private HeroNode head = new HeroNode(0, "", "");

    // 2 添加节点到单向链表
    // 思路： 当考虑编号顺序时
    //       1、 首先要找到新添加的节点的位置，通过辅助的temp， 遍历
    //       2、 `新的节点.next` = `temp.next`
    //       3、 将 `temp.next` = 新的节点
    public void addByOrder(HeroNode heroNode) {

        // 因为 head 节点不能动， 所以我们需要一个辅助遍历 temp
        HeroNode temp = head;
        boolean flag = false;
        // 遍历链表， 找到最后
        while (true) {
            if (temp.next == null) {//temp 已在链表最后
                break;
            }
            if (temp.next.no > heroNode.no) { //位置找到了， 就在 temp 后面插入
                break;
            } else if (temp.next.no == heroNode.no) {//说明希望添加的heroNode的编号已经存在
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;
        }
        //判断flag 的值
        if (flag) {
            System.out.printf("准备添加的英雄编号 %d 已经存在，不能能再添加。", heroNode.no);
        } else {
            //插入到链表中
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点， 根据no 编号来修改， 即no 编号不能改
    // 说明：
    //   1) 根据 newHeroNode 的 no 来修改即可
    public void update(HeroNode newHeroNode) {
        // 判断是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //需要找到要修改的的节点， 根据no 编号
        // 先定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;//到链表结束，已经遍历
            }
            if (temp.no == newHeroNode.no) {
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else {//没有找到编号位于此的节点
            System.out.println("没有找到。。");
        }
    }

    //显示链表
    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.toString());
            System.out.println(temp);
            //将temp 后移， 一定要
            temp = temp.next;
        }
    }
}

//定义一个 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 + '\'' +
                '}';
    }
}

2.4 删除节点

2.4.1 代码思路
  1. 我们先要找到需要删除的这个节点的前一个节点；
  2. temp. next = temp.next.next;
  3. 被删除的节点， 将不会有其他引用指向， 会被垃圾回收机制回收。
2.4.2 代码实现
package practiceOrder;

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

        //创建链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();

        //加入
        singleLinkedList.addByOrder(hero3);
        singleLinkedList.addByOrder(hero4);
        singleLinkedList.addByOrder(hero1);
        singleLinkedList.addByOrder(hero2);

        //显示
        singleLinkedList.list();

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

        //删除一个节点
        singleLinkedList.del(1);
        singleLinkedList.del(2);
        singleLinkedList.del(3);
        System.out.println("删除节点后的链表情况：");
        singleLinkedList.list();


    }
}

//定义一个SingleLinkedList 管理我们的英雄
class SingleLinkedList {
    // 1 创建一个头节点， 头节点不要动， 且不存放任何数据
    private HeroNode head = new HeroNode(0, "", "");

    // 2 添加节点到单向链表
    // 思路： 当考虑编号顺序时
    //       1、 首先要找到新添加的节点的位置，通过辅助的temp， 遍历
    //       2、 `新的节点.next` = `temp.next`
    //       3、 将 `temp.next` = 新的节点
    public void addByOrder(HeroNode heroNode) {

        // 因为 head 节点不能动， 所以我们需要一个辅助遍历 temp
        HeroNode temp = head;
        boolean flag = false;
        // 遍历链表， 找到最后
        while (true) {
            if (temp.next == null) {//temp 已在链表最后
                break;
            }
            if (temp.next.no > heroNode.no) { //位置找到了， 就在 temp 后面插入
                break;
            } else if (temp.next.no == heroNode.no) {//说明希望添加的heroNode的编号已经存在
                flag = true;//说明编号存在
                break;
            }
            temp = temp.next;
        }
        //判断flag 的值
        if (flag) {
            System.out.printf("准备添加的英雄编号 %d 已经存在，不能能再添加。", heroNode.no);
        } else {
            //插入到链表中
            heroNode.next = temp.next;
            temp.next = heroNode;
        }
    }

    //修改节点， 根据no 编号来修改， 即no 编号不能改
    // 说明：
    //   1) 根据 newHeroNode 的 no 来修改即可
    public void update(HeroNode newHeroNode) {
        // 判断是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //需要找到要修改的的节点， 根据no 编号
        // 先定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;//到链表结束，已经遍历
            }
            if (temp.no == newHeroNode.no) {
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else {//没有找到编号位于此的节点
            System.out.println("没有找到。。");
        }
    }

    //删除节点
    //思路：
    //1.head 不能动， 因为我们需要一个 temp 辅助节点找到删除节点的前一个节点
    //2.说明我们在比较时， 是 temp.next.no 和 需要删除的节点的 no 比较
    public void del(int no) {
        HeroNode temp = head;
        boolean flag = false;
        while (true) {
            if (temp.next == null) {//已经到最后了
                break;
            }
            if (temp.next.no == no) {
                //找到了带删除节点的前一个节点 temp
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {//找到了
            temp.next = temp.next.next;//删除了节点
        }else {
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }

    //显示链表
    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.toString());
            System.out.println(temp);
            //将temp 后移， 一定要
            temp = temp.next;
        }
    }
}

//定义一个 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 + '\'' +
                '}';
    }
}

结果显示：

HeroNode{no=1, name='宋江', nickName='及时雨'}
HeroNode{no=2, name='卢俊义', nickName='玉麒麟'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
修改后的链表情况：
HeroNode{no=1, name='宋江', nickName='及时雨'}
HeroNode{no=2, name='小卢', nickName='玉麒麟~~'}
HeroNode{no=3, name='吴用', nickName='智多星'}
HeroNode{no=4, name='林冲', nickName='豹子头'}
删除节点后的链表情况：
HeroNode{no=4, name='林冲', nickName='豹子头'}

2.5 总结

遍历链表，执行操作时，判断条件有时候是 temp ，有时候是 temp.next ，Why？
对于插入、删除节点来说，需要知道当前待操作的节点（heroNode）前一个节点的地址（指针），如果直接定位至当前待操作的节点 heroNode ，那没得玩。。。因为不知道heroNode 前一个节点的地址，无法进行插入、删除操作，所以 while 循环中的条件使用 temp.next 进行判断
对于更新、遍历操作来说，我需要的仅仅就只是当前节点的信息，所以 while 循环中的条件使用 temp进行判断
头结点与首节点

头结点是为了操作的统一与方便而设立的，放在第一个元素结点之前，其数据域一般无意义（当然有些情况下也可存放链表的长度、用做监视哨等等）。
首元结点也就是第一个元素的结点，它是头结点后边的第一个结点。

3 单链表面试题

3.1 求单链表中有效节点的个数

3.1.1 代码思路

求单链表中有效节点的个数：遍历即可

3.1.2 代码实现

求单链表中有效节点的个数

// 方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
/**
 * 
 * @param head 链表的头节点
 * @return 返回的就是有效节点的个数
 */
public static int getLength(HeroNode head) {
	if (head.next == null) { // 空链表
		return 0;
	}
	int length = 0;
	// 定义一个辅助的变量, 这里我们没有统计头节点
	HeroNode cur = head.next;
	while (cur != null) {
		length++;
		cur = cur.next; // 遍历
	}
	return length;
}

测试代码

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, "林冲", "豹子头");

    // 创建要给链表
    SingleLinkedList singleLinkedList = new SingleLinkedList();

    // 加入
    singleLinkedList.add(hero1);
    singleLinkedList.add(hero2);
    singleLinkedList.add(hero3);
    singleLinkedList.add(hero4);

    singleLinkedList.list();

    // 测试一下 求单链表中有效节点的个数
    System.out.println("有效的节点个数=" + getLength(singleLinkedList.getHead()));// 2
}

程序运行结果

HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]
有效的节点个数=4

3.2 查找单链表中的倒数第 k 个结点

3.2.1 代码思路

查找单链表中的倒数第k个结点 【新浪面试题】

  1. 首先，获取整个链表中元素的个数 size
  2. 在使用 for 循环定位至倒数第 index（形参） 个节点，返回即可
  3. for 循环的条件应如何确定？for (int i = 0; i < x; i++) 中 x 的值应是多少？我们需要定位至倒数第 index 个节点，在 for 循环之前，我们已经定位置首节点，还需再走 (size - index ) 步，定位至倒数第 index 个节点
  4. 举例说明：链表中一共有 4 个元素，想要定位至倒数第 2 个节点，那么需要在首节点之后走两步，到达倒数第 2 个节点
3.2.2 代码实现

查找单链表中的倒数第k个结点

// 查找单链表中的倒数第k个结点 【新浪面试题】
// 思路
// 1. 编写一个方法，接收head节点，同时接收一个index
// 2. index 表示是倒数第index个节点
// 3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
// 4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
// 5. 如果找到了，则返回该节点，否则返回nulll
public static HeroNode findLastIndexNode(HeroNode head, int index) {
    // 判断如果链表为空，返回null
    if (head.next == null) {
        return null;// 没有找到
    }
    // 第一个遍历得到链表的长度(节点个数)
    int size = getLength(head);
    // 第二次遍历 size-index 位置，就是我们倒数的第K个节点
    // 先做一个index的校验
    if (index <= 0 || index > size) {
        return null;
    }
    // 定义给辅助变量， for 循环定位到倒数的index
    HeroNode cur = head.next; // 3 // 3 - 1 = 2
    for (int i = 0; i < size - index; i++) {
        cur = cur.next;
    }
    return cur;
}

测试代码

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, "林冲", "豹子头");

    // 创建要给链表
    SingleLinkedList singleLinkedList = new SingleLinkedList();

    // 加入
    singleLinkedList.add(hero1);
    singleLinkedList.add(hero2);
    singleLinkedList.add(hero3);
    singleLinkedList.add(hero4);

    singleLinkedList.list();

    // 测试一下看看是否得到了倒数第K个节点
    HeroNode res = findLastIndexNode(singleLinkedList.getHead(), 2);
    System.out.println("res=" + res);

}

程序运行结果

HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]
res=HeroNode [no=3, name=吴用, nickName=智多星]

3.3 单链表的反转

3.3.1 代码思路

单链表的反转【腾讯面试题，有点难度】

  1. 定义一个新的头结点 reverseHead ，一点一点将链表反转后，再串起来
  2. 怎么个串法？
    在原链表中每读取一个节点（cur），先保存其下一个节点的地址（next），然后将 cur 节点放在新链表的最前面
  3. 然后执行遍历：cur = next ，即指针后移
  4. 遍历完成后，新链表即是反转后的链表
  5. 如何将 cur 节点插入在新链表的最前面
    cur.next = reverseHead.next;
    reverseHead.next = cur;
    while 循环终止条件？ cur == null ：已遍历至链表尾部
    单链表的翻转可以参考我的这篇博文：https://blog.csdn.net/oneby1314/article/details/107577923
3.2.2 代码实现

单链表的反转
// 将单链表反转
public static void reversetList(HeroNode head) {
// 如果当前链表为空，或者只有一个节点，无需反转，直接返回
if (head.next == null || head.next.next == null) {
return;
}

// 定义一个辅助的指针(变量)，帮助我们遍历原来的链表
HeroNode cur = head.next;
HeroNode next = null;// 指向当前节点[cur]的下一个节点
HeroNode reverseHead = new HeroNode(0, "", "");
// 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端
// 动脑筋
while (cur != null) {
    next = cur.next;// 先暂时保存当前节点的下一个节点，因为后面需要使用
    cur.next = reverseHead.next;// 将cur的下一个节点指向新的链表的最前端
    reverseHead.next = cur; // 将cur 连接到新的链表上
    cur = next;// 让cur后移
}
// 将head.next 指向 reverseHead.next , 实现单链表的反转
head.next = reverseHead.next;

}
测试代码
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, “林冲”, “豹子头”);

// 创建要给链表
SingleLinkedList singleLinkedList = new SingleLinkedList();

// 加入
singleLinkedList.add(hero1);
singleLinkedList.add(hero2);
singleLinkedList.add(hero3);
singleLinkedList.add(hero4);

// 测试一下单链表的反转功能
System.out.println("原来链表的情况~~");
singleLinkedList.list();

System.out.println("反转单链表~~");
reversetList(singleLinkedList.getHead());
singleLinkedList.list();

}
程序运行结果
原来链表的情况~~
HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]
反转单链表~~
HeroNode [no=4, name=林冲, nickName=豹子头]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=1, name=宋江, nickName=及时雨]

3.3 单链表的反转（我的代码）

3.3.1 代码思路

单链表的反转【腾讯面试题，有点难度】
原链表为 cur 指向 next ，反转链表不就是把 next 指向 cur 吗？
由于 next 指向 cur 时，next 将丢失其下一节点的地址，所以需要先将 nnext 保存起来
next ==null 时链表已经反转完毕，最后将头结点指向 cur 节点即可

3.3.2 代码实现

单链表的反转

// 将单链表反转
public static void myReversetList(HeroNode head) {
    // 如果当前链表为空，或者只有一个节点，无需反转，直接返回
    if (head.next == null || head.next.next == null) {
        return;
    }

    // 当前节点
    HeroNode cur = head.next;	
    // 下一节点
    HeroNode next = cur.next;	
    // 首节点反转后为尾节点，需指向 null
    cur.next = null;

    // next == null 时，链表已经反转完毕
    while (next != null) {
        // 记录 next 的后一节点
        HeroNode nnext = next.next;

        // 反转链表
        next.next = cur;

        // 指针后移
        cur = next;
        next = nnext;
    }

    // 最后加上首节点
    head.next = cur;
}

测试代码

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, "林冲", "豹子头");

    // 创建要给链表
    SingleLinkedList singleLinkedList = new SingleLinkedList();

    // 加入
    singleLinkedList.add(hero1);
    singleLinkedList.add(hero2);
    singleLinkedList.add(hero3);
    singleLinkedList.add(hero4);

    // 测试一下单链表的反转功能
    System.out.println("原来链表的情况~~");
    singleLinkedList.list();

    System.out.println("反转单链表~~");
    reversetList(singleLinkedList.getHead());
    singleLinkedList.list();
}

程序运行结果
原来链表的情况~~

HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]
反转单链表~~
HeroNode [no=4, name=林冲, nickName=豹子头]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=1, name=宋江, nickName=及时雨]

3.4 从尾到头打印单链表

3.4.1 栈的基本使用

测试代码
public static void main(String[] args) {
Stack stack = new Stack();
// 入栈
stack.add(“jack”);
stack.add(“tom”);
stack.add(“smith”);

// 出栈
// smith, tom , jack
while (stack.size() > 0) {
    System.out.println(stack.pop());//pop就是将栈顶的数据取出
}

}
程序运行结果
smith
tom
jack

3.4.2 代码思路

从尾到头打印单链表 【百度，要求方式1：反向遍历 。 方式2：Stack栈】

  • 方式一：先将单链表进行反转操作，然后再遍历输出，问题：破坏原链表结构，不可取
  • 方式二：遍历链表，去除节点压入栈中，利用栈先进后出的特点，实现逆序打印

在这里插入图片描述
思路：

  1. 上面的题的要求就是逆序打印单链表.
  2. 方式1： 先将单链表进行反转操作，然后再遍历即可，这样的做的问题是会破坏原来的单链表的结构，不建议
  3. 方式2：可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果.
    举例演示栈的使用 Stack：见3.4.1 栈的基本使用
3.4.3 代码实现

从尾到头打印单链表
// 方式2：
// 可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果
public static void reversePrint(HeroNode head) {
if (head.next == null) {
return;// 空链表，不能打印
}
// 创建要给一个栈，将各个节点压入栈
Stack stack = new Stack();
HeroNode cur = head.next;
// 将链表的所有节点压入栈
while (cur != null) {
stack.push(cur);
cur = cur.next; // cur后移，这样就可以压入下一个节点
}
// 将栈中的节点进行打印,pop 出栈
while (stack.size() > 0) {
System.out.println(stack.pop()); // stack的特点是先进后出
}
}
测试代码
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, “林冲”, “豹子头”);

//创建要给链表
SingleLinkedList singleLinkedList = new SingleLinkedList();

//加入
singleLinkedList.add(hero1);
singleLinkedList.add(hero2);
singleLinkedList.add(hero3);
singleLinkedList.add(hero4);

System.out.println("原来链表的情况~~");
singleLinkedList.list();

System.out.println("测试逆序打印单链表, 没有改变链表的结构~~");
reversePrint(singleLinkedList.getHead());

}
程序运行结果
原来链表的情况~~
HeroNode [no=1, name=宋江, nickName=及时雨]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=4, name=林冲, nickName=豹子头]
测试逆序打印单链表, 没有改变链表的结构~~
HeroNode [no=4, name=林冲, nickName=豹子头]
HeroNode [no=3, name=吴用, nickName=智多星]
HeroNode [no=2, name=卢俊义, nickName=玉麒麟]
HeroNode [no=1, name=宋江, nickName=及时雨]

3.5 合并两个有序的单链表

3.5.1 代码思路

合并两个有序的单链表，合并之后的链表依然有序【课后练习】

3.5.2 代码实现

合并两个有序的单链表，合并之后的链表依然有序
具体讲解见我的一篇博客：https://blog.csdn.net/oneby1314/article/details/107590876

3.6 单向链表所有代码

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, "林冲", "豹子头");
		
		//创建要给链表
		SingleLinkedList singleLinkedList = new SingleLinkedList();
		
		
		//加入
		singleLinkedList.add(hero1);
		singleLinkedList.add(hero4);
		singleLinkedList.add(hero2);
		singleLinkedList.add(hero3);

		// 测试一下单链表的反转功能
		System.out.println("原来链表的情况~~");
		singleLinkedList.list();
		
		System.out.println("反转单链表~~");
		reversetList(singleLinkedList.getHead());
		singleLinkedList.list();
		
		System.out.println("测试逆序打印单链表, 没有改变链表的结构~~");
		reversePrint(singleLinkedList.getHead());
		

		//加入按照编号的顺序
		singleLinkedList.addByOrder(hero1);
		singleLinkedList.addByOrder(hero4);
		singleLinkedList.addByOrder(hero2);
		singleLinkedList.addByOrder(hero3);
		
		//显示一把
		singleLinkedList.list();
		
		//测试修改节点的代码
		HeroNode newHeroNode = new HeroNode(2, "小卢", "玉麒麟~~");
		singleLinkedList.update(newHeroNode);
		
		System.out.println("修改后的链表情况~~");
		singleLinkedList.list();
		
		//删除一个节点
		singleLinkedList.del(1);
		singleLinkedList.del(4);
		System.out.println("删除后的链表情况~~");
		singleLinkedList.list();
		
		//测试一下 求单链表中有效节点的个数
		System.out.println("有效的节点个数=" + getLength(singleLinkedList.getHead()));//2
		
		//测试一下看看是否得到了倒数第K个节点
		HeroNode res = findLastIndexNode(singleLinkedList.getHead(), 3);
		System.out.println("res=" + res);

	}

	// 方式2：
	// 可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，就实现了逆序打印的效果
	public static void reversePrint(HeroNode head) {
		if (head.next == null) {
			return;// 空链表，不能打印
		}
		// 创建要给一个栈，将各个节点压入栈
		Stack<HeroNode> stack = new Stack<HeroNode>();
		HeroNode cur = head.next;
		// 将链表的所有节点压入栈
		while (cur != null) {
			stack.push(cur);
			cur = cur.next; // cur后移，这样就可以压入下一个节点
		}
		// 将栈中的节点进行打印,pop 出栈
		while (stack.size() > 0) {
			System.out.println(stack.pop()); // stack的特点是先进后出
		}
	}

	// 将单链表反转
	public static void reversetList(HeroNode head) {
		// 如果当前链表为空，或者只有一个节点，无需反转，直接返回
		if (head.next == null || head.next.next == null) {
			return;
		}

		// 定义一个辅助的指针(变量)，帮助我们遍历原来的链表
		HeroNode cur = head.next;
		HeroNode next = null;// 指向当前节点[cur]的下一个节点
		HeroNode reverseHead = new HeroNode(0, "", "");
		// 遍历原来的链表，每遍历一个节点，就将其取出，并放在新的链表reverseHead 的最前端
		// 动脑筋
		while (cur != null) {
			next = cur.next;// 先暂时保存当前节点的下一个节点，因为后面需要使用
			cur.next = reverseHead.next;// 将cur的下一个节点指向新的链表的最前端
			reverseHead.next = cur; // 将cur 连接到新的链表上
			cur = next;// 让cur后移
		}
		// 将head.next 指向 reverseHead.next , 实现单链表的反转
		head.next = reverseHead.next;
	}

	// 将单链表反转
	public static void myReversetList(HeroNode head) {
		// 如果当前链表为空，或者只有一个节点，无需反转，直接返回
		if (head.next == null || head.next.next == null) {
			return;
		}

		// 当前节点
		HeroNode cur = head.next;	
		// 下一节点
		HeroNode next = cur.next;	
		// 首节点反转后为尾节点，需指向 null
		cur.next = null;

		// next == null 时，链表已经反转完毕
		while (next != null) {
			// 记录 next 的后一节点
			HeroNode nnext = next.next;
			
			// 反转链表
			next.next = cur;
			
			// 指针后移
			cur = next;
			next = nnext;
		}

		// 最后加上头结点
		head.next = cur;
	}

	// 查找单链表中的倒数第k个结点 【新浪面试题】
	// 思路
	// 1. 编写一个方法，接收head节点，同时接收一个index
	// 2. index 表示是倒数第index个节点
	// 3. 先把链表从头到尾遍历，得到链表的总的长度 getLength
	// 4. 得到size 后，我们从链表的第一个开始遍历 (size-index)个，就可以得到
	// 5. 如果找到了，则返回该节点，否则返回nulll
	public static HeroNode findLastIndexNode(HeroNode head, int index) {
		// 判断如果链表为空，返回null
		if (head.next == null) {
			return null;// 没有找到
		}
		// 第一个遍历得到链表的长度(节点个数)
		int size = getLength(head);
		// 第二次遍历 size-index 位置，就是我们倒数的第K个节点
		// 先做一个index的校验
		if (index <= 0 || index > size) {
			return null;
		}
		// 定义给辅助变量， for 循环定位到倒数的index
		HeroNode cur = head.next; // 3 // 3 - 1 = 2
		for (int i = 0; i < size - index; i++) {
			cur = cur.next;
		}
		return cur;

	}

	// 方法：获取到单链表的节点的个数(如果是带头结点的链表，需求不统计头节点)
	/**
	 * 
	 * @param head 链表的头节点
	 * @return 返回的就是有效节点的个数
	 */
	public static int getLength(HeroNode head) {
		if (head.next == null) { // 空链表
			return 0;
		}
		int length = 0;
		// 定义一个辅助的变量, 这里我们没有统计头节点
		HeroNode cur = head.next;
		while (cur != null) {
			length++;
			cur = cur.next; // 遍历
		}
		return length;
	}

}

//定义SingleLinkedList 管理我们的英雄
class SingleLinkedList {
	// 先初始化一个头节点, 头节点不要动, 不存放具体的数据
	private HeroNode head = new HeroNode(0, "", "");

	// 返回头节点
	public HeroNode getHead() {
		return head;
	}

	// 添加节点到单向链表
	// 思路，当不考虑编号顺序时
	// 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就指向了链表的最后
		// 将最后这个节点的next 指向 新的节点
		temp.next = heroNode;
	}

	// 第二种方式在添加英雄时，根据排名将英雄插入到指定位置
	// (如果有这个排名，则添加失败，并给出提示)
	public void addByOrder(HeroNode heroNode) {
		// 因为头节点不能动，因此我们仍然通过一个辅助指针(变量)来帮助找到添加的位置
		// 因为单链表，因为我们找的temp 是位于 添加位置的前一个节点，否则插入不了
		HeroNode temp = head;
		boolean flag = false; // flag标志添加的编号是否存在，默认为false
		while (true) {
			if (temp.next == null) {// 说明temp已经在链表的最后
				break; //
			}
			if (temp.next.no > heroNode.no) { // 位置找到，就在temp的后面插入
				break;
			} else if (temp.next.no == heroNode.no) {// 说明希望添加的heroNode的编号已然存在

				flag = true; // 说明编号存在
				break;
			}
			temp = temp.next; // 后移，遍历当前链表
		}
		// 判断flag 的值
		if (flag) { // 不能添加，说明编号存在
			System.out.printf("准备插入的英雄的编号 %d 已经存在了, 不能加入\n", heroNode.no);
		} else {
			// 插入到链表中, temp的后面
			heroNode.next = temp.next;
			temp.next = heroNode;
		}
	}

	// 修改节点的信息, 根据no编号来修改，即no编号不能改.
	// 说明
	// 1. 根据 newHeroNode 的 no 来修改即可
	public void update(HeroNode newHeroNode) {
		// 判断是否空
		if (head.next == null) {
			System.out.println("链表为空~");
			return;
		}
		// 找到需要修改的节点, 根据no编号
		// 定义一个辅助变量
		HeroNode temp = head.next;
		boolean flag = false; // 表示是否找到该节点
		while (true) {
			if (temp == null) {
				break; // 已经遍历完链表
			}
			if (temp.no == newHeroNode.no) {
				// 找到
				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);
		}
	}

	// 删除节点
	// 思路
	// 1. head 不能动，因此我们需要一个temp辅助节点找到待删除节点的前一个节点
	// 2. 说明我们在比较时，是temp.next.no 和 需要删除的节点的no比较
	public void del(int no) {
		HeroNode temp = head;
		boolean flag = false; // 标志是否找到待删除节点的
		while (true) {
			if (temp.next == null) { // 已经到链表的最后
				break;
			}
			if (temp.next.no == no) {
				// 找到的待删除节点的前一个节点temp
				flag = true;
				break;
			}
			temp = temp.next; // temp后移，遍历
		}
		// 判断flag
		if (flag) { // 找到
			// 可以删除
			temp.next = temp.next.next;
		} else {
			System.out.printf("要删除的 %d 节点不存在\n", no);
		}
	}

	// 显示链表[遍历]
	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 + "]";
	}

}

4 双向链表

4.1 与单向链表的比较

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

比较单与双
实现思路

4.2 代码实现

package DoubleLinkedList;


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

        //创建链表
        DoubleLinkedList doubleLinkedList = new DoubleLinkedList();

        //加入
        doubleLinkedList.add(hero3);
        doubleLinkedList.add(hero4);
        doubleLinkedList.add(hero1);
        doubleLinkedList.add(hero2);

        //显示
        doubleLinkedList.list();

        //测试修改节点的代码
        HeroNode newHeroNode = new HeroNode(2, "公孙胜", "入云龙");
        doubleLinkedList.update(newHeroNode);
        System.out.println("修改后的链表情况：");
        doubleLinkedList.list();

        //删除一个节点
        doubleLinkedList.del(1);
        doubleLinkedList.del(2);
        doubleLinkedList.del(3);
        System.out.println("删除节点后的链表情况：");
        doubleLinkedList.list();

    }
}

//创建一个双向链表的类
class DoubleLinkedList {
    // 创建一个头节点， 头节点不要动， 且不存放任何数据
    private HeroNode head = new HeroNode(0, "", "");

    //返回头节点
    public HeroNode getHead() {
        return head;
    }

    //遍历双向链表
    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.toString());
            System.out.println(temp);
            //将temp 后移， 一定要
            temp = temp.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;
        heroNode.pre = temp;
    }

    // 修改一个节点的内容
    public void update(HeroNode newHeroNode) {
        // 判断是否为空
        if (head.next == null) {
            System.out.println("链表为空");
            return;
        }
        //需要找到要修改的的节点， 根据no 编号
        // 先定义一个辅助变量
        HeroNode temp = head.next;
        boolean flag = false;
        while (true) {
            if (temp == null) {
                break;//到链表结束，已经遍历
            }
            if (temp.no == newHeroNode.no) {
                //找到
                flag = true;
                break;
            }
            temp = temp.next;
        }
        if (flag) {
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else {//没有找到编号位于此的节点
            System.out.printf("没有找到%d", newHeroNode.no);
        }
    }

    //删除一个节点
    //1. 对于双向链表， 我们可以直接找到要删除的这个节点
    //2. 找到后，删除即可
    public void del(int no) {
        //判断当前链表是否为空
        if (head.next == null) {
            System.out.println("链表为空， 无法删除。");
            return;
        }
        HeroNode 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.next = temp.next.next;//删除了节点[单向链表]
            temp.pre.next = temp.next;
            //这里我们的代码有问题
            //如果是最后一个， 就不需要执行下面的代码， 否则会空指针异常
            if (temp.next != null) {
                temp.next.pre = temp.pre;
            }
        } else {
            System.out.printf("要删除的 %d 节点不存在\n", no);
        }
    }

}

class HeroNode {
    public int no;
    public String name;
    public String nickName;
    public HeroNode next;//指向下一个节点，默认为null
    public HeroNode pre;//指向前一个节点，默认为null

    //构造器
    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 + '\'' +
                '}';
    }
}

4.3 总结

辅助变量 temp ，相当于一个指针，指向当前节点
如果定位至当前节点会丢失前一个节点的信息，那么我们只能定位至待操作节点的前一个节点：使用 temp.next 进行条件判断

5 单向环形链表

5.1 单向环形链表应用场景

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

5.2 单向环形链表图解

图解

5.3 Josephu 问题

用一个不带头结点的循环链表来处理 Josephu 问题：
先构成一个有 n 个结点的单循环链表， 然后由 k 结点起从 1 开始计数， 计到 m 时， 对应结点从链表中删除， 然后再从被删除结点的下一个结点又从 1 开始计数， 直到最后一个结点从链表中删除算法结束。
出圈顺序
m:2
思路
构建一个单向的环形链表思路

  1. 先创建第一个节点, 让 first 指向该节点，并形成环形
  2. 后面当我们每创建一个新的节点，就把该节点，加入到已有的环形链表中即可.

遍历环形链表

  1. 先让一个辅助指针(变量) curBoy，指向first节点
  2. 然后通过一个while循环遍历 该环形链表即可 curBoy.next == first 结束

出圈思路：

  1. 需要创建一个辅助指针（bian）
  2. 在这里插入图片描述

5.4 代码实现

package Josepfu;

public class Josepfu {
    public static void main(String[] args) {
        CircleSingleLinkedList circleSingleLinkedList = new CircleSingleLinkedList();
        circleSingleLinkedList.addBoy(5);//加入五个小盆友
        circleSingleLinkedList.showBoy();

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

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

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

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

//根据用户输入，计算出小孩出圈的顺序

    /**
     * startNo     表示从第几个小孩子开始数数
     * countNum    表示数几下
     * nums        表示最初有几个小孩在圈中
     */
    public void countBoy(int startNo, int countNum, int nums) {
        //先对数据校验
        if (first == null || startNo < 1 || startNo > nums) {
            System.out.println("参数有误，请重新输入。");
            return;
        }
        //创建辅助指针，帮助小孩出圈
        Boy helper = first;
        // 1. 需要创建一个辅助指针(变量) helper, 事先应该指向环形链表的最后的这个节点
        while (true) {
            if (helper.getNext() == first) {
                break;
            }
            helper = helper.getNext();
        }
        // 2. 小孩报数前， 先让first 和 helper 移动 k-1次
        for (int j = 0; j < startNo - 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.getNext();
            helper.setNext(first);//最后只剩下一个，就break了
        }
        System.out.printf("最后留在圈中的小孩编号为 %d \n", helper.getNo());
    }
}


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

    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;
    }

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

}
好饿呀~～～
关注
专栏目录
链表及其应用场景
m0_73111279的博客
09-05 3823
链表的基本应用场景，以及力扣经典题目
第三章 链表
CoderJay
03-03 210
第三章 链表 4.1 链表(Linked List)介绍 链表是有序的列表，但是它在内存中是存储如下 小结上图: 链表是以节点的方式来存储,是链式存储 每个节点包含data 域， next 域：指向下一个节点. 如图：发现链表的各个节点不一定是连续存储. 链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定 单链表(带头结点) 逻辑结构示意图如下： 4.2 单链表的应用实例 使用带head 头的单向链表实现–水浒英雄排行榜管理完成对英雄人物的增删改查操作 第一种方法在添加英雄时，直接添加
链表（Linked List）算法的使用场景和使用例子详解
最新发布
一如既往的准备文章
03-05 2687
python复制代码。
链表经典应用场景：LRU缓存淘汰算法
weixin_45254641的博客
04-23 739
链表经典应用场景：LRU缓存淘汰算法 或许很多人并不知道学习算法与数据结构到底有什么用，只是人云亦云。 哦算法与数据结构很重要，学就完事！ 但是任何脱离实际应用的学习，都不能掌握其精髓！ 所以我们需要通过具体的应用场景去分析使用哪个算法，使用哪个数据结构能够达到最好的效果。 在某些场景下需要用时间复杂度去置换空间复杂度，比如在一些小型硬件上，没有太多的存储资源，采用这种方式比较好。 而在某些性能要求高的场景下，则需要用空间复杂度去置换时间复杂度了。 所以呢我将创建一个系列，专门从实际应用的角度去讲解如何使
链表的运用
accumla的博客
03-25 297
#include<stdio.h> #include<malloc.h> #define LEN sizeof(struct student) typedef struct student { long num; float score; struct student *next;/*指向链表的下一个结点**/ }stu; /*声明结构体...
链表的实际应用1
染指弦
04-25 6969
在上次的《链表的基本应用》中，大致的说明了；链表的基本算法和概念，但这也只是书面的介绍而已，而它到底怎么用连我自己也不是很清楚，所以现在在练一些可以用链表来做题的题目，做了几道题，觉得还可以，所以现在再来理一遍思路； “链表的使用主要是要依靠指针和动态空间” （1）：通讯录的使用:这个同学们应该比较熟悉吧，先说为什么要用链表吧，因为通讯录中的信息是不确定的，可增加，也可减少，如果只允许
数据结构 第一章 前置知识 链表
12-16
数据结构第一章前置知识链表 本章主要讲链表的知识，包括链表的创建、增删改查。下面是对链表的详细介绍： 什么是链表？ 链表是一种数据结构，它是一种动态分配的数据结构，通过指针将零散的内存块串联起来。链表...
《华中师大c语言数据结构》第2章 链表__自测卷答案1
08-04
《华中师大c语言数据结构》第二章主要讲解了链表这一重要...以上就是关于《华中师大c语言数据结构》第二章链表的自测卷答案中涉及到的全部知识点的详细解析。理解并掌握这些知识点对于深入学习链表和数据结构至关重要。
第11章 动态数据结构-链表-21
08-03
4. **链接节点**：将节点连接成链表，是通过设置每个节点的`next`指针指向其后继节点来完成的。例如，`pl1->next = pl2;`表示`pl1`之后是`pl2`。 5. **头指针**：头指针指向链表的第一个节点。在示例中，`head`变量...
数据结构和算法(第四章链表)
m0_50507927的博客
03-07 3620
文章目录前言一、链表介绍1.链表在内存中的存储(真实存储)2.单链表(带头节点)逻辑结构二、单向链表的实现1.不考虑编号顺序时，添加英雄分析2.不考虑编号顺序时，添加英雄代码3.考虑编号顺序时，添加英雄分析4.考虑编号顺序时，添加英雄代码5.单链表的修改6.单链表的删除7.单链表小练-问题1：求单链表中有效节点的个数8.单链表小练-问题2：查找单链表中的倒数第k个节点9.单链表小练-问题3：单链表的反转(头插法)10.单链表小练-问题3：二、使用步骤1.引入库2.代码3.小练二、使用步骤1.引入库2.代码.
链表的应用
天行健，君子以自强不息
05-13 3182
题目：求相邻k个节点数值之和最大的第一节点 输入数据（设为整型）建立单链表，并求相邻k个节点data值之和为最大的第一节点。例如输入k = 2，数据为2 6 4 7 3 #（#为结束符），建立下面链表，运行结果输出（序号3，data值4）： 书上学的数据结构总是用指针和链表来操作，和刷题时的程序有点不一样，需要多练习 #include #include int k,k1;
数据结构--链表实际场景应用
BtWangZhi的博客
04-28 1533
时间应用场景，构造一个固定长度的列表，达到固定长度后，自动淘汰尾部的节点 /** * 固定大小的容器，当添加的个数达到上限时， * 自动淘汰添加时间最长的元素 * * @param <E> */ private static class FixElementList<E> { /** * 头指针 */ private Node<E> he
【了解链表的适用场景；掌握单向链表、双向链表的使用】（学习笔记18--链表）
北豼不太皮的博客
03-23 2832
链表中的节点和火车的车厢一样，是一个连着一个的，通常将当前节点的前一个或上一个节点称为它的前驱节点，将后一个或者下一个节点称之为它的后续节点。链表中的第一个节点被称为头节点，最后一个节点被称为尾节点。在链表中，头节点是没有前驱的节点，尾节点是没有后续的节点，其它的所有节点都称为中间节点，中间节点都会拥有一个前驱节点和一个后续节点。
链表的概念、使用场景、常见链表
qq_43334139的博客
03-01 1802
回答了什么是链表，为什么使用链表，以及常用的链表及其使用场景
Java--数组和链表的区别以及使用场景
weixin_30799995的博客
06-25 541
数组：是将元素在内存中连续存储的；它的优点：因为数据是连续存储的，内存地址连续，所以在查找数据的时候效率比较高；它的缺点：在存储之前，我们需要申请一块连续的内存空间，并且在编译的时候就必须确定好它的空间的大小。在运行的时候空间的大小是无法随着你的需要进行增加和减少而改变的，当数据两比较大的时候，有可能会出现越界的情况，数据比较小的时候，又有可能会浪费掉内存空间。在改变数据个数时，增加、插入、删除数...
一问读懂链表结构，及应用场景
兴趣是最好的老师，勤能补拙
05-19 1351
Java中的链表结构是指，将一组数据按照指定规则连接起来的数据结构。它由多个节点组成，每个节点包含一个数据元素和一个指向下一个节点的引用。在Java中，这种数据结构被封装成了一个链表类，常见的有单向链表、双向链表和循环链表等。
数据结构之链表C语言实现以及使用场景分析
weixin_30482181的博客
07-09 586
牢骚：本篇博客两个星期前已经存为草稿，鉴于发生一些糟糕的事情，今天才基本完成。本人6月份应届毕业生一枚，毕业后当天来到帝都，之后也非常顺利，面试了俩家公司都成功了。一家做C++方面电商ERP，一家做wifi模块，觉得第二家公司小，薪资低，但是觉得好玩就去了。同时，在学校也喝了不少鸡汤，觉得公司小怎么了。然而去了不到20天，公司被深圳一家公司收购了，公司动员我去深圳，我尼玛我才来20多天啊，有木有？...
线性表基础：链表及经典问题（一）链表的基础知识、典型应用场景、经典算法题刷题（链表的访问）
语雀同名：犬豪 yuque.com/qhao
03-14 564
一、链表的基础知识 1.1 链表的结构 节点 数据域 指针域 实现方式包括：地址（C语言）、下标（相对地址，数组下标）、引用（Java、JS、Python） 链状结构 通过指针域的值形成了一个线性结构 这个图是C语言中的链表，head中只存储指针 head就是C语言中的指针，在Java中相当于一个引用 它本身不是一个对象，也不是一个链表节点 总结：只要在相关的结构中增加了一项指针域，则该结构就可以串成一个链表结构 答疑： C语言的地址一般情况下都是虚拟地址，不是物理地址
顺序表与链表的比较及其使用场景
swo_ows的博客
10-18 1223
顺序表 头和中间插入、删除效率低，可随机访问，CPU高速缓存效率高 链表 任意位置插入删除高效，不可随机访问，CPU高速缓存效率低 使用场景 从它们的优缺点可以看出，在需要大量的插入和删除操作时使用链表，需要随机访问时使用顺序表...
C++链表讲解：清华大学第九章链表教程
"这份资源是清华大学的一份关于C++链表的PPT，主要涵盖了链表的基本概念、动态内存分配、单向链表和双向链表的定义与操作。" 在计算机科学中，链表是一种重要的数据结构，它不同于数组，不连续存储数据。在C++中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

好饿呀~～～

我这么菜，配得上你的打赏吗？

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值