DSA_树结构的基础部分（java数据结构与算法）

最新推荐文章于 2022-10-27 17:34:55 发布
最新推荐文章于 2022-10-27 17:34:55 发布
阅读量198 收藏
点赞数 1
分类专栏： java数据结构与算法（韩顺平老师随堂笔记） 文章标签： 数据结构 链表 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Fine____/article/details/120602487
版权

树结构的基础部分

二叉树

为什么需要树这种数据结构

数组存储方式的分析

优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。

缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低 [示意图]

画出操作示意图：

image-20210702205247693

链式存储方式的分析

优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可，删除效率也很好)。

缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历) 【示意图】

操作示意图：

image-20210702205305605

树存储方式的分析

能提高数据存储，读取的效率, 比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。【示意图,后面详讲】

案例**😗* [7, 3, 10, 1, 5, 9, 12]

image-20210702205351659

树示意图

image-20210702205409247

树的常用术语(结合示意图理解):

  1. 节点
  2. 根节点
  3. 父节点
  4. 子节点
  5. 叶子节点 (没有子节点的节点)
  6. 节点的权(节点值)
  7. 路径(从 root 节点找到该节点的路线)
  8. 层
  9. 子树
  10. 树的高度(最大层数)
  11. 森林 :多颗子树构成森林

二叉树的概念

  1. 树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
  2. 二叉树的子节点分为左节点和右节点
  3. 示意图

  1. 如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。

    image-20210702205815141

  2. 如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树

    image-20210702205827818

二叉树遍历的说明

使用前序，中序和后序对下面的二叉树进行遍历.

  1. 前序遍历: 先输出父节点，再遍历左子树和右子树
  2. 中序遍历: 先遍历左子树，再输出父节点，再遍历右子树
  3. 后序遍历: 先遍历左子树，再遍历右子树，最后输出父节点
  4. 小结: 看输出父节点的顺序，就确定是前序，中序还是后序

二叉树遍历应用实例(前序,中序,后序)

应用实例的说明和思路

image-20210702205940388

代码实现

package cn.chasing.DataStructure.tree;

import org.junit.Test;

/**
 * @author 柴柴快乐每一天
 * @create 2021-07-02  7:59 下午
 * <p>
 * 『Stay hungry, stay foolish. 』
 */
public class BinaryTreeDemo {

    @Test
    public void test1() {
        BinaryTree binaryTree = new BinaryTree();

        HeroNode root = new HeroNode(1, "宋江");
        HeroNode node2 = new HeroNode(2, "吴用");
        HeroNode node3 = new HeroNode(3, "卢俊义");
        HeroNode node4 = new HeroNode(4, "林冲");
        HeroNode node5 = new HeroNode(5, "关胜");

        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);

        binaryTree.setRoot(root);

        System.out.println("前序遍历");
        binaryTree.preOrder();

        System.out.println("中序遍历");
        binaryTree.infixOrder();

        System.out.println("后续遍历");
        binaryTree.postOrder();
    }
}

/**
 * BinaryTree 二叉树
 */
class BinaryTree {
    private HeroNode root;

    public BinaryTree() {
    }

    public BinaryTree(HeroNode root) {
        this.root = root;
    }

    public HeroNode getRoot() {
        return root;
    }

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    /**
     * 前序遍历
     */
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    /**
     * 中序遍历
     */
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    /**
     * 后序遍历
     */
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }
}



/**
 * HeroNode结点
 */
class HeroNode{
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;



    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    public int getNo() {
        return no;
    }

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

