Java数据结构

最新推荐文章于 2024-05-12 18:24:10 发布

Three_tree.

最新推荐文章于 2024-05-12 18:24:10 发布

阅读量350

点赞数

文章标签： java 数据结构 ide

本文链接：https://blog.csdn.net/three_tree226/article/details/127094056

版权

数据结构

数据结构包括：线性结构和非线性结构

线性结构

线性结构作为最常用的数据结构，其特点是数据元素之间存在一对一的线性关系
线性结构有两种不同的存储结构，即顺序存储结构（数组）和链式存储结构（链表）。顺序存储的线性表称为顺序表，顺序表中的存储元素是连续的
链式存储的线性表称为链表，链表中的存储元素不一定是连续的，元素节点中存放数据元素以及相邻元素的地址信息
线性结构常见的有:数组、队列、链表和栈

非线性结构

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

稀疏数组

基本介绍

当一个数组中大部分元素为0，或者为同一个值的数组时，可以使用稀疏数组来保存该数组

稀疏数组的处理方法是:

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

package com.yhs.sparsearray;

import java.io.*;

public class SparseArray {
   
    public static void main(String[] args) throws IOException {
   
        //创建一个二维数组 11 * 11
        int[][] chessArr1 = new int[11][11];
        chessArr1[1][2] = 1;
        chessArr1[2][3] = 2;
        chessArr1[4][5] = 2;
        //输出原始的二维数组
        System.out.println("原始的二维数组");
        for (int[] row : chessArr1) {
   
            for (int data : row) {
   
                System.out.print(data + "\t");
            }
            System.out.println();
        }

        //将原始数组转稀疏数组
        //1. 先遍历二维数组 得到非0数据的个数
        int sum = 0;
        for (int i = 0; i < chessArr1.length; i++) {
   
            for (int j = 0; j < chessArr1.length; j++) {
   
                if (chessArr1[i][j] != 0) {
   
                    sum++;
                }
            }
        }

        //2. 创建对应的稀疏数组
        int sparseArr[][] = new int[sum + 1][3];
        // 给稀疏数组赋值
        sparseArr[0][0] = 11;
        sparseArr[0][1] = 11;
        sparseArr[0][2] = sum;

        // 遍历二维数组，将非零的值存放到稀疏数组
        int count = 0; //用来记录是第几个非零数据
        for (int i = 0; i < chessArr1.length; i++) {
   
            for (int j = 0; j < chessArr1.length; j++) {
   
                if (chessArr1[i][j] != 0) {
   
                    count++;
                    sparseArr[count][0] = i;
                    sparseArr[count][1] = j;
                    sparseArr[count][2] = chessArr1[i][j];
                }
            }
        }

        //输出稀疏数组的形式
        System.out.println();
        System.out.println("得到的稀疏数组为");
        for (int i = 0; i < sparseArr.length; i++) {
   
            System.out.printf("%d\t%d\t%d\t\n", sparseArr[i][0], sparseArr[i][1], sparseArr[i][2]);
        }
        System.out.println();

        //将稀疏数组 --> 恢复成原始的二维数组
        //读取稀疏数组后几行数据，并赋值给原始数组
        //1. 先读取稀疏数组第一行，得到原始数组的大小
        int[][] chessArr2 = new int[sparseArr[0][0]][sparseArr[0][1]];
        for (int i = 1; i < sparseArr.length; i++) {
   
            chessArr2[sparseArr[i][0]][sparseArr[i][1]] = sparseArr[i][2];
        }
        //输出恢复后的二维数组
        System.out.println();
        System.out.println("恢复后的二维数组");
        for (int[] row : chessArr2) {
   
            for (int data : row) {
   
                System.out.print(data + "\t");
            }
            System.out.println();
        }

        //将稀疏数组写入文件
        System.out.println("稀疏数组写入map.data文件");
        String filePath = "d:\\map.data";
        File file = new File(filePath);
        OutputStreamWriter writer = null;
        try {
   
            System.out.println("文件创建成功");
            writer = new OutputStreamWriter(new FileOutputStream(file), "GB2312");
        } catch (IOException e) {
   
            throw new RuntimeException(e);
        }
        for (int i = 0; i < sparseArr.length; i++) {
   
            if (i == sparseArr.length - 1) {
   
                writer.write(sparseArr[i][0] + "," + sparseArr[i][1] + "," + sparseArr[i][2]);
            } else {
   
                writer.write(sparseArr[i][0] + "," + sparseArr[i][1] + "," + sparseArr[i][2] + ",");
            }
        }
        writer.close();
        System.out.println("写入成功");


        //稀疏数组转二维数组首先读取文件
        InputStreamReader inputStreamReader = new InputStreamReader(new FileInputStream(file));
        StringBuffer sbf = new StringBuffer();
        while (inputStreamReader.ready()) {
   
            sbf.append((char) inputStreamReader.read());
        }
        System.out.println("读出文件" + sbf.toString());
        inputStreamReader.close();

        //把读出的文件，赋值给稀疏数组
        String[] data = sbf.toString().split(",");
        System.out.println(data.length / 3);
        int[][] sparseArray2 = new int[data.length / 3][3];
        int i = 0;
        for (String s : data) {
   
            System.out.println(i % 3);
            sparseArray2[i / 3][i % 3] = Integer.parseInt(s);
            i++;
        }

        //输出读取到的稀疏数组
        System.out.println("读取到的稀疏数组如下++++++++++++");
        for (int j = 0; j < sparseArray2.length; j++) {
   
            System.out.print(sparseArray2[j][0] + "\t" + sparseArray2[j][1] + "\t" + sparseArray2[j][2]);
            System.out.println();
        }

        //1. 先读取稀疏数组的第一行，找出二维数组的大小
        int[][] charArray2 = new int[sparseArray2[0][0]][sparseArray2[0][1]];
        //2. 读取稀疏数组的值，给到二维数组
        for (int k = 1; k < sparseArray2.length; k++) {
   
            charArray2[sparseArray2[k][0]][sparseArray2[k][1]] = sparseArray2[k][2];
        }
        System.out.println("恢复后的二维数组");
        for (int[] row : charArray2) {
   
            for (int ds : row) {
   
                System.out.print(ds + "\t");
            }
            System.out.println();
        }
    }
}

