1.1.1先看几个经典的算法面试题

  1. 字符串匹配问题：

    1. 有一个字符串 str1= “”硅硅谷 尚硅谷你尚硅 尚硅谷你尚硅谷你尚硅你好””，和一个子串 str2=”尚硅谷你尚
    2. 硅你”
    3. 现在要判断 str1 是否含有 str2, 如果存在，就返回第一次出现的位置, 如果没有，则返回-1
    4. 要求用最快的速度来完成匹配
    5. 你的思路是什么？

      暴力匹配 [简单，但是效率低] KMP 算法《部分匹配表》

  2. 汉诺塔游戏, 请完成汉诺塔游戏的代码: 要求：1) 将 A 塔的所有圆盘移动到 C 塔。并且规定，在 2) 小圆盘上不能放大圆盘，3)在三根柱子之间一次只能移动一个圆盘

image.png

  1. 八皇后问题八皇后问题，是一个古老而著名的问题，是回溯算法的典型案例。该问题是国际西洋棋棋手马克斯·贝瑟尔于1848 年提出：在 8×8 格的国际象棋上摆放八个皇后，使其不能互相攻击，即：任意两个皇后都不能处于同一行、同一列或同一斜线上，问有多少种摆法。【92】=> 分治算法

image.png

  1. 马踏棋盘算法介绍和游戏演示
    1. 1) 马踏棋盘算法也被称为骑士周游问题
    2. 2) 将马随机放在国际象棋的 8×8 棋盘 Board[0～7][0～7]的某个方格中，马按走棋规则(马走日字)进行移动。要求每个方格只进入一次，走遍棋盘上全部 64 个方格
    3. 3) 游戏演示: http://www.4399.com/flash/146267_2.htm
    4. 4) 会使用到图的深度优化遍历算法(DFS) + 贪心算法优化

image.png