    public String getName() {
        return name;
    }

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

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    /**
     * 前序遍历
     */
    public void preOrder() {
        System.out.println(this); //先输出父节点
        // 递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        // 递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    /**
     * 中序遍历
     */
    public void infixOrder() {
        // 递归向左子树中序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        // 输出父节点
        System.out.println(this);
        // 递归右子树中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    /**
     * 后续遍历
     */
    public void postOrder() {
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }

}

二叉树-查找指定节点

要求

  1. 请编写前序查找，中序查找和后序查找的方法。

  2. 并分别使用三种查找方式，查找 heroNO = 5 的节点

  3. 并分析各种查找方式，分别比较了多少次

  4. 思路分析图解

image-20210711172648112

  1. 代码实现
package cn.chasing.DataStructure.tree;

import org.junit.Before;
import org.junit.Test;

/**
 * @author 柴柴快乐每一天
 * @create 2021-07-02  7:59 下午
 * <p>
 * 『Stay hungry, stay foolish. 』
 */
public class BinaryTreeDemo {

    BinaryTree binaryTree = new BinaryTree();

    HeroNode root = new HeroNode(1, "宋江");
    HeroNode node2 = new HeroNode(2, "吴用");
    HeroNode node3 = new HeroNode(3, "卢俊义");
    HeroNode node4 = new HeroNode(4, "林冲");
    HeroNode node5 = new HeroNode(5, "关胜");


    @Before
    public void before() {
        root.setLeft(node2);
        root.setRight(node3);
        node3.setRight(node4);
        node3.setLeft(node5);

        binaryTree.setRoot(root);
    }

    @Test
    public void test1() {

        System.out.println("前序遍历");
        binaryTree.preOrder();

        System.out.println("中序遍历");
        binaryTree.infixOrder();

        System.out.println("后续遍历");
        binaryTree.postOrder();

    }

    @Test
    public void test3() {
        System.out.println("删除前,前序遍历");
        binaryTree.preOrder(); //  1,2,3,5,4
        binaryTree.deleteNo(5);
        //binaryTree.delNode(3);
        System.out.println("删除后，前序遍历");
        binaryTree.preOrder(); // 1,2,3,4
    }

    @Test
    public void test2() {
        System.out.println("遍历查找");
        HeroNode resNode = binaryTree.postOrderSearch(5);
        if (resNode != null) {
            System.out.printf("找到了，信息为 no=%d name=%s", resNode.getNo(), resNode.getName());
        } else {
         System.out.printf("没有找到 no = %d 的英雄", 5);
      }

    }
}

/**
 * BinaryTree 二叉树
 */
class BinaryTree {
    private HeroNode root;

    public BinaryTree() {
    }

    public BinaryTree(HeroNode root) {
        this.root = root;
    }

    public HeroNode getRoot() {
        return root;
    }

    public void setRoot(HeroNode root) {
        this.root = root;
    }

    /**
     * 前序遍历
     */
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    /**
     * 中序遍历
     */
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    /**
     * 后序遍历
     */
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    /**
     * 前序遍历查找
     * @param no
     * @return
     */
    public HeroNode preOrderSearch(int no) {
        if (this.root != null) {
            return this.root.preOrderSearch(no);
        } else {
            return null;
        }
    }

    /**
     * 中序遍历查找
     * @param no
     * @return
     */
    public HeroNode infixOrderSearch(int no) {
        if (this.root != null) {
            return this.root.infixOrderSearch(no);
        } else {
            return null;
        }
    }

    /**
     * 后序遍历查找
     * @param no
     * @return
     */
    public HeroNode postOrderSearch(int no) {
        if (this.root != null) {
            return this.root.postOrderSearch(no);
        } else {
            return null;
        }
    }

    /**
     * 删除节点
     * @param no
     */
    public void deleteNo(int no){
        if (this.root != null) {
            // 这样才能完成当前节点的比较
            if (this.root.getNo() == no) {
                this.root = null;
                return;
            } else {
                // 递归进去第一步就是比较当前节点
                this.root.delete(no);
            }
        } else {
            System.out.println("this tree is null and cannot delete");
        }
    }
}



/**
 * HeroNode结点
 */
class HeroNode{
    private int no;
    private String name;
    private HeroNode left;
    private HeroNode right;



    public HeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "HeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    public int getNo() {
        return no;
    }

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

    public String getName() {
        return name;
    }

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

    public HeroNode getLeft() {
        return left;
    }

    public void setLeft(HeroNode left) {
        this.left = left;
    }

    public HeroNode getRight() {
        return right;
    }

    public void setRight(HeroNode right) {
        this.right = right;
    }

    /**
     * 前序遍历
     */
    public void preOrder() {
        System.out.println(this); //先输出父节点
        // 递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        // 递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    /**
     * 中序遍历
     */
    public void infixOrder() {
        // 递归向左子树中序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        // 输出父节点
        System.out.println(this);
        // 递归右子树中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    /**
     * 后续遍历
     */
    public void postOrder() {
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }

    /**
     * 前序遍历查找
     * @param no 查找no
     * @return 找到返回该node，没找到返回null
     */
    public HeroNode preOrderSearch(int no) {
        System.out.println("pre");
        if (this.no == no) {
            return this;
        }
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.preOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        if (this.right != null) {
            resNode = this.right.preOrderSearch(no);
        }
        return resNode;
    }

    /**
     * 中序遍历查找
     * @param no
     * @return
     */
    public HeroNode infixOrderSearch(int no) {
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("infix");
        if (this.no == no) {
            return this;
        }
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    /**
     * 后续遍历查找
     * @param no
     * @return
     */
    public HeroNode postOrderSearch(int no) {
        HeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        if (this.right != null) {
            resNode = this.right.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("post");
        if (this.no == no) {
            return this;
        }
        return null;
    }

    //思路
      /*
       *     1. 因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点.
         2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
         3. 如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
         4. 如果第2和第3步没有删除结点，那么我们就需要向左子树进行递归删除
         5.  如果第4步也没有删除结点，则应当向右子树进行递归删除.

       */

    /**
     * 删除节点
     * 1.如果删除的节点是叶子节点，则删除该节点
     * 2.如果删除的节点是非叶子节点，则删除该子树
     * @param no
     */
    public void delete(int no) {
        if (this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        if (this.right != null && this.right.no == no) {
            this.right = null;
            return;
        }
        if (this.left != null) {
            this.left.delete(no);
        }
        if (this.right != null) {
            this.right.delete(no);
        }
    }

}

二叉树-删除节点

要求

  1. 如果删除的节点是叶子节点，则删除该节点

  2. 如果删除的节点是非叶子节点，则删除该子树.尚硅谷 Java 数据结构和算法

  3. 测试，删除掉 5 号叶子节点 和 3 号子树.

  4. 完成删除思路分析

image-20210711172924964

  1. 代码实现

同上

顺序存储二叉树

顺序存储二叉树的概念

基本说明

从数据存储来看，数组存储方式和树的存储方式可以相互转换，即数组可以转换成树，树也可以转换成数组，看右面的示意图。

image-20210711173247008

要求:

  1. 右图的二叉树的结点，要求以数组的方式来存放 arr : [1, 2, 3, 4, 5, 6, 6]

  2. 要求在遍历数组 arr 时，仍然可以以前序遍历，中序遍历和后序遍历的方式完成结点的遍历

顺序存储二叉树的特点:

  1. 顺序二叉树通常只考虑完全二叉树

  2. 第 n 个元素的左子节点为 2 * n + 1

  3. 第 n 个元素的右子节点为 2 * n + 2

  4. 第 n 个元素的父节点为 (n-1) / 2

  5. n : 表示二叉树中的第几个元素(按 0 开始编号如图所示)

顺序存储二叉树遍历

需求: 给你一个数组 {1,2,3,4,5,6,7}，要求以二叉树前序遍历的方式进行遍历。 前序遍历的结果应当为 1,2,4,5,3,6,7

代码实现

package cn.chasing.DataStructure.tree;

import org.junit.Test;

/**
 * @author 柴柴快乐每一天
 * @create 2021-07-06  7:02 下午
 * <p>
 * 『Stay hungry, stay foolish. 』
 */
public class ArrBinaryTreeDemo {

    @Test
    public void test() {
        int[] arr = { 1, 2, 3, 4, 5, 6, 7 };
        //创建一个 ArrBinaryTree
        ArrBinaryTree arrBinaryTree = new ArrBinaryTree(arr);
        arrBinaryTree.preOrder(); // 1,2,4,5,3,6,7
    }
}

class ArrBinaryTree {
    private int[] arr;

    public ArrBinaryTree(int[] arr) {
        this.arr = arr;
    }

    public void preOrder() {
        this.preOrder(0);
    }

    /**
     * 编写一个方法，完成顺序存储二叉树的前序遍历
     * @param index 数组的下标
     */
    public void preOrder(int index) {
        if (arr == null || arr.length == 0) {
            System.out.println("数组为空");
        }
        System.out.println(arr[index]);
        // 向左递归遍历
        if ((index*2+1) < arr.length) {
            preOrder(index*2+1);
        }

        // 向右递归遍历
        if ((index*2+2) < arr.length) {
            preOrder(index*2+2);
        }
    }

}

课后练习

完成对数组以二叉树中序，后序遍历方式的代码.

线索化二叉树

先看一个问题

将数列 {1, 3, 6, 8, 10, 14 } 构建成一颗二叉树. n+1=7

image-20210711173621140

问题分析:

  1. 当我们对上面的二叉树进行中序遍历时，数列为 {8, 3, 10, 1, 6, 14 }

  2. 但是 6, 8, 10, 14 这几个节点的 左右指针，并没有完全的利用上.

  3. 如果我们希望充分的利用 各个节点的左右指针， 让各个节点可以指向自己的前后节点,怎么办?

  4. 解决方案-线索二叉树

线索二叉树基本介绍

  1. n 个结点的二叉链表中含有 n+1 【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）

  2. 这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种

  3. 一个结点的前一个结点，称为前驱结点

  4. 一个结点的后一个结点，称为后继结点

线索二叉树应用案例

应用案例说明：

将下面的二叉树，进行中序线索二叉树。中序遍历的数列为 {8, 3, 10, 1, 14, 6}

image-20210711173827265

思路分析

中序遍历的结果：{8, 3, 10, 1, 14, 6}

image-20210711173906361

当线索化二叉树后，Node 节点的 属性 left 和 right ，有如下情况:

  1. left 指向的是左子树，也可能是指向的前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点.

  2. right 指向的是右子树，也可能是指向后继节点，比如 ① 节点 right 指向的是右子树，而⑩ 节点的 right 指向的是后继节点.

遍历线索化二叉树

  1. 说明：对前面的中序线索化的二叉树， 进行遍历

  2. 分析：因为线索化后，各个结点指向有变化，因此原来的遍历方式不能使用，这时需要使用新的方式遍历线索化二叉树，各个节点可以通过线型方式遍历，因此无需使用递归方式，这样也提高了遍历的效率。 遍历的次序应当和中序遍历保持一致。

代码实现

package cn.chasing.DataStructure.tree;

import org.junit.Test;

/**
 * @author 柴柴快乐每一天
 * @create 2021-07-06  9:43 下午
 * <p>
 * 『Stay hungry, stay foolish. 』
 */
public class ThreadedBinaryTreeDemo {

    @Test
    public void test() {
        //测试一把中序线索二叉树的功能
        THeroNode root = new THeroNode(1, "tom");
        THeroNode node2 = new THeroNode(3, "jack");
        THeroNode node3 = new THeroNode(6, "smith");
        THeroNode node4 = new THeroNode(8, "mary");
        THeroNode node5 = new THeroNode(10, "king");
        THeroNode node6 = new THeroNode(14, "dim");

        //二叉树，后面我们要递归创建, 现在简单处理使用手动创建
        root.setLeft(node2);
        root.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);

        //测试中序线索化
        ThreadedBinaryTree threadedBinaryTree = new ThreadedBinaryTree();
        threadedBinaryTree.setRoot(root);
        threadedBinaryTree.threadedNodes();

        //测试: 以10号节点测试
        THeroNode leftNode = node5.getLeft();
        THeroNode rightNode = node5.getRight();
        System.out.println("10号结点的前驱结点是 ="  + leftNode); //3
        System.out.println("10号结点的后继结点是="  + rightNode); //1

        //当线索化二叉树后，能在使用原来的遍历方法
        //threadedBinaryTree.infixOrder();
        System.out.println("使用线索化的方式遍历 线索化二叉树");
        threadedBinaryTree.threadedList(); // 8, 3, 10, 1, 14, 6
    }
}

/**
 * ThreadedBinaryTree 二叉树
 */
class ThreadedBinaryTree {
    private THeroNode root;

    //为了实现线索化，需要创建要给指向当前结点的前驱结点的指针
    //在递归进行线索化时，pre 总是保留前一个结点
    private THeroNode pre = null;

    //遍历线索化二叉树的方法
    public void threadedList() {
        //定义一个变量，存储当前遍历的结点，从root开始
        THeroNode node = root;
        while (node != null) {
            //循环的找到leftType == 1的结点，第一个找到就是8结点
            //后面随着遍历而变化,因为当leftType==1时，说明该结点是按照线索化
            //处理后的有效结点
            while (node.getLeftType() == 0) {
                node = node.getLeft();
            }

            System.out.println(node);

            while (node.getRightType() == 1) {
                node = node.getRight();
                System.out.println(node);
            }

            node = node.getRight();

        }
    }

    public void threadedNodes() {
        this.threadedNodes(root);
    }

    /**
     * 编写对二叉树进行中序线索化的方法
     * @param node  就是当前需要线索化的结点
     */
    public void threadedNodes(THeroNode node) {
        //如果node==null, 不能线索化
        if (node == null) {
            return;
        }
        // 线索化左子树
        threadedNodes(node.getLeft());

        // 线索化当前节点
        // 处理当前节点的前驱节点
        if (node.getLeft() == null) {
            node.setLeft(pre);
            node.setLeftType(1);
            // 以8为例，pre == null, leftType == 1
        }

        // 处理当前节点的后继节点
        // 递归回上一层了
        if (pre != null && pre.getRight() == null) {
            pre.setRight(node);
            pre.setRightType(1);
        }

        //!!! 每处理一个结点后，让当前结点是下一个结点的前驱结点
        pre = node;

        // 线索化右子树
        threadedNodes(node.getRight());
    }

    public ThreadedBinaryTree() {
    }

    public ThreadedBinaryTree(THeroNode root) {
        this.root = root;
    }

    public THeroNode getRoot() {
        return root;
    }

    public void setRoot(THeroNode root) {
        this.root = root;
    }

    /**
     * 前序遍历
     */
    public void preOrder() {
        if (this.root != null) {
            this.root.preOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    /**
     * 中序遍历
     */
    public void infixOrder() {
        if (this.root != null) {
            this.root.infixOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    /**
     * 后序遍历
     */
    public void postOrder() {
        if (this.root != null) {
            this.root.postOrder();
        } else {
            System.out.println("二叉树为空，无法遍历");
        }
    }

    /**
     * 前序遍历查找
     * @param no
     * @return
     */
    public THeroNode preOrderSearch(int no) {
        if (this.root != null) {
            return this.root.preOrderSearch(no);
        } else {
            return null;
        }
    }

    /**
     * 中序遍历查找
     * @param no
     * @return
     */
    public THeroNode infixOrderSearch(int no) {
        if (this.root != null) {
            return this.root.infixOrderSearch(no);
        } else {
            return null;
        }
    }

    /**
     * 后序遍历查找
     * @param no
     * @return
     */
    public THeroNode postOrderSearch(int no) {
        if (this.root != null) {
            return this.root.postOrderSearch(no);
        } else {
            return null;
        }
    }

    /**
     * 删除节点
     * @param no
     */
    public void deleteNo(int no){
        if (this.root != null) {
            // 这样才能完成当前节点的比较
            if (this.root.getNo() == no) {
                this.root = null;
                return;
            } else {
                // 递归进去第一步就是比较当前节点
                this.root.delete(no);
            }
        } else {
            System.out.println("this tree is null and cannot delete");
        }
    }
}



/**
 * THeroNode结点
 */
class THeroNode{
    private int no;
    private String name;
    private THeroNode left;
    private THeroNode right;

    //说明
    //1. 如果leftType == 0 表示指向的是左子树, 如果 1 则表示指向前驱结点
    //2. 如果rightType == 0 表示指向是右子树, 如果 1表示指向后继结点
    private int leftType;
    private int rightType;

    public int getLeftType() {
        return leftType;
    }

    public void setLeftType(int leftType) {
        this.leftType = leftType;
    }

    public int getRightType() {
        return rightType;
    }

    public void setRightType(int rightType) {
        this.rightType = rightType;
    }

    public THeroNode(int no, String name) {
        this.no = no;
        this.name = name;
    }

    @Override
    public String toString() {
        return "THeroNode{" +
                "no=" + no +
                ", name='" + name + '\'' +
                '}';
    }

    public int getNo() {
        return no;
    }

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

    public String getName() {
        return name;
    }

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

    public THeroNode getLeft() {
        return left;
    }

    public void setLeft(THeroNode left) {
        this.left = left;
    }

    public THeroNode getRight() {
        return right;
    }

    public void setRight(THeroNode right) {
        this.right = right;
    }

    /**
     * 前序遍历
     */
    public void preOrder() {
        System.out.println(this); //先输出父节点
        // 递归向左子树前序遍历
        if (this.left != null) {
            this.left.preOrder();
        }
        // 递归向右子树前序遍历
        if (this.right != null) {
            this.right.preOrder();
        }
    }

    /**
     * 中序遍历
     */
    public void infixOrder() {
        // 递归向左子树中序遍历
        if (this.left != null) {
            this.left.infixOrder();
        }
        // 输出父节点
        System.out.println(this);
        // 递归右子树中序遍历
        if (this.right != null) {
            this.right.infixOrder();
        }
    }

    /**
     * 后续遍历
     */
    public void postOrder() {
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }

    /**
     * 前序遍历查找
     * @param no 查找no
     * @return 找到返回该node，没找到返回null
     */
    public THeroNode preOrderSearch(int no) {
        System.out.println("pre");
        if (this.no == no) {
            return this;
        }
        THeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.preOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        if (this.right != null) {
            resNode = this.right.preOrderSearch(no);
        }
        return resNode;
    }

    /**
     * 中序遍历查找
     * @param no
     * @return
     */
    public THeroNode infixOrderSearch(int no) {
        THeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.infixOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("infix");
        if (this.no == no) {
            return this;
        }
        if (this.right != null) {
            resNode = this.right.infixOrderSearch(no);
        }
        return resNode;
    }

    /**
     * 后续遍历查找
     * @param no
     * @return
     */
    public THeroNode postOrderSearch(int no) {
        THeroNode resNode = null;
        if (this.left != null) {
            resNode = this.left.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        if (this.right != null) {
            resNode = this.right.postOrderSearch(no);
        }
        if (resNode != null) {
            return resNode;
        }
        System.out.println("post");
        if (this.no == no) {
            return this;
        }
        return null;
    }

    //思路
      /*
       *     1. 因为我们的二叉树是单向的，所以我们是判断当前结点的子结点是否需要删除结点，而不能去判断当前这个结点是不是需要删除结点.
         2. 如果当前结点的左子结点不为空，并且左子结点 就是要删除结点，就将this.left = null; 并且就返回(结束递归删除)
         3. 如果当前结点的右子结点不为空，并且右子结点 就是要删除结点，就将this.right= null ;并且就返回(结束递归删除)
         4. 如果第2和第3步没有删除结点，那么我们就需要向左子树进行递归删除
         5.  如果第4步也没有删除结点，则应当向右子树进行递归删除.

       */

    /**
     * 删除节点
     * 1.如果删除的节点是叶子节点，则删除该节点
     * 2.如果删除的节点是非叶子节点，则删除该子树
     * @param no
     */
    public void delete(int no) {
        if (this.left != null && this.left.no == no) {
            this.left = null;
            return;
        }
        if (this.right != null && this.right.no == no) {
            this.right = null;
            return;
        }
        if (this.left != null) {
            this.left.delete(no);
        }
        if (this.right != null) {
            this.right.delete(no);
        }
    }

}

线索化二叉树的课后作业:

前序线索化二叉树和后序线索化二叉树的分析思路类似

奥义喷火恐龙
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RISC-V与DSA计算机架构
吴建明wujianming_110117
02-23 3244
RISC-V与DSA计算机架构 相信所有和计算机体系结构打过交道的朋友们都看过David Patterson与John Hennessy的煌煌巨作,《计算机体系架构：量化研究方法》。两位在计算机架构领域鼎鼎大名的教授，一个来自加州大学伯克利分校，另一个来自斯坦福。 首先上场的是David Patterson，为我们带来了关于指令集架构（ISA）的回顾以及RISC-V项目的展望。 （Patterson教授在演讲中） Patterson教授的演讲主题是50年来计算机体系架构（ISA为主）的回顾以及RISC-
Java编程：树（基础部分）
KaiSarH
10-05 416
Java编程：树
树相关知识及编程练习总结
热门推荐
张彦峰的博客
10-27 1万+
树相关知识及编程练习总结：背景知识+树的应用举例（Spring中的应用举例+其他框架中的应用举例+实际开发中的应用举例）+相关编程练习（二叉树遍历：包括前序遍历、中序遍历、后序遍历、层序遍历等+二叉树的最大深度+二叉树的最小深度+对称二叉树+二叉树的最近公共祖先+二叉树的直径+二叉树的路径和+二叉搜索树中的插入操作+二叉搜索树中的删除操作+二叉搜索树中的搜索操作+二叉树的层平均值+二叉树的镜像+二叉树的序列化与反序列化+二叉树的右视图+二叉树的最大宽度+前序遍历和中序遍历构造二叉树+平衡二叉树）
编程题分类——树
保持一颗敬畏之心，简单地调用C++，适当地向C++妥协，让以后的自己看懂代码，让别人看懂代码。
10-23 383
目录前言正文按之字形顺序打印二叉树参考 前言 正文 按之字形顺序打印二叉树 code /* struct TreeNode { int val; struct TreeNode *left; struct TreeNode *right; TreeNode(int x) : val(x), left(NULL), right(NULL) { } }; */ class Solution { public: vector<vecto
程序树形结构构建
mhl8519的博客
03-18 305
程序树形结构构建
dsa_java:使用Java的数据结构和算法
04-07
在编程领域，数据结构和算法...通过这个"dsa_java"项目，你可以深入学习和实践这些Java数据结构和算法，提升编程技能，并能够更好地理解和解决问题。项目的源代码可以作为学习和参考的实例，加深理论与实际操作的结合。
数据结构和算法(DSA)贡献_C++_Java_下载.zip
最新发布
04-30
这个压缩包“数据结构和算法(DSA)贡献_C++_Java_下载.zip”显然是一个包含C++和Java语言实现的数据结构与算法资源集合。 在C++和Java中，数据结构主要包括数组、链表、栈、队列、哈希表、树（如二叉树、平衡树AVL和...
dsa:数据结构与算法实践
06-17
《dsa:数据结构与算法实践》是一本深入探讨数据结构和算法应用的资源，主要针对Java编程语言。在这个领域，理解和熟练运用数据结构与算法是提升编程能力的关键，也是解决复杂问题的基础。以下是对这个主题的详细阐述...
DSA:数据结构与算法实践
03-27
在这个主题中，我们将深入探讨一些关键的Java数据结构和算法。 首先，我们从数据结构开始。数据结构是指在内存中存储、组织数据的方式，常见的有数组、链表、栈、队列、树、图、哈希表等。数组是最基础的数据结构，...
DSA:Java中的数据结构和算法
03-21
数据结构与算法（DSA）是计算机科学的基础，对于任何编程语言来说，理解并掌握它们都是至关重要的。在Java中，DSA的应用尤其广泛，因为Java作为一种强类型、面向对象的语言，其丰富的类库和高效性能使得它成为实现...
java基础树状图
06-09
java基础
Java程序设计基础学习3（树与二叉树）
qq_50972777的博客
01-19 339
主要是关于数据结构树的一些代码编写。 21. 第 21 天: 二叉树的深度遍历的递归实现 21.1. 遍历、递归&&迭代 递归：一个过程函数在其定义或说明中有直接或间接调用自身的一种方法，它通常把一个大型复杂的问题层层转化为一个与原问题相似的规模较小的问题来求解。一般来说，递归需要有边界条件、递归前进段和递归返回段。 迭代：迭代是重复反馈过程的活动，其目的通常是为了逼近所需目标或结果。每一次对过程的重复称为一次“迭代”，而每一次迭代得到的结果会作为下一次迭代的初始值。（斐波那契数列）
各种编程实现的树
weixin_33801856的博客
05-03 380
d3js : 　　　  http://animateddata.co.uk/lab/d3-tree/# javaFx2 : 　　https://docs.oracle.com/javafx/2/animations/img/tree-only.jpg 　　　　　　　https://docs.oracle.com/javafx/2/animations/jfxpub-animations.htm...
树的常见问题编程
CSDN_WHB的博客
04-17 291
template &lt;typename T&gt;/*struct BTreeNode{ T val; BTreeNode* parent; BTreeNode* left; BTreeNode* right;};*///先序遍历二叉树template &lt;typename T&gt;void preTrav(BTreeNode&lt;T&gt;* p){ if(p != NULL) { ...
二叉树相关编程题总结
John的博客
12-01 6288
关于二叉树的五道面试题的总结 求二叉树的最远两个结点的距离； 由前序遍历和中序遍历重建二叉树； 判断一棵树是否是完全二叉树； 求二叉树两个节点的最近公共祖先； 将二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。 注：本篇博客就这五道面试题，并不是单纯的给出求解代码，而是全面的进行分析，并进行问题的延伸，在求解过程中对问题的延伸都有代码的实现，so!
数据结构学习：什么是树？
一名热爱技术的工程师的博客。分享技术干货，记录美好生活。永远相信美好的事情即将发生。
07-30 3418
概念 A tree is a nonlinear data structure, compared to arrays, linked lists, stacks and queues which are linear data structures. A tree can be empty with no nodes or a tree is a structure consisting of ...
利用Java语言编写二叉树并用三种方式（前序、中序、后序）遍历树
一只小白的奋斗历程的博客
02-22 444
如题：利用Java语言编写二叉树并用三种方式（前序、中序、后序）遍历树 分析： 1、创建一个空树类。 2、创建一个根节点类。 3、创建一个测试类。 4、利用递归的思想进行二叉树的遍历。 具体代码如下： 1、空树类： public class BinaryTree { // 空树 类 //设置一个根节点 TreeNode root; public void...
Linux进程管理之进程树pstree
xiao_hao_的博客
11-17 2893
语法： pstree [选项]：更加直观的来看进程信息 选项 作用 -p 显示进程的PID -u 显示进程的所属用户 案例1： 请以树状的形式显示进程的PID pstree -p 案例2： 请以树状的形式显示进程的用户PID pstree -u ...
面试中所有二叉树题目总结（java版）
etdeng的专栏
11-29 893
package BinaryTreeSummary; import java.util.ArrayList; import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Queue; import java.util.Stack;
97页精华：英文版数据结构与算法速成指南
"《数据结构与算法快速入门》是一本英文原版的简短教程，仅包含97页的内容，旨在帮助读者在学习计算机科学的同时掌握数据结构与算法的基础知识。这本书以实践为导向，结合英语学习，让读者在轻松愉快的氛围中提升...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值