Java数据结构和算法---二叉树

已于 2022-04-05 18:58:36 修改
阅读量682 收藏
点赞数
分类专栏： Java数据结构和算法 文章标签： java 数据结构 二叉树 树
于 2022-04-03 20:44:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/TIANJIAWEN/article/details/123938172
版权

·二叉树
        为什么需要树这种数据结构
        ①数组存储方式的分析
           优点：通过下标方式访问元素，速度快。对于有序数组，还可使用二分查找提高检索速度。            缺点：如果要检索具体某个值，或者插入值(按一定顺序)会整体移动，效率较低
        ②链式存储方式的分析
           优点：在一定程度上对数组存储方式有优化(比如：插入一个数值节点，只需要将插入节点，链接到链表中即可， 删除效率也很好)。
           缺点：在进行检索时，效率仍然较低，比如(检索某个值，需要从头节点开始遍历) 
        ③树存储方式的分析 能提高数据存储，读取的效率,  比如利用 二叉排序树(Binary Sort Tree)，既可以保证数据的检索速度，同时也可以保证数据的插入，删除，修改的速度。
        案例: [7, 3, 10, 1, 5, 9, 12]


 二叉树的概念
        ①树有很多种，每个节点最多只能有两个子节点的一种形式称为二叉树。
        ②二叉树的子节点分为左节点和右节点。
        ③如果该二叉树的所有叶子节点都在最后一层，并且结点总数= 2^n -1 , n 为层数，则我们称为满二叉树。
        ④如果该二叉树的所有叶子节点都在最后一层或者倒数第二层，而且最后一层的叶子节点在左边连续，倒数第二层的叶子节点在右边连续，我们称为完全二叉树

         完全二叉树 ， 如果把 (61)节点删除， 就不是完全二叉树了,因为叶子节点不连续了

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

代码:

package tree;

public class BinaryTree1 {
    public static void main(String[] args) {
        Node zhangke1 = new Node(1, "zhangke1");
        Node zhangke2 = new Node(2, "zhangke2");
        Node zhangke3 = new Node(3, "zhangke3");
        Node zhangke4 = new Node(4, "zhangke4");
        Node zhangke5 = new Node(5,"zhangke5");
        zhangke1.right=zhangke3;
        zhangke1.left=zhangke2;
        zhangke3.right=zhangke4;
        zhangke3.left=zhangke5;
        binaryTree binaryTree1 = new binaryTree();
        binaryTree1.setRoot(zhangke1);
        binaryTree1.preOrder();
        System.out.println();
        binaryTree1.midOrder();
        System.out.println();
        binaryTree1.postOrder();
    }
}
class binaryTree{
   private Node root;
   public void setRoot(Node root){
       this.root=root;
   }
   public void preOrder(){
       if (root != null) {
           root.preOrder();
       }else {
           System.out.println("EMPTY");
       }
   }
   public void midOrder(){
        if (root != null) {
            root.midOrder();
        }else {
            System.out.println("EMPTY");
        }
    }
    public void postOrder(){
        if (root != null) {
            root.postOrder();
        }else {
            System.out.println("EMPTY");
        }
    }
}
class Node{
    private int no;
    private String name;
    Node left;
    Node right;

    public Node(int no, String name) {
        this.no = no;
        this.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 Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\''
                +
                '}';
    }
    public void preOrder(){
        System.out.println(this);
        if (this.left != null) {
            this.left.preOrder();
        }
        if (this.right != null) {
            this.right.preOrder();
        }
    }
    public void midOrder(){
        if (this.left != null) {
            this.left.midOrder();
        }
        System.out.println(this);
        if (this.right != null) {
            this.right.midOrder();
        }
    }
    public void postOrder(){
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }
}


二叉树-查找指定节点

 分别利用前中后序查找 找5: 前序比较了4次 中序比较了3次 后序比较了2次


 代码: Node.left和Node.right最好定义为private然后通过set/get来设置/获取

package tree;