队列

基本介绍

对列是一个有序列表，可以用数组或链表来实现

遵循先入先出的原则，即：先存入队列的数据，要先取出，后存入队列的数据，要后退出

数组模拟队列

当我们将数据存入队列时称为“addQueue", “addQueue” 的处理需要有两个步骤；

将尾指针往后移：rear+1，当front == rear【空】
若尾指针 rear 小于队列的最大下标 maxSize -1 ，则将数据存入 rear所指的数组元素中，否则无法存入数组。rear == maxSize -1【队列满】

代码实现

package com.yhs.queue;

import java.util.Scanner;

public class Queue {
   
    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): 查看队列头的数据");
            System.out.print("请输入你的选择： ");
            key = scanner.next().charAt(0);
            switch (key) {
   
                case 's':
                  arrayQueue.showQueue();
                  break;
                case 'a':
                    System.out.print("请输入添加的数据： ");
                    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());
                    }
                    break;
                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; //该数组用于存放数据，模拟队列

    //添加构造器
    public ArrayQueue(int arrMaxsize) {
   
        maxSize = arrMaxsize;
        arr = new int[maxSize];
        front = -1; //指向队列头部，front指向队列头的前一个位置
        rear = -1; //指向队列尾部，指向队列尾的数据
    }

    //判断数组是否为空
    public boolean isEmpty() {
   
        return front == rear;
    }

    //判断数组是否已满
    public boolean isFull() {
   
        return rear == maxSize - 1;
    }

    //添加数据
    public void addQueue(int n) {
   
        if (! isFull()) {
   
            rear++;
            arr[rear] = n;
        } else {
   
            System.out.println("队列已满不能添加数据");
        }
    }

    //获取队列数据
    public int getQueue() {
   
        if (! isEmpty()) {
   
            front++; //因为front代表队列头的前一个数据,所以需要++
            return arr[front];
        } else {
   
            throw new RuntimeException("队列为空 不能取出数据");
        }
    }

    //显示队列的所有数据
    public void showQueue() {
   
        if (! isEmpty()) {
   
            for (int i = 0; i < arr.length; i++) {
   
                System.out.printf("arr[%d]=%d\n", i, arr[i]);
            }
        } else {
   
            System.out.println("队列为空，无法遍历数据");
        }
    }

    //显示队列的头数据
    public int headQueue() {
   
        if (! isEmpty()) {
   
            return arr[front+1];
        } else {
   
            throw new RuntimeException("队列为空，无法取出");
        }
    }
}

数组模拟环形队列