1.1.2数据结构和算法的重要性

  1. 算法是程序的灵魂，优秀的程序可以在海量数据计算时，依然保持高速计算
  2. 一般来讲 程序会使用了内存计算框架(比如 Spark)和缓存技术(比如 Redis 等)来优化程序,再深入的思考一下，这些计算框架和缓存技术， 它的核心功能是哪个部分呢？
  3. 拿实际工作经历来说, 在 Unix 下开发服务器程序，功能是要支持上千万人同时在线，在上线前，做内测，一切OK,可上线后，服务器就支撑不住了, 公司的 CTO 对代码进行优化，再次上线，坚如磐石。你就能感受到程序是有灵魂的，就是算法。
  4. 目前程序员面试的门槛越来越高，很多一线 IT 公司(大厂)，都会有数据结构和算法面试题(负责的告诉你，肯定有的

  5. 如果你不想永远都是代码工人,那就花时间来研究下数据结构和算法

    第 2 章 数据结构和算法概述

    2.1.1数据结构和算法的关系

  6. 数据 data 结构(structure)是一门研究组织数据方式的学科，有了编程语言也就有了数据结构.学好数据结构可以编写出更加漂亮,更加有效率的代码。

  7. 要学习好数据结构就要多多考虑如何将生活中遇到的问题,用程序去实现解决.
  8. 程序 = 数据结构 + 算法
  9. 数据结构是算法的基础, 换言之，想要学好算法，需要把数据结构学到位。

    2.2 看几个实际编程中遇到的问题

    2.2.1问题一-字符串替换问题

    image.png

小结：需要使用到单链表数据结构

2.2.2一个五子棋程序

image.png
如何判断游戏的输赢，并可以完成存盘退出和继续上局的功能

  1. 棋盘 二维数组=>(稀疏数组)-> 写入文件 【存档功能】

  2. 读取文件-》稀疏数组-》二维数组 -》 棋盘 【接上局】

    2.2.3约瑟夫(Josephu)问题(丢手帕问题)

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

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

  5. 小结：完成约瑟夫问题，需要使用到单向环形链表 这个数据结构

    2.2.4其它常见算法问题:

  6. 修路问题 => 最小生成树(加权值)【数据结构】+ 普利姆算法

  7. 最短路径问题 => 图+弗洛伊德算法
  8. 汉诺塔 => 分支算法

  9. 八皇后问题 => 回溯法

    2.3 线性结构和非线性结构

    2.3.1线性结构

  10. 线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系

  11. 线性结构有两种不同的存储结构，即顺序存储结构(数组)和链式存储结构(链表)。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的
  12. 链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息

  13. 线性结构常见的有：数组、队列、链表和栈

    2.3.2非线性结构

    非线性结构包括：二维数组，多维数组，广义表，树结构，图结构

    第 3 章 稀疏数组和队列

    3.1 稀疏 sparsearray 数组

    3.1.1先看一个实际的需求

    编写的五子棋程序中，有存盘退出和续上盘的功能。
    image.png
    分析问题:
    因为该二维数组的很多值是默认值0, 因此记录了很多没有意义的数据.->稀疏数组。

    3.1.2基本介绍

    当一个数组中大部分元素为０，或者为同一个值的数组时，可以使用稀疏数组来保存该数组。
    稀疏数组的处理方法是:

    1. 记录数组一共有几行几列，有多少个不同的值
    2. 把具有不同值的元素的行列及值记录在一个小规模的数组中，从而缩小程序的规模

稀疏数组举例说明：
image.png

3.1.3应用实例

  1. 使用稀疏数组，来保留类似前面的二维数组(棋盘、地图等等)
  2. 把稀疏数组存盘，并且可以从新恢复原来的二维数组数
  3. 整体思路分析

image.png
image.png
稀疏数组代码实现

  1. package Data;
  3. /*
  4. 稀疏数组的代码实现，
  5.  */
  7. public class SparseArray {
  8.     public static void main(String[] args) {
  9.         /*
  10.         二维数组转稀疏数组
  11.          */
  12.         //先创建一个原始的二维数组
  13.         //0表示没有棋子；1表示黑子；2表示篮子
  14.         int chessArr[][]=new int[11][11];
  15.         chessArr[1][2]=1;
  16.         chessArr[2][3]=2;
  17.         chessArr[4][5]=2;
  18.         //输出原始数组
  19.         System.out.println("输出原始数组");
  20.         for (int[] row:chessArr){
  21.             for (int data:row){
  22.                 System.out.printf("%d\t",data);
  23.             }
  24.             System.out.println();
  25.         }
  26.         //将二维数组转为稀疏数组
  27.         //1.遍历二维数组，得到非零数据的个数
  28.         int sum=0;
  29.         for (int i = 0; i < 11; i++) {
  30.             for (int j = 0; j < 11; j++) {
  31.                 if (chessArr[i][j]!=0){
  32.                     sum++;
  33.                 }
  34.             }
  35.         }
  36.         System.out.println();
  37.         System.out.println(sum);
  38.         //2.创建对应的稀疏数组
  39.         int sparseArr[][]=new int[sum+1][3];
  40.         //给稀疏数组赋值
  41.          sparseArr[0][0]=11;
  42.          sparseArr[0][1]=11;
  43.          sparseArr[0][2]=sum;
  44.          //遍历二维数组，将非零数据放到稀疏数组
  45.         int count=0;//count用于记录是第几个非零数据
  46.         for (int i = 0; i < 11; i++) {
  47.             for (int j = 0; j < 11; j++) {
  48.                 if (chessArr[i][j]!=0){
  49.                     count++;
  50.                     sparseArr[count][0]=i;
  51.                     sparseArr[count][1]=j;
  52.                     sparseArr[count][2]=chessArr[i][j];
  53.                 }
  54.             }
  55.         }
  56.         //输出稀疏数组的形式
  57.         System.out.println();
  58.         System.out.println("得到的稀疏数组如下");
  59.         for (int i = 0; i < sparseArr.length; i++) {
  60.             System.out.printf("%d\t%d\t%d\t\n",sparseArr[i][0],sparseArr[i][1],sparseArr[i][2]);
  61.         }
  63.         /*
  64.         稀疏数组转二维数组
  65.          */
  66.         //1.先读取稀疏数组的第一行，根据第一行的数据，创建原始的二维数组
  67.          int chessArr1[][]=new int[sparseArr[0][0]][sparseArr[0][1]];
  68.          //输出恢复结构的二维数组
  69.         System.out.println();
  70.         for (int[] row:chessArr1){
  71.             for (int data:row){
  72.                 System.out.printf("%d\t",data);
  73.             }
  74.             System.out.println();
  75.         }
  76.         //2.读取后面几行的数据(从第二行开始)，并赋给原始的二维数组即可
  77.         for (int i = 1; i < sparseArr.length; i++) {
  78.             chessArr1[sparseArr[i][0]][sparseArr[i][1]]=sparseArr[i][2];
  79.         }
  80.         //输出恢复完全的二维数组
  81.         System.out.println();
  82.         for (int[] row:chessArr1){
  83.             for (int data:row){
  84.                 System.out.printf("%d\t",data);
  85.             }
  86.             System.out.println();
  87.         }
  88.     }
  89. }

3.2队列

  • 队列的一个使用场景
  • 银行排队的案例:
    • image.png
  • 队列介绍
    • 队列是一个有序列表，可以用数组或是链表来实现。
    • 遵循先入先出的原则。即：先存入队列的数据，要先取出。后存入的要后取出
    • 示意图：(使用数组模拟队列示意图)
      • image.png
  • 数组模拟队列
    • 队列本身是有序列表，若使用数组的结构来存储队列的数据，则队列数组的声明如下图, 其中 maxSize是该队列的最大容量。
    • 因为队列的输出、输入是分别从前后端来处理，因此需要两个变量 front及 rear分别记录队列前后端的下标，front 会随着数据输出而改变，而 rear则是随着数据输入而改变，如图所示:
      • image.png
    • 当我们将数据存入队列时称为”addQueue”，addQueue的处理需要有两个步骤：思路分析
      • 1)将尾指针往后移：rear+1 , 当front == rear 【空】
      • 2)若尾指针 rear 小于队列的最大下标 maxSize-1，则将数据存入 rear所指的数组元素中，否则无法存入数据。 rear == maxSize - 1[队列满]
    • 队列代码实现 ```java package queue;

import java.util.Scanner;

/ 队列 / public class ArrayQueueDemo { public static void main(String[] args) { ArrayQueue arrayQueue = new ArrayQueue(3); char key=’ ‘;//接收用户的输入 Scanner scanner = new Scanner(System.in); boolean loop=true; //输出一个菜单 while (loop){ System.out.println(“s(show):显示队列”); System.out.println(“e(exit):退出程序”); System.out.println(“a(add):添加数据到队列”); System.out.println(“g(get):从队列取出数据”); System.out.println(“h(head):查看队列头数据”); key=scanner.next().charAt(0);//接收一个字符 switch (key){ case ‘s’: arrayQueue.showQueue(); break; case ‘a’: System.out.println(“输入一个数”); int value=scanner.nextInt(); arrayQueue.addQueue(value); break; case ‘g’: try { int res=arrayQueue.getQueue(); System.out.printf(“取出的数是%d\n”,res); }catch (Exception e){ System.out.println(e.getMessage()); } break; case ‘h’: try { int res=arrayQueue.headQueue(); System.out.printf(“取出的队列头数据是%d\n”,res); }catch (Exception e){ System.out.println(e.getMessage()); } case ‘e’: scanner.close(); loop=false; break; default: break; } } System.out.println(“程序退出”); } } //使用数组模拟队列-编写一个ArrayQueue class ArrayQueue{ private int maxSize;//表示数组最大容量 private int front;//队列头 private int rear;//队列尾 private int[] arr;//该数组用于存放数据，模拟队列

  1. //创建队列的构造器
  2. public ArrayQueue(int arrmaxSize) {
  3.     this.maxSize = arrmaxSize;
  4.     arr=new int[maxSize];
  5.     front=-1;//指向队列头部，分析出front是指向队列头的前一个位置
  6.     rear=-1;//指向队列尾，指向队列尾的数据（即就是队列最后一个数据）
  7. }
  9. //判断队列是否满
  10. public boolean isFull(){
  11.     return rear == maxSize - 1;
  12. }
  14. //判断队列是否为空
  15. public boolean isEmpty(){
  16.     return rear == front;
  17. }
  19. //添加数据到队列
  20. public void addQueue(int n){
  21.     //判断队列是否满
  22.     if (isFull()){
  23.         System.out.println("队列满，不能加入数据");
  24.         return;
  25.     }
  26.     rear++;
  27.     arr[rear] = n;
  28. }
  30. //获取队列的数据，出队列
  31. public int getQueue(){
  32.     //判断队列是否为空
  33.     if (isEmpty()){
  34.         //通过抛出异常处理
  35.         throw new RuntimeException("队列空，无法取数据");
  36.     }
  37.     front++;
  38.     return arr[front];
  39. }
  41. //显示队列的所有数据
  42. public void showQueue(){
  43.     //遍历
  44.     if (isEmpty()){
  45.         System.out.println("队列空");
  46.         return;
  47.     }
  48.     for (int i = 0; i < arr.length; i++) {
  49.         System.out.printf("arr[%d]=%d\n",i,arr[i]);
  50.     }
  51. }
  53. //显示队列的头数据
  54. public int headQueue(){
  55.     if (isEmpty()){
  56.         throw new RuntimeException("队列空，无数据");
  57.     }
  58.     return arr[front+1];
  59. }

}

  2.    - **问题分析**并优化
  3.       - 对前面的数组模拟队列的优化，充分利用数组. 因此将数组看做是一个环形的。(通过取模的方式来实现即可)
  4.       - 分析说明：
  5.          - 1)尾索引的下一个为头索引时表示队列满，即将**队列容量空出一个作为约定**,这个在做判断队列满的时候需要注意 (rear + 1) % maxSize == front 满] 
  6.          - 2)rear == front [空]
  7.       - ![image.png](https://cdn.nlark.com/yuque/0/2022/png/22782459/1645576267847-e164ffd5-86ef-478e-87da-bb4a24dd6aee.png#averageHue=%23c0aeae&clientId=ue12d2605-52aa-4&from=paste&height=181&id=MVne1&originHeight=181&originWidth=476&originalType=binary&ratio=1&rotation=0&showTitle=false&size=24180&status=done&style=none&taskId=uda40b5f1-5d15-4e3a-914c-fb0c32e6f4b&title=&width=476)
  8.       - ![image.png](https://cdn.nlark.com/yuque/0/2022/png/22782459/1645577910049-e9ded9a6-58cd-42ab-abab-edd81f32d227.png#averageHue=%23ebebeb&clientId=ue12d2605-52aa-4&from=paste&height=287&id=u69fb6db0&originHeight=287&originWidth=1128&originalType=binary&ratio=1&rotation=0&showTitle=false&size=282019&status=done&style=none&taskId=ude846bab-af19-4c11-bb1d-4f515c717a0&title=&width=1128)
  9. >       - 思路如下:
  10. >          - 1.  front变量的含义做一个调整： front 就指向队列的第一个元素, 也就是说 arr[front] 就是队列的第一个元素 
  11. >          - front 的初始值 = 0
  12. >          - 2.  rear 变量的含义做一个调整：rear 指向队列的最后一个元素的后一个位置. 因为希望空出一个空间做为约定.
  13. >          - rear 的初始值 = 0
  14. >          - 3. 当队列满时，条件是  (rear  + 1) % maxSize == front 【满】
  15. >          - 4. 对队列为空的条件， rear == front 空
  16. >          - 5. 当我们这样分析， 队列中有效的数据的个数   (rear + maxSize - front) % maxSize   // rear = 1 front = 0 
  17. >          - 6. 我们就可以在原来的队列上修改得到，一个环形队列
  19.       - **环形队列代码实现**
  20. ```java
  21. package queue;
  22. /*
  23. 环形队列
  24.  */
  26. import java.util.Scanner;
  28. public class CireleArrayQueue {
  29.     public static void main(String[] args) {
  30.         System.out.println("测试数组环形队列");
  31.         CircleArray arrayQueue = new CircleArray(4);
  32.         char key=' ';//接收用户的输入
  33.         Scanner scanner = new Scanner(System.in);
  34.         boolean loop=true;
  35.         //输出一个菜单
  36.         while (loop){
  37.             System.out.println("s(show):显示队列");
  38.             System.out.println("e(exit):退出程序");
  39.             System.out.println("a(add):添加数据到队列");
  40.             System.out.println("g(get):从队列取出数据");
  41.             System.out.println("h(head):查看队列头数据");
  42.             key=scanner.next().charAt(0);//接收一个字符
  43.             switch (key){
  44.                 case 's':
  45.                     arrayQueue.showQueue();
  46.                     break;
  47.                 case 'a':
  48.                     System.out.println("输入一个数");
  49.                     int value=scanner.nextInt();
  50.                     arrayQueue.addQueue(value);
  51.                     break;
  52.                 case 'g':
  53.                     try {
  54.                         int res=arrayQueue.getQueue();
  55.                         System.out.printf("取出的数是%d\n",res);
  56.                     }catch (Exception e){
  57.                         System.out.println(e.getMessage());
  58.                     }
  59.                     break;
  60.                 case 'h':
  61.                     try {
  62.                         int res=arrayQueue.headQueue();
  63.                         System.out.printf("取出的队列头数据是%d\n",res);
  64.                     }catch (Exception e){
  65.                         System.out.println(e.getMessage());
  66.                     }
  67.                 case 'e':
  68.                     scanner.close();
  69.                     loop=false;
  70.                     break;
  71.                 default:
  72.                     break;
  73.             }
  74.         }
  75.         System.out.println("程序退出");
  76.     }
  77. }
  79. class CircleArray{
  80.     private int maxSize;//表示数组最大容量
  81.     //front变量的含义做一个调整：front就指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素，front的初始值为0
  82.     private int front;//队列头
  83.     //rear变量的含义做一个调整：rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定，rear的初始值为0
  84.     private int rear;//队列尾
  85.     private int[] arr;//该数组用于存放数据，模拟队列
  87.     public CircleArray(int arrMaxSize){
  88.         this.maxSize = arrMaxSize;
  89.         arr=new int[maxSize];
  90.     }
  92.     //判断队列是否满
  93.     public boolean isFull(){
  94.         return (rear+1)%maxSize==front;
  95.     }
  97.     //判断队列是否为空
  98.     public boolean isEmpty(){
  99.         return rear == front;
  100.     }
  102.     //添加数据到队列
  103.     public void addQueue(int n){
  104.         //判断队列是否满
  105.         if (isFull()){
  106.             System.out.println("队列满，不能加入数据");
  107.             return;
  108.         }
  109.         //直接添加数据
  110.         arr[rear]=n;
  111.         //添加后将指向后移
  112.         rear = (rear+1)%maxSize;
  113.     }
  115.     //获取队列的数据，出队列
  116.     public int getQueue(){
  117.         //判断队列是否为空
  118.         if (isEmpty()){
  119.             //通过抛出异常处理
  120.             throw new RuntimeException("队列空，无法取数据");
  121.         }
  122.         //这里需要分析出front就指向队列的第一个元素
  123.         //1.先把front的值保存到一个临时变量
  124.         //2.再将front后移
  125.         //3.将临时保存的值返回
  126.         int value=arr[front];
  127.         front=(front+1)%maxSize;
  128.         return value;
  129.     }
  131.     //显示队列的所有数据
  132.     public void showQueue(){
  133.         //遍历
  134.         if (isEmpty()){
  135.             System.out.println("队列空");
  136.             return;
  137.         }
  138.         //从front开始遍历
  139.         for (int i = front; i < front+size(); i++) {
  140.             System.out.printf("arr[%d]=%d\n",i%maxSize,arr[i%maxSize]);
  141.         }
  142.     }
  144.     //求出当前队列的有效数据个数
  145.     public int size(){
  146.         return (rear+maxSize-front)%maxSize;
  147.     }
  149.     //显示队列的头数据
  150.     public int headQueue(){
  151.         if (isEmpty()){
  152.             throw new RuntimeException("队列空，无数据");
  153.         }
  154.         return arr[front];
  155.     }
  156. }

