2. 程式人生 > 其它 >java--演算法--線索化二叉樹

java--演算法--線索化二叉樹

阿新 • • 發佈：2021-07-14
  1. 線索化二叉樹的介紹：
    4. 按照某種遍歷方式順序存放到陣列中：[0,1,2,3,4,5,6]：則1的前驅節點時0後繼節點時2

  2. 線索二叉樹的線索化程式碼實現：

    1. package com.model.tree;

/**
 * @Description:測試類
 * @Author: 張紫韓
 * @Crete 2021/7/14 9:39
 * 線索化二叉樹的程式碼實現
 */
public class TreeDemo03 {
    public static void main(String[] args) {
        HeroNode node1 = new HeroNode(1, "a");
        HeroNode node2 
       
      = new HeroNode(3, "b");
        HeroNode node3 = new HeroNode(6, "c");
        HeroNode node4 = new HeroNode(8, "d");
        HeroNode node5 = new HeroNode(10, "e");
        HeroNode node6 = new HeroNode(14, "f");
        node1.setLeft(node2);
        node1.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);
        ThreadedBinaryTree tree 
       
      = new ThreadedBinaryTree(node1);
        tree.threadedNode();
        System.out.println(node5.getLeft());
        System.out.println(node5.getRightType());


    }
}

class ThreadedBinaryTree {
    public HeroNode root;
    //第一個進行線索化的節點的前驅就是null
    private HeroNode pre=null;

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

    public HeroNode getRoot() {
        return root;
    }

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

    public void threadedNode(){threadedNode(root);}
//        編寫中中序化線索樹

    public void threadedNode(HeroNode node){
        if (node==null){
            return;
        }else {
//        線索化左子樹
            threadedNode(node.getLeft());
//        線索化當前節點
            if (node.getLeft()==null){
                node.setLeft(pre);
                node.setLeftType(1);
            }
            //當pre移動到node節點是，再對node的右指標進行處理
            if (pre!=null&&pre.getRight()==null){
                pre.setRight(node);
                pre.setRightType(1);
            }
            pre=node;
//        線索化右子樹
            threadedNode(node.getRight());
        }
    }




}

class HeroNode {
    private int id;
    private String name;
    private HeroNode left;
    private HeroNode right;

    //指定做指標事 是指向左右子樹還是執行前驅或後繼節點，如果是0則表示是字數如果是是1則表示指向前驅和後繼
    private int leftType;
    private int rightType;

    public HeroNode(int id, String name, HeroNode left, HeroNode right) {
        this.id = id;
        this.name = name;
        this.left = left;
        this.right = right;
    }

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

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 HeroNode() {
    }
    public HeroNode(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public void preOrder(){
        
    }

}

  3. 線索化二叉樹的遍歷：

    2. package com.model.tree;

/**
 * @Description:測試類
 * @Author: 張紫韓
 * @Crete 2021/7/14 9:39
 * 線索化二叉樹的程式碼實現
 */
public class TreeDemo03 {
    public static void main(String[] args) {
        HeroNode node1 = new HeroNode(1, "a");
        HeroNode node2 = new HeroNode(3, "b");
        HeroNode node3 = new HeroNode(6, "c");
        HeroNode node4 = new HeroNode(8, "d");
        HeroNode node5 = new HeroNode(10, "e");
        HeroNode node6 = new HeroNode(14, "f");
        node1.setLeft(node2);
        node1.setRight(node3);
        node2.setLeft(node4);
        node2.setRight(node5);
        node3.setLeft(node6);
        ThreadedBinaryTree tree = new ThreadedBinaryTree(node1);
//        中序線索化
        tree.threadedNode();
        System.out.println(node5.getLeft());
        System.out.println(node5.getRightType());
        tree.preOrder();
        System.out.println("---------------------");
        tree.preOrder03();

//        先序線索化
//
//        tree.threadedInfix();
//        System.out.println(node4.getLeft());
//        System.out.println(node4.getRight());


    }
}

class ThreadedBinaryTree {
    public HeroNode root;
    //第一個進行線索化的節點的前驅就是null
    private HeroNode pre = null;

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

    public ThreadedBinaryTree() {
    }

    public HeroNode getRoot() {
        return root;
    }

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

    public void threadedNode() {
        threadedNode(root);
    }

//    public void threadedInfix() {
//        threadedInfix(root);
//    }
//        編寫中中序化線索樹