public class BinaryTree1 {
    public static void main(String[] args) {
        Node zhangke1 = new Node(1, "zhangke1");
        Node zhangke2 = new Node(2, "zhangke2");
        Node zhangke3 = new Node(3, "zhangke3");
        Node zhangke4 = new Node(4, "zhangke4");
        Node zhangke5 = new Node(5,"zhangke5");
        zhangke1.right=zhangke3;
        zhangke1.left=zhangke2;
        zhangke3.right=zhangke4;
        zhangke3.left=zhangke5;
        binaryTree binaryTree1 = new binaryTree();
        binaryTree1.setRoot(zhangke1);
        System.out.println("前序遍历:");
        binaryTree1.preOrder();
        System.out.println();
        System.out.println("中序遍历:");
        binaryTree1.midOrder();
        System.out.println();
        System.out.println("后序遍历:");
        binaryTree1.postOrder();

        System.out.println("前序遍历查找5:");//四次
        Node node = binaryTree1.preOrderSearch(5);
        if(node!=null){
            System.out.println("找到了"+node.toString());
        }else {
            System.out.println("没找到");
        }
        System.out.println("中序遍历查找5:");//三次
        Node node1 = binaryTree1.midOrderSearch(5);
        if(node1!=null){
            System.out.println("找到了"+node.toString());
        }else {
            System.out.println("没找到");
        }
        System.out.println("后序遍历查找5:");//两次
        Node node2 = binaryTree1.postOrderSearch(5);
        if(node1!=null){
            System.out.println("找到了"+node.toString());
        }else {
            System.out.println("没找到");
        }

    }
}
class binaryTree{
   private Node root;
   public void setRoot(Node root){
       this.root=root;
   }
   public void preOrder(){
       if (root != null) {
           root.preOrder();
       }else {
           System.out.println("EMPTY");
       }
   }
   public void midOrder(){
        if (root != null) {
            root.midOrder();
        }else {
            System.out.println("EMPTY");
        }
    }
    public void postOrder(){
        if (root != null) {
            root.postOrder();
        }else {
            System.out.println("EMPTY");
        }
    }
    public Node preOrderSearch(int no){
       if(root!=null){
           return root.preOrderSearch(no);
       }else {
           return null;
       }
    }

    public Node midOrderSearch(int no){
        if(root!=null){
            return root.midOrderSearch(no);
        }else {
            return null;
        }
    }

    public Node postOrderSearch(int no){
        if(root!=null){
            return root.postOrderSearch(no);
        }else {
            return null;
        }
    }
}
class Node{
    private int no;
    private String name;
    Node left;
    Node right;

    public Node(int no, String name) {
        this.no = no;
        this.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 Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\''
                +
                '}';
    }
    public void preOrder(){
        System.out.println(this);
        if (this.left != null) {
            this.left.preOrder();
        }
        if (this.right != null) {
            this.right.preOrder();
        }
    }
    public void midOrder(){
        if (this.left != null) {
            this.left.midOrder();
        }
        System.out.println(this);
        if (this.right != null) {
            this.right.midOrder();
        }
    }
    public void postOrder(){
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }


    //前序遍历查找
    public Node preOrderSearch(int no){
        System.out.println("1");
        if(this.no==no){
            return this;
        }
        Node 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);
        }
       //这里无论找不找得到 都要返回 找不到的话返回一个null
            return resNode;

    }
    //中序遍历查找
    public Node midOrderSearch(int no){
        Node resNode = null;
        if (this.left != null) {
            resNode = this.left.midOrderSearch(no);
        }
        if(resNode!=null){
            return resNode;
        }
        System.out.println("2");
        if(this.no==no){
            return this;
        }
        if (this.right != null) {
            resNode = this.right.midOrderSearch(no);
        }
        //这里无论找不找得到 都要返回 找不到的话返回一个null
        return resNode;

    }
    //后序遍历查找
    public Node postOrderSearch(int no){

        Node 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("3");
        if(this.no==no){
            return this;
        }
        return null;
    }
}

二叉树-删除节点

        如果删除的节点是叶子节点，则删除该节点
        如果删除的节点是非叶子节点，则删除该子树(临时要求 后面会优化).
        写代码测试，删除掉 5号叶子节点 和 3号子树.

代码:

package tree;