在上一个ArrayQueueDemo的基础上优化程序，达到复用的效果

思路如下：

front变量的含义做一个调整：front就指向队列的第一个元素，也就是说arr[front]就是队列的第一个元素
front的初始值为0
rear变量的含义做一个调整：rear指向队列的最后一个元素的后一个位置，因为希望空出一个空间作为约定
rear的初始值为0
当队列满时，条件是：(rear+1)%maxSize = front
当队列为空的条件，rear==front
当我们这样分析，队列中有效的数据个数(rear+maxSize-front)%maxSize
在上一个demo中修改得到一个环形队列

代码实现

package com.yhs.queue;

import java.util.Scanner;

@SuppressWarnings("all")
public class CircleArrayQueue {
   
    public static void main(String[] args) {
   
        //测试
        //这里设置为4，其队列有效数据最大为3
        //约定的位置是动态变化的
        CircleArray circleArray = new CircleArray(4);
        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): 查看队列头的数据");
            System.out.print("请输入你的选择： ");
            key = scanner.next().charAt(0);
            switch (key) {
   
                case 's':
                    circleArray.showQueue();
                    break;
                case 'a':
                    System.out.print("请输入添加的数据： ");
                    int value = scanner.nextInt();
                    circleArray.addQueue(value);
                    break;
                case 'g':
                    try {
   
                        int res = circleArray.getQueue();
                        System.out.printf("取出的数据是%d\n", res);
                    } catch (Exception e) {
   
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'h':
                    try {
   
                        int res = circleArray.headQueue();
                        System.out.printf("取出的头数据=%d\n", res);
                    } catch (Exception e) {
   
                        System.out.println(e.getMessage());
                    }
                    break;
                case 'e':
                    scanner.close();
                    loop = false;
                    break;
                default:
                    break;
            }
        }
        System.out.println("程序退出");
    }
}

class CircleArray {
   
    private int maxSize; //数组最大容量
    //front 变量的含义作调整：指向队列的第一个元素，也就是arr[front] = arr[0];
    //front 的初始值 = 0
    private int front;
    //rear 变量的含义作调整: 指向队列的最后一个元素的后一个位置
    //rear 的初始值 = = 0
    private int rear; //队列尾
    private int[] arr;

    //构造器
    public CircleArray(int arrMaxSize) {
   
        maxSize = arrMaxSize;
        arr = new int[maxSize];
    }

    //判断是否为空
    public boolean isEmpty() {
   
        return front == rear;
    }

    //判断是否已满
    public boolean isFull() {
   
        return (rear + 1) % maxSize == front;
    }

    //添加数据到队列
    public void addQueue(int n) {
   
        // 判断队列是否满
        if (!isFull()) {
   
            arr[rear] = n;
            rear = (rear + 1) % maxSize;
        } else {
   
            System.out.println("队列已满，不能加入...");
        }
    }

    //获取队列中的数据
    public int getQueue() {
   
        if (!isEmpty()) {
   
            //front指向队列中的第一个元素
            //1. 先将front存入一个零时变量
            //2. 将front 后移动,考虑取模
            //3. 将临时保存的变量返回
            int value = arr[front];
            front = (front + 1) % maxSize;
            return value;
        } else {
   
            throw new RuntimeException("队列为空，无法取出");
        }
    }

    //显示队列中的数据
    public void showQueue() {
   
        if (!isEmpty()) {
   
            for (int i = front; i <  front + dataNum(); i++) {
   
                System.out.printf("arr[%d]=%d\n", i % maxSize, arr[i % maxSize]);
            }
        } else {
   
            System.out.println("队列为空，无法显示...");
        }
    }

    //求出当前队列有效数据的数量
    public int dataNum() {
   
        return (rear + maxSize - front) % maxSize;
    }

    public int headQueue() {
   
        //判断
        if (!isEmpty()) {
   
            return arr[front];
        } else {
   
            throw new RuntimeException("队列为空,没有数据...");
        }
    }
}

单链表

链表（Linked List)链表是有序的列表，是链式存储结构

链表增查实现思路

【添加方式一】

按照编号顺序添加

【添加方式二】

单链表节点删除

package com.yhs.linkedlist;

public class SingleLinkedListDemo {
   