    public void threadedNode(HeroNode node) {
        if (node == null) {
            return;
        } else {
//        線索化左子樹
            threadedNode(node.getLeft());
//        線索化當前節點
            if (node.getLeft() == null) {
                node.setLeft(pre);
                node.setLeftType(1);
            }
            //當pre移動到node節點是，再對node的右指標進行處理
            if (pre != null && pre.getRight() == null) {
                pre.setRight(node);
                pre.setRightType(1);
            }
            pre = node;
//        線索化右子樹
            threadedNode(node.getRight());
        }
    }

//    //    先序遍歷線索化
//    public void threadedInfix(HeroNode node) {
//        if (node == null) {
//            return;
//        }
////        線索化當前節點
//        if (node.getLeft() == null) {
//            node.setLeft(pre);
//            node.setLeftType(1);
//        }
//        if (pre != null && pre.getRight() == null) {
//            pre.setRight(node);
//            pre.setRightType(1);
//        }
//
//        pre = node;
////       序列化左子樹
//        if (node.getLeft()!=null){threadedInfix(node.getLeft());}
////        序列化右子樹
//        if (node.getRight()!=null){threadedInfix(node.getRight());}
//        
//    }

    public void preOrder() {
        root.preOrder();
    }

    //利用線索化進行遍歷《
//    線索化二叉樹，線索化的節點，指向的下一個節點就是中序遍歷的下一個節點，
//    但是如果沒有線索化的節點，並不是中序遍歷的節點
//    我們可以根據中序遍歷找到第一個節點，根據線索化，right 向後遍歷，但是需要判斷後面的是 線索化的還是普通的指向其右子樹
//    如果本節點的right 是線索化的我們可以直接 進行輸出，因為他就是中序遍歷的下一個節點，如果本節點的right指向的是其右子樹
//    我們子需要重新找到這個右子樹的第一個節點,自此進行上述遍歷
    public void preOrder02() {
        HeroNode temp = root;
//       找到第一個節點，利用線索化向後一定，遍歷所有的元素
        while (temp != null) {
            while (temp.getLeftType() == 0) {
                temp = temp.getLeft();
            }
//            找到第一個節點
            System.out.println(temp);

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

    public void preOrder03() {
        HeroNode temp = root;
        while (temp != null) {
//      1.得到這個樹中序遍歷的第一個節點(第一次是整個樹,第二次就是某個節點的子樹)
            while (temp.getLeftType() == 0) {
                temp = temp.getLeft();
            }
//       2.列印第一個節點
            System.out.println(temp);
//        3. 根據節點的線索化判斷其右節點是其子樹還是線索化的下一節點
            while (temp.getRightType() == 1) {
//                說明temp的右節點就是一個線索化的節點,就是中序遍歷的下一節點
                temp = temp.getRight();
                System.out.println(temp);
            }
//         4.跳出迴圈說明其右指標指向的是一個右子樹
            temp = temp.getRight();//執行右子樹重複上敘操作

        }

    }


}

class HeroNode {
    private int id;
    private String name;
    private HeroNode left;
    private HeroNode right;

    //指定做指標事 是指向左右子樹還是執行前驅或後繼節點，如果是0則表示是字數如果是是1則表示指向前驅和後繼
    private int leftType;
    private int rightType;

    public HeroNode(int id, String name, HeroNode left, HeroNode right) {
        this.id = id;
        this.name = name;
        this.left = left;
        this.right = right;
    }

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

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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 HeroNode() {
    }

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

    public void preOrder() {
        if (this == null) {
            return;
        } else {
            if (this.left != null && this.leftType == 0) {
                this.left.preOrder();
            }
            System.out.println(this);
            if (this.right != null && this.leftType == 0) {
                this.right.preOrder();
            }
        }

    }

}

      　　

相關推薦

java--演算法--線索化二叉樹

線索化二叉樹的介紹： 按照某種遍歷方式順序存放到陣列中：[0,1,2,3,4,5,6]：則1的前驅節點時0後繼節點時2

資料結構與演演算法--線索化二叉樹

前言   前一篇簡單的對二叉樹進行初探，簡單的瞭解了一下二叉樹的一些概念，和二叉樹的 順序儲存 和 鏈式儲存 以及二叉樹的一些簡單操作，和二叉樹的幾種遍歷方式。這一篇，我們在對二叉樹進行了解，假如這個二叉樹

重新整理資料結構與演算法(c#)—— 線索化二叉樹[二十]

前言 為什麼會有線索化二叉樹呢? 是這樣子的，二叉樹呢，比如有n個節點，那麼就有n+1個空指標域。

java實現中序線索化二叉樹遍歷

java實現中序線索化二叉樹遍歷 節點類 /** * 節點類 */ class Node { private int id; private Node left;

C#資料結構-線索化二叉樹

為什麼線索化二叉樹？ 對於二叉樹的遍歷，我們知道每個節點的前驅與後繼，但是這是建立在遍歷的基礎上,否則我們只知道後續的左右子樹。現在我們充分利用二叉樹左右子樹的空節點，分別指向當前節點的前驅、後繼，便於

線索化二叉樹

技術標籤：演算法與資料結構二叉樹線索化二叉樹資料結構java 一、線索二叉樹概述

【演算法】二叉樹、N叉樹先序、中序、後序、BFS、DFS遍歷的遞迴和迭代實現記錄（Java版）

本文總結了刷LeetCode過程中，有關樹的遍歷的相關程式碼實現，包括了二叉樹、N叉樹先序、中序、後序、BFS、DFS遍歷的遞迴和迭代實現。這也是解決樹的遍歷問題的固定套路。

【劍指offer較難部分22】序列化二叉樹（java）

技術標籤：劍指offer（java）二叉樹字串演算法面試 題目描述 請實現兩個函式，分別用來序列化和反序列化二叉樹 二叉樹的序列化是指：把一棵二叉樹按照某種遍歷方式的結果以某種格式儲存為字串，從而使得記憶體中

【演算法】二叉樹前中後序的遞迴+迭代（java程式碼）

二叉樹遍歷 【遞迴前中後序】 // 前序遍歷·遞迴·LC144_二叉樹的前序遍歷 class Solution {

線索二叉樹（找前驅/後繼）

線索二叉樹（找前驅/後繼） 建立線索的初衷就是為了在一個結點中能夠更方便找到前驅結點和後繼結點。

#樹#遍歷#LeetCode37.序列化二叉樹

/** * Definition for a binary tree node. * public class TreeNode { *int val; *TreeNode left; *TreeNode right;

線索二叉樹的構造

首先明確線索二叉樹的概念，線索二叉樹是原本二叉樹n個節點中未分配的n-1個孩子指標改為線索指標，左孩子指向前驅結點，右孩子指向後繼節點。

劍指offer（61）：序列化二叉樹

題目描述 請實現兩個函式，分別用來序列化和反序列化二叉樹 二叉樹的序列化是指：把一棵二叉樹按照某種遍歷方式的結果以某種格式儲存為字串，從而使得記憶體中建立起來的二叉樹可以持久儲存。序列化可以基於先序、

序列化二叉樹

offer_61 概要：序列化二叉樹 題目描述 請實現兩個函式，分別用來序列化和反序列化二叉樹

面試題37：序列化二叉樹

輸入一棵二叉樹，將其序列化為char*，並且支援反序列化為二叉樹。 解題思路

劍指 Offer 37. 序列化二叉樹 （難，多個小技巧）- 8月19日

題目 劍指 Offer 37. 序列化二叉樹 我的思路 從樹變成題目要求的字串，藉助佇列層序遍歷即可。注意整數變成字串可以用輸出運算子<<。

劍指 Offer 37. 序列化二叉樹

// Encodes a tree to a single string. public String serialize(TreeNode root) { if(root == null) return \"[]\";

劍指61.序列化二叉樹

題目描述 請實現兩個函式，分別用來序列化和反序列化二叉樹 二叉樹的序列化是指：把一棵二叉樹按照某種遍歷方式的結果以某種格式儲存為字串，從而使得記憶體中建立起來的二叉樹可以持久儲存。序列化可以基於先序、

演算法-求二叉樹的最大深度

1.題目 求給定二叉樹的最大深度（最大深度是指樹的根結點到最遠葉子結點的最長路徑上結點的數量）(程式碼在牛客網上通過)

力扣演算法：二叉樹的前序遍歷

原題連結：https://leetcode-cn.com/problems/binary-tree-preorder-traversal 原題： 給定一個二叉樹，返回它的前序遍歷。