public class BinaryTree1 {
    public static void main(String[] args) {
        Node zhangke1 = new Node(1, "zhangke1");
        Node zhangke2 = new Node(2, "zhangke2");
        Node zhangke3 = new Node(3, "zhangke3");
        Node zhangke4 = new Node(4, "zhangke4");
        Node zhangke5 = new Node(5,"zhangke5");
        zhangke1.setRight(zhangke3);
        zhangke1.setLeft(zhangke2);
        zhangke3.setRight(zhangke4);
        zhangke3.setLeft(zhangke5);
        binaryTree binaryTree1 = new binaryTree();
        binaryTree1.setRoot(zhangke1);
        System.out.println("前序遍历:");
        binaryTree1.preOrder();
        System.out.println();
        System.out.println("中序遍历:");
        binaryTree1.midOrder();
        System.out.println();
        System.out.println("后序遍历:");
        binaryTree1.postOrder();

        binaryTree1.deleteNode(5);
        System.out.println("前序遍历:");
        binaryTree1.preOrder();
        System.out.println();
        System.out.println("中序遍历:");
        binaryTree1.midOrder();
        System.out.println();
        System.out.println("后序遍历:");
        binaryTree1.postOrder();

    }
}
class binaryTree{
   private Node root;
   public void setRoot(Node root){
       this.root=root;
   }
   public void preOrder(){
       if (root != null) {
           root.preOrder();
       }else {
           System.out.println("EMPTY");
       }
   }
   public void midOrder(){
        if (root != null) {
            root.midOrder();
        }else {
            System.out.println("EMPTY");
        }
    }
    public void postOrder(){
        if (root != null) {
            root.postOrder();
        }else {
            System.out.println("EMPTY");
        }
    }
    public Node preOrderSearch(int no){
       if(root!=null){
           return root.preOrderSearch(no);
       }else {
           return null;
       }
    }

    public Node midOrderSearch(int no){
        if(root!=null){
            return root.midOrderSearch(no);
        }else {
            return null;
        }
    }

    public Node postOrderSearch(int no){
        if(root!=null){
            return root.postOrderSearch(no);
        }else {
            return null;
        }
    }

    public void deleteNode(int no) {
        if(this.root!=null){
            //只有一个root
            if(root.getNo()==no){
                root=null;
            }else {
                root.deleteNode(no);
            }
        }else {
            System.out.println("空树!");
        }
    }
}
class Node{

    private int no;
    private String name;
    private Node left;
    private Node right;

    public Node(int no, String name) {
        this.no = no;
        this.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 Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

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

    public void deleteNode(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.deleteNode(no);
        }
        if(this.right!=null){
            this.right.deleteNode(no);
        }
    }
    public void preOrder(){
        System.out.println(this);
        if (this.left != null) {
            this.left.preOrder();
        }
        if (this.right != null) {
            this.right.preOrder();
        }
    }
    public void midOrder(){
        if (this.left != null) {
            this.left.midOrder();
        }
        System.out.println(this);
        if (this.right != null) {
            this.right.midOrder();
        }
    }
    public void postOrder(){
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }


    //前序遍历查找
    public Node preOrderSearch(int no){
        System.out.println("1");
        if(this.no==no){
            return this;
        }
        tree.Node 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);
        }
       //这里无论找不找得到 都要返回 找不到的话返回一个null
            return resNode;

    }
    //中序遍历查找
    public Node midOrderSearch(int no){
        Node resNode = null;
        if (this.left != null) {
            resNode = this.left.midOrderSearch(no);
        }
        if(resNode!=null){
            return resNode;
        }
        System.out.println("2");
        if(this.no==no){
            return this;
        }
        if (this.right != null) {
            resNode = this.right.midOrderSearch(no);
        }
        //这里无论找不找得到 都要返回 找不到的话返回一个null
        return resNode;

    }
    //后序遍历查找
    public Node postOrderSearch(int no){

        Node 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("3");
        if(this.no==no){
            return this;
        }
        return null;
    }
}