    public static void main(String[] args) {
   
        //测试
        //创建节点
        HeroNode h1 = new HeroNode(1, "詹姆斯", "小皇帝");
        HeroNode h2 = new HeroNode(2, "奥尼尔", "大鲨鱼");
        HeroNode h3 = new HeroNode(3, "邓肯", "石佛");
        HeroNode h4 = new HeroNode(4, "库里", "小学生");

        //创建一个链表
        SingleLinkedList singleLinkedList = new SingleLinkedList();
        //方式一：加入
//        singleLinkedList.addHeroNode(h1);
//        singleLinkedList.addHeroNode(h4);
//        singleLinkedList.addHeroNode(h2);
//        singleLinkedList.addHeroNode(h3);

        //方式二：加入按照编号的顺序
        singleLinkedList.addByOrder(h1);
        singleLinkedList.addByOrder(h4);
        singleLinkedList.addByOrder(h2);
        singleLinkedList.addByOrder(h3);

        //显示
        singleLinkedList.list();

        //测试修改节点的代码
        HeroNode newHeroNode = new HeroNode(2, "科比", "小飞侠");
        singleLinkedList.update(newHeroNode);
        System.out.println("=========修改后=========");
        singleLinkedList.list();

        //测试删除节点
        singleLinkedList.delete(1);
        singleLinkedList.delete(2);
        singleLinkedList.delete(3);
        singleLinkedList.delete(4);
        System.out.println("=============删除后===========");
        singleLinkedList.list();

    }
}

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

    //【方式一】添加节点到单项链表，不考虑编号顺序时
    //1. 找到当前链表的最后的节点
    //2. 将最后的节点的next 指向新的节点
    public void addHeroNode(HeroNode heroNode) {
   
        //因为head节点不能动，因此我们需要一个辅助的变量 temp
        HeroNode temp = headN;
        //遍历链表，找到最后
        while (true) {
   
            if (temp.next == null) {
   
                break;
            }
            //如果没有找到最后，就将temp后移
            temp = temp.next;
        }
        //当退出while循环时，temp就指向新的节点
        temp.next = heroNode;
    }

    //【方式二】添加节点时，根据排名将英雄插入到指定位置
    //(如果有这个排名，则添加失败，并给出提示)
    public void addByOrder(HeroNode heroNode) {
   
        //因为头节点不能动，因此我们仍然通过一个辅助指针（变量）来帮助找到添加的位置
        HeroNode temp = headN;
        boolean flag = false; //标志添加的编号是否存在，默认为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 (headN.next == null) {
   
            System.out.println("链表为空...");
            return;
        }
        //找到需要修改的节点
        //定义一个辅助指针
        HeroNode temp = headN.next;
        boolean loop = false; //表示是否找到该节点
        while (true) {
   
            if (temp.no == newHeroNode.no) {
   
                loop = true;
                break;
            }
            temp = temp.next;
            if (temp == null) {
   
                return;
            }
        }
        if (loop) {
   
            temp.name = newHeroNode.name;
            temp.nickName = newHeroNode.nickName;
        } else {
   
            System.out.printf("没有找到编号= %d 的节点，不能修改", newHeroNode.no);
        }
    }

    //删除节点
    //1. head 不能动，因此我们需要一个辅助指针找到删除节点的前一个节点
    //2. 说明我们比较时，时temp.next.no 和 需要删除的节点no比较
    public void delete(int no) {
   
        HeroNode temp = headN;
        boolean loop = false; //标志是否找到待删除的节点
        while (true) {
   
            if (temp.next == null) {
   
                break;
            }
            if (temp.next.no == no) {
   
                loop = true;
                break;
            }
            temp = temp.next;
        }
        //判断是否找到该节点
        if (loop) {
    //找到
            //删除该节点
            temp.next = temp.next.next;
        } else {
   
            System.out.printf("删除失败...该节点 %d不存在", no);
        }
    }


    //显示链表
    public void list() {
   
        //先判断链表是否为空
        if (headN.next == null) {
   
            System.out.println("链表为空");
            return;
        }
        //因为头节点不能动，因此我们需要定义一个辅助变量来遍历
        HeroNode temp = headN.next;
        while (true) {
   
            //判断是否到链表最后
            if (temp == null) {
   
                break;
            }
            //输出节点信息
            System.out.println(temp);
            //将temp后移
            temp = temp.next;

//            第二种写法
//        while (true) {
   
//            System.out.println(temp);
//            temp = temp.next;
//            if (temp == null) {
   
//                break;
//            }
//        }
        }
    }

}


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

单链表面试题

获取单链表有效节点个数