第 4 章 链表

链表(Linked List)介绍

  • 链表是有序的列表，但是它在内存中是存储如下
  • image.png
  • 小结:
    • 1)链表是以节点的方式来存储,是链式存储
    • 2)每个节点包含 data 域， next 域：指向下一个节点.
    • 3)如图：发现链表的各个节点不一定是连续存储.
    • 4)链表分带头节点的链表和没有头节点的链表，根据实际的需求来确定
  • 单链表(带头结点) 逻辑结构示意图如下

  • image.png

    单链表的应用实例

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

    • 1)完成对英雄人物的增删改查操作， 注: 删除和修改,查找可以考虑学员独立完成，也可带学员完成
    • 2)第一种方法在添加英雄时，直接添加到链表的尾部
    • 3)第二种方式在添加英雄时，根据排名将英雄插入到指定位置(如果有这个排名，则添加失败，并给出提示)

  • 代码如下 ```java package linkedlist; / 链表最后添加数据和遍历 / public class SingleLinkedListDemo { public static void main(String[] args) {

    1.   //测试
    2.   HeroNode heroNode1 = new HeroNode(1,"宋江","及时雨");
    3.   HeroNode heroNode2 = new HeroNode(2,"卢俊义","玉麒麟");
    4.   HeroNode heroNode3 = new HeroNode(3,"吴用","智多星");
    5.   HeroNode heroNode4 = new HeroNode(4,"林冲","豹子头");
    7.   SingleLinkedList singleLinkedList = new SingleLinkedList();

/ singleLinkedList.add(heroNode1); singleLinkedList.add(heroNode2); singleLinkedList.add(heroNode3); singleLinkedList.add(heroNode4);/

  1.     singleLinkedList.addByOther(heroNode1);
  2.     singleLinkedList.addByOther(heroNode4);
  3.     singleLinkedList.addByOther(heroNode3);
  4.     singleLinkedList.addByOther(heroNode2);
  5.     singleLinkedList.addByOther(heroNode3);
  8.     singleLinkedList.list();
  9. }

} //定义SingleLinkedList管理英雄 class SingleLinkedList{ //先初始化一个头节点，头节点不要动 private HeroNode haed=new HeroNode(0,””,””); //第一种：添加节点到单项链表的方式 / 思路：当不考虑编号顺序时 1.找到当前链表的最后节点 2.将这个节点的next指向新的节点 / public void add(HeroNode heroNode){ //因为head节点不能动，因此我们需要一个辅助节点temp HeroNode temp=haed; //遍历链表，找到最后 while (true){ //找到链表最后 if (temp.next==null){ break; } //如果没有找到最后，就temp后移 temp=temp.next; } / 当推出while循环时，temp就指向了链表的最后 将最后这个节点的next指向新的节点 / temp.next=heroNode; } //第二种:根据排名添加到指定位置 public void addByOther(HeroNode heroNode){ //因为头节点不能动，需要辅助节点，因此我们找到temp应是位于添加位置的前一个节点，否则插入不了 HeroNode temp=haed; boolean flag=false;//标志添加的编号是否存在 while (true){ if (temp.next==null){ 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 { //可以插入 heroNode.next=temp.next; temp.next=heroNode; } }

  1. //显示链表
  2. public void list(){
  3.     //判断链表是否为空
  4.     if (haed.next==null){
  5.         System.out.println("链表为空！！！");
  6.         return;
  7.     }
  8.     //因为头节点不能动，需要辅助变量
  9.     HeroNode temp=haed.next;
  10.     while (true){
  11.         //判断链表是否到最后
  12.         if (temp==null){
  13.             break;
  14.         }
  15.         System.out.println(temp);
  16.         //将next后移
  17.         temp=temp.next;
  18.     }
  19. }

} //定义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 + ‘\’’ + ‘}’; } } ```