顺序存储二叉树的概念 
        从数据存储来看，数组存储方式和树 的存储方式可以相互转换，即数组可 以转换成树，树也可以转换成数组  如下图所示:

        要求:
                下图的二叉树的结点，要求以数组 的方式来存放 arr : [1, 2, 3, 4, 5, 6, 6] 且在遍历数组 arr时，仍然可以以 前序遍历，中序遍历和后序遍历的 方式完成结点的遍历

        顺序存储二叉树的特点:
                顺序二叉树通常只考虑完全二叉树 第n个元素的左子节点为  2 * n + 1 第n个元素的右子节点为  2 * n + 2 第n个元素的父节点为  (n-1) / 2 n : 表示二叉树中的第几个元素(按0开始编号 如图所示)

 顺序存储二叉树遍历 (堆排序会用到这个)
        需求:
                给你一个数组 {1,2,3,4,5,6,7}，要求以二叉树前序遍历的方式进行遍历。 前序遍历的结果应当为 1,2,4,5,3,6,7
        代码:

package tree;

public class shunxucunchu {
    public static void main(String[] args) {
        int []arr = {1,2,3,4,5,6,7};
        arrayBinaryTree arrayBinaryTree1 = new arrayBinaryTree(arr);//1 2 4 5 3 6 7
        arrayBinaryTree1.preOrder();
    }
}
class arrayBinaryTree{
    private int []arr;//存储结点的数组

    public arrayBinaryTree(int[] arr) {
        this.arr = arr;
    }
    //重载
    public void preOrder(){
        this.preOrder(0);
    }
    //编写一个方法完成顺序存储二叉树的前序遍历
    public void preOrder(int index){//index 数组下标
        if(arr==null||arr.length==0){
            return;
        }
        //输出当前元素
        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);
    }
}


线索化二叉树

        ①n个结点的二叉链表中含有n+1  【公式 2n-(n-1)=n+1】 个空指针域。利用二叉链表中的空指针域，存放指向该结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索"）         
        ②这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree)。
        ③根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种
        一个结点的前一个结点，称为前驱结点
        一个结点的后一个结点，称为后继结点

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

         tips:当线索化二叉树后，Node节点的 属性 left 和 right ，有如下情况:
                ①left 指向的是左子树，也可能是指向的前驱节点. 比如 ① 节点 left 指向的左子树, 而 ⑩ 节点的 left 指向的就是前驱节点.
                ②right指向的是右子树，也可能是指向后继节点，比如 ① 节点right 指向的是右子树，而⑩ 节点的right 指向的是后继节点. 

代码:

package tree.xianshu;

public class ThreadedBinaryTree {
    public static void main(String[] args) {
        Node node1 = new Node(1, "1");
        Node node2 = new Node(3, "3");
        Node node3 = new Node(4, "6");
        Node node4 = new Node(8, "8");
        Node node5 = new Node(10, "10");
        Node node6 = new Node(14, "14");

        node1.setLeft(node2);
        node1.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);
        threadBinaryTree threadBinaryTree = new threadBinaryTree();
        threadBinaryTree.setRoot(node1);
        threadBinaryTree.threadedNodes();

        //测试:以node5为例子
        Node left = node5.getLeft();
        Node right = node5.getRight();
        System.out.println(left);
        System.out.println(right);
    }
}

class threadBinaryTree{
    private Node root;
    //为了实现先做华 需要创建一个指向当前结点的前驱结点
    //pre在递归进行线索化时 总保留前一个结点(前驱结点)
    private Node pre = null;
    public void setRoot(Node root){
        this.root=root;
    }
    public void threadedNodes(){
        this.threadedNodes(root);
    }
    //编写对二叉树进行中序线索化的方法
    public void threadedNodes(Node node){//node就是当前需要线索化的结点
        if (node==null){
            return;
        }
        //1.先线索化左子树(对应中序遍历)
        threadedNodes(node.getLeft());
        //2.线索化当前结点[有难度]
        //处理当前结点的前驱结点
        /*
        以结点8为例子
             8.left = null;
             8.leftType=1;
         */
        if(node.getLeft()==null){
            //让当前结点的左指针指向前驱结点
            node.setLeft(pre);
            node.setLeftType(1);
        }
        //每处理一个结点后 让当前结点是下一个结点的前驱结点

        //处理后继结点 放在下一次循环中 让当前结点作为下次一循环中结点的前驱结点
        if(pre!=null&&pre.getRight()==null){
            pre.setRight(node);
            pre.setRightType(1);
        }
        pre = node;
        //3.再线索化右子树
        threadedNodes(node.getRight());
    }