public static int getLength(HeroNode headN) {
   
    if (headN.next == null) {
   
        return 0;
    }
    int length = 0;
    HeroNode temp = headN.next;
    while (temp != null) {
   
        length++;
        temp = temp.next;
    }
    return length;
}

查找单链表倒数第k个节点

//1. 编写一个方法，接收head节点，同时接收一个index
//2. index 表示倒数第index个节点
//3. 先把链表从头到尾遍历，得到链表的总长度
//4. 得到size后，我们从链表的第一个开始遍历（size - index)个，就可以得到
//5. 如果找到了，则返回该节点，否则返回null
public HeroNode getKNode(HeroNode headN, int index) {
   
    if (headN.next == null) {
   
        return null;
    }
    int size = 0;
    HeroNode temp = headN.next;
    while (temp != null) {
   
        size++;
        temp = temp.next;
    }
    //第二次遍历 size-index 位置，就是倒数的第k个节点
    //先做一个index的校验
    if (index <= 0 || index > size) {
   
        return null;
    }
    temp = headN.next;
    //for循环 定位到倒数的index
    for (int i = 0; i < size - index; i++) {
   
        temp = temp.next;
    }
    return temp;
}

单链表反转

方式一

//将单链表反转
public static void reverseList(HeroNode headN) {
   
    //如果当前链表为空，或者只有一个节点，无序反转，直接返回
    if (headN.next == null || headN.next.next == null) {
   
        return;
    }
    //定义一个辅助的指针，帮助我们遍历原来的链表
    HeroNode cur = headN.next;
    HeroNode next = null; //指向当前节点[cur]的下一个节点
    HeroNode reverseHead = new HeroNode(0,"", "");
    //并从头到尾遍历原来的链表，每遍历一个节点，就将其取出,并放在新的链表reverseHead 的最前端
    while (cur != null) {
   
        next = cur.next; //先暂时保存当前节点的下一个节点，因为后面需要使用
        cur.next = reverseHead.next;
        reverseHead.next = cur; //将cur连接到新的链表上
        cur = next; //让temp后移
    }
    //将head.next 指向 reverseHead.next 实现链表反转
    headN.next = reverseHead.next;
}

方式二

//将单链表反转 -- 双指针解法
    public void reverseList(HeroNode headN) {
   
        //如果当前链表为空，或者只有一个节点，无序反转，直接返回
        if (headN.next == null || headN.next.next == null) {
   
            return;
        }
        //定义一个辅助的指针，帮助我们遍历原来的链表
        HeroNode cur = headN.next;
        HeroNode pre = null;
        HeroNode temp = null; //辅助指针
        while (cur != null) {
   
            temp = cur.next;
            cur.next = pre;
            pre = cur;
            cur = temp;
        }
        headN.next = pre;
    }

从尾到头打印单链表

测试Stack（栈）的使用

public class TestStock {
   
    public static void main(String[] args) {
   
        Stack<String> stack = new Stack<>();
        //入栈
        stack.add("jack");
        stack.add("tom");
        stack.add("smith");
        //出栈
        while (stack.size() > 0) {
   
            System.out.println(stack.pop());
        }
    }
}

//倒序打印链表
//可以利用栈这个数据结构，将各个节点压入到栈中，然后利用栈的先进后出的特点，实现逆序打印效果
public void reversePrint(HeroNode headN) {
   
    if (headN.next == null) {
   
        return;
    }
    //创建一个栈，将各个节点压入栈中
    Stack<HeroNode> stack = new Stack<>();
    HeroNode cur = headN.next;
    //将链表的所有节点压入栈
    while (cur != null) {
   
        stack.push(cur);
        cur = cur.next;
    }
    //将栈中的节点进行打印 pop出栈
    while (stack.size() > 0) {
   
        System.out.println(stack.pop()); //stack的特点：先进后出
    }
}

双向链表

使用单项链表的缺点分析

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

双向链表CRUD分析图解

代码实现

package com.yhs.linkedlist;

public class DoubleLinkedListDemo {
   
    public static void main(String[] args) {
   
        //测试
        //创建节点
        System.out.println("~~~~~~~~双向链表测试~~~~~");
        HeroNode2 h1 = new HeroNode2(1, "詹姆斯", "小皇帝");
        HeroNode2 h2 = new HeroNode2(2, "奥尼尔", "大鲨鱼");
        HeroNode2 h3 = new HeroNode2(3, "邓肯"