    public void preOrder(){
        if (root != null) {
            root.preOrder();
        }else {
            System.out.println("EMPTY");
        }
    }
    public void midOrder(){
        if (root != null) {
            root.midOrder();
        }else {
            System.out.println("EMPTY");
        }
    }
    public void postOrder(){
        if (root != null) {
            root.postOrder();
        }else {
            System.out.println("EMPTY");
        }
    }
    public Node preOrderSearch(int no){
        if(root!=null){
            return root.preOrderSearch(no);
        }else {
            return null;
        }
    }

    public Node midOrderSearch(int no){
        if(root!=null){
            return root.midOrderSearch(no);
        }else {
            return null;
        }
    }

    public Node postOrderSearch(int no){
        if(root!=null){
            return root.postOrderSearch(no);
        }else {
            return null;
        }
    }

    public void deleteNode(int no) {
        if(this.root!=null){
            //只有一个root
            if(root.getNo()==no){
                root=null;
            }else {
                root.deleteNode(no);
            }
        }else {
            System.out.println("空树!");
        }
    }
}



class Node{
    private int no;
    private String name;
    private Node left;
    private Node right;

    private int leftType;//若=0 指向左子树 若=1指向前驱结点
    private int rightType;//若=0 指向右子树 若=1指向后继结点

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

    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 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 Node getLeft() {
        return left;
    }

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

    public Node getRight() {
        return right;
    }

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

    @Override
    public String toString() {
        return "Node{" +
                "no=" + no +
                ", name='" + name + '\''
                +
                '}';
    }
    public void deleteNode(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.deleteNode(no);
        }
        if(this.right!=null){
            this.right.deleteNode(no);
        }
    }
    public void preOrder(){
        System.out.println(this);
        if (this.left != null) {
            this.left.preOrder();
        }
        if (this.right != null) {
            this.right.preOrder();
        }
    }
    public void midOrder(){
        if (this.left != null) {
            this.left.midOrder();
        }
        System.out.println(this);
        if (this.right != null) {
            this.right.midOrder();
        }
    }
    public void postOrder(){
        if (this.left != null) {
            this.left.postOrder();
        }
        if (this.right != null) {
            this.right.postOrder();
        }
        System.out.println(this);
    }


    //前序遍历查找
    public Node preOrderSearch(int no){
        System.out.println("1");
        if(this.no==no){
            return this;
        }
        Node 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);
        }
        //这里无论找不找得到 都要返回 找不到的话返回一个null
        return resNode;

    }
    //中序遍历查找
    public Node midOrderSearch(int no){
        Node resNode = null;
        if (this.left != null) {
            resNode = this.left.midOrderSearch(no);
        }
        if(resNode!=null){
            return resNode;
        }
        System.out.println("2");
        if(this.no==no){
            return this;
        }
        if (this.right != null) {
            resNode = this.right.midOrderSearch(no);
        }
        //这里无论找不找得到 都要返回 找不到的话返回一个null
        return resNode;

    }
    //后序遍历查找
    public Node postOrderSearch(int no){

        Node 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("3");
        if(this.no==no){
            return this;
        }
        return null;
    }
}


遍历线索化二叉树
        说明：对前面的中序线索化的二叉树， 进行遍历
        分析：因为线索化后，各个结点指向有变化，因此原来的遍历方式不能使用，这时需要使用新的方式遍历线索化二叉树，各个节点可以通过线型方式遍历，因此无需使用递归方式，这样也提高了遍历的效率。 遍历的次序应当和中序遍历保持一致。
                tips:比如原来遍历退出递归的==null  现在都不成立了
代码:

   //遍历线索化二叉树
    public void threadedList(){
        //定义一个变量 存储当前遍历的结点 从root开始
        Node node = root;
        while (node!=null){
            //循环找到的第一个leftType==1的结点 第一个找到的就是结点"8"
            //后面随着遍历的变化而变化 不是固定的 因为当left==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();
        }
    }


 

需要沉淀沉淀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构与算法java篇--二叉树
小马哥的博客
12-24 722
数据结构有算法，java
尚硅谷数据结构与算法(Java)--24线索化二叉树
shlr_的博客
05-30 1256
：线索化二叉树 线索二叉树基本介绍 1)n个结点的二叉链表中含有n+1公式2n-(n-1)=n+1个空指针域。利用二叉链表中的空指针域，存放指向结点在某种遍历次序下的前驱和后继结点的指针（这种附加的指针称为"线索") 2)这种加上了线索的二叉链表称为线索链表，相应的二叉树称为线索二叉树(Threaded BinaryTree),根据线索性质的不同，线索二叉树可分为前序线索二叉树、中序线索二叉树和后序线索二叉树三种 3)一个结点的前一个结点，称为前驱结点 4)一个结点
数据结构常见问题总结
Wang laiqi's blog
11-21 755
排序算法 查找算法
数据结构大作业流程总结-答辩准备
ChangeW fafa的博客
06-06 2201
流程 制作ppt总纲流程 细节弄清楚，讲清楚——一定要清清楚楚 优缺点，改进与反思 总结 一、 总纲流程——首先项目介绍：说清楚是什么，为什么，怎么做 （1）爬虫 （2）数据处理 （3）数据分析（画图、词云等） （4）建模：1初步建模，调参优化，验证评估与效果展示 2评估模型，对比选择 （5）进行预测，前端框架，前端原理讲解，效果展示 （6）分析长进与优点，不足与改进 （7）总结所有 二、细节 （1）爬虫scrapy框架遇到的问题：header，ip池 （2）数据处理：：爬取下来的数据分析，与数据进行
Leetcode刷题（28）二叉树专题：树的前序遍历（三种方法：递归、迭代的两种写法）
Promise_Lv_2019的博客
06-18 345
本篇重要参考资料(点此跳转)。这篇解析，不仅简单介绍了二叉树这种数据结构，还详细罗列了各种不同遍历的方法，对于我使用的教材是个很好的补充。 # Definition for a binary tree node. # class TreeNode: # def __init__(self, x): # self.val = x # self.left = None # self.right = None class Solution: def
Java数据结构与算法-笔记-代码-课件-资料
05-17
稀疏数组、单向队列、环形队列、单向链表、双向链表、环形链表、约瑟夫问题、栈、前缀、中缀、后缀表达式、中缀表达式转换为后缀表达式、递归与回溯、迷宫问题、八皇后问题、算法的时间复杂度、冒泡排序、选择排序、...
Java数据结构和算法-带书签目录扫描版
11-11
《Java数据结构和算法-带书签目录扫描版》是一本深入探讨Java编程语言中数据结构和算法的书籍。此扫描版特别包含了完整的书签目录，使得读者在电子版阅读时能够快速定位到所需章节，提高了学习和查阅的效率。 在...
数据结构和算法-Java版.zip
01-14
算法与数据结构它们分别涵盖了以下主要内容： 数据结构（Data Structures）： ...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
数据结构与算法-学习笔记 Java 版.zip
最新发布
01-15
逻辑结构：描述数据元素之间的逻辑关系，如线性结构（如数组、链表）、树形结构（如二叉树、堆、B树...学习算法与数据结构不仅有助于理解程序的内部工作原理，更能帮助开发人员编写出高效、稳定和易于维护的软件系统。
关于树和二叉树的基本概念总结
jingsuxuyilq的专栏
03-09 5610
1.什么是（自由）树？ 树首先是无向图的一种，并且此无向图要满足下面两个特性： 1）连通，即任何两对顶点之间都有路径相连。 2）无回路，简单地说就是没有成环。 2.什么是森林？ 当满足树特性2）而不满足1）时称为森林。可以简单地理解为，什么不满足连通性，所以森林中可含有多个（自由）树。 3.树的特性 假设G = (V, E)是一个无向图，则下面的定义中等价的： 1）G是（自由）
java 树算法_Java数据结构与算法-树
weixin_42423852的博客
02-12 402
(摘录加总结------)一、树的概念(1)树是一种非线性的数据结构，是由n(n>=1)个有限节点组成的有层次关系的集合，在树中有许多节点，每一个节点最多只有一个父节点，并且可能会有0个或者更多个子节点，没有父节点的那个称为根节点，除了根节点外，每个节点又可分为多个不相交的子树。(2)树的相关概念术语：1)节点树中每个元素都叫节点2)根节点或树根树顶端的节点称之为根节点，也叫树根3)子树除根...
二叉树排序算法（java）
weixin_44591656的博客
02-19 1448
二叉树 主要包括根节点，左孩子和右孩子 二叉排序的基本原理： 把第一个元素作为根节点，之后的元素如果比第一个元素大，放到右面，否则放到左面 算法步骤 先声明一个节点类Node,里面有根节点，左孩子和右孩子 然后创建一个构造函数里面放的是根节点 然后写一个添加节点的方法，我们给他起名为add方法 先把创建树的代码写一下 class Node,声明一个节点类Node 里面有根节点，左右孩子，然后创建一个根节点的构造方法，方便后面使用。 class newTree{ class Node{ int data
二叉树【Java算法（八）】
qq_56402474的博客
04-09 914
简单的介绍了二叉树，数组存储和链式存储，其中链式存储占主要，因为数组存储比链式存储通常浪费空间。
数据结构——二叉树（Java 实现）
GhostLike_Husky的博客
09-08 794
为什么使用二叉树？ 1.在有序数据中插入数据项太慢； 2.在链表中查找太慢； 树既能向链表那样快速的插入和删除，又能像有序数组那样快速查找。 树的术语 路径：设想一下顺着连接节点的边从一个节点走到另一个节点，所经过的节点的顺序排列就称为“路径”。 根：树顶端的节点称为“根”。一棵树有且仅有一个根。 父节点，子节点。 叶节点：没有子节点的节点。 子树。 访问，遍历，层，关键字，二...
java数据结构与算法之树基本概念及二叉树（BinaryTree）的设计与实现
热门推荐
zejian的博客
12-22 4万+
【版权申明】未经博主同意，不允许转载！（请尊重原创，博主保留追究权） http://blog.csdn.net/javazejian/article/details/53727333 出自【zejian的博客】 关联文章:java数据结构与算法之顺序表与链表设计与实现分析 java数据结构与算法之双链表设计与实现 java数据结构与算法之改良顺序表与双链表类似ArrayList和L
JAVA 算法——树
hqiangtai的博客
03-12 512
1、二叉搜索树    二叉搜索树需满足以下四个条件：若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；任意节点的左、右子树也分别为二叉查找树；没有键值相等的节点。2、什么是伸展树（Splay Tree） 假设想要对一个二叉查找树执行一系列的查找操作。为了使整个查找时间更小，被查频率高的那些条目就应当经常处于靠近树...
Java数据结构与算法（树的入门）
博客包含书籍、B站、其他博主博客等内容，只为了记录笔记，作业，问题，软件配置等，为了以后方便查阅，如有侵权，请联系删除
07-24 427
树(Tree)是n(n>=0)个结点的有限集。当n=0时成为空树，在任意一棵非空树中： - 有且仅有一个特定的称为根(Root)的结点； - 当n>1时，其余结点可分为m(m>0)个互不相交的有限集T1、T2、...、Tm，其中每一个集合本身又是一棵树，并且称为根的子树(SubTree)。...
Java实现二叉树
飞奔的蜗牛
02-09 154
使用静态内部类实现 静态内部类作为二叉树结点，实现了创建二叉树和遍历二叉树，使用了递归的方法 import java.util.Scanner; public class BiTree<T> { static class Node<T> { private T data; private Node<T> lChild; ...
数据结构与算法分析---树Java实现
qq_37976565的博客
03-18 264
树 树的定义（递归方式） 树的实现 class TreeNode{ Object element; TreeNode firstChild; TreeNode nextSibling; } 树的遍历 先序遍历（preorder travelsal) 设我们想要列出目录中所有文件的名字。输出格式将是：深度为 did_idi​ 的文件将被 did_idi​ 次跳格（ta...
数据结构与算法-动态数据结构：二叉树遍历解析
在Java编程中，二叉树是一种非线性数据结构，由节点（每个节点包含一个值和最多两个子节点）组成，分为左子节点和右子节点。二叉树的主要特点在于它的快速查找、排序和删除重复数据项的能力。 二叉树的遍历有三种...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值