二叉树

最新推荐文章于 2022-03-12 20:36:06 发布
原创最新推荐文章于 2022-03-12 20:36:06 发布 · 203 阅读
0 ·
CC 4.0 BY-SA版权
文章标签：
#二叉树
本文深入探讨了二叉树的各种操作，包括构建、遍历、查找、计算节点和叶子节点数量、获取树的高度及特定层级节点数等核心算法。通过具体实例展示了前序、中序和后序遍历的方法，并提供了计算二叉树属性的实用代码。
摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >
import java.awt.*;
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

import static jdk.nashorn.internal.objects.NativeMath.max;

public class BinaryTree {
    private static class Node {
        int val;
        Node root = null;
        Node left = null;
        Node right = null;

        private Node(char val) {
            this.val = val;
        }

        @Override
        public String toString() {
            return String.format("{%c}", val);
        }
    }

    public static Node buildTree() {
        Node a = new Node('A');
        Node b = new Node('B');
        Node c = new Node('C');
        
```Node d = new Node('D');
        Node e = new Node('E');
        Node f = new Node('F');
        Node g = new Node('G');
        Node h = new Node('H');
        a.left = b;
        a.right = c;
        b.left = d;
        b.right = e;
        c.left = f;
        c.right = g;
        e.right = h;
        return a;
    }
//前序遍历
    public static void preOrderTraversal(Node root) {
        //终止条件(在形参中去寻找)
        if (root == null) {
            return;
        }
        System.out.println(root);
        preOrderTraversal(root.left);
        preOrderTraversal(root.right);

    }
//中序遍历
    public static void inOrderTraversal(Node root) {
        if (root == null) {
            return;
        }

        preOrderTraversal(root.left);
        System.out.println(root);
        preOrderTraversal(root.right);
    }
//后序遍历
    public static void postOrderTraversal(Node root) {
        if (root == null) {
            return;
        }
        preOrderTraversal(root.left);
        preOrderTraversal(root.left);
        System.out.println(root);

    }

    //记录根节点的个数
    private static int count = 0;

    public static void getSize(Node root) {
        if (root == null) {
            return;
        }

        count++;//前序遍历根节点的个数
        getSize(root.left);
        getSize(root.right);
    }

    private static List<Character> inorderList = new ArrayList<>();

    private static void inorderReturnList(Node root) {
        if (root != null) {
            inorderReturnList(root.left);
            inorderList.add((char) root.val);
            inorderReturnList(root.right);
        }
    }

    private static List<Character> inorderReturnList2(Node root) {
        List<Character> list = new ArrayList<>();
        if (root == null) {
            return list;
        }
        list.addAll(inorderReturnList2(root.left));
        list.add((char) root.val);
        list.addAll(inorderReturnList2(root.right));
        return list;
    }


    //  整棵树的结果=汇总（左子树+右子树）
    public static int getSize2(Node root) {
        if (root == null) {
            return 0;
        }
        int left = getSize2(root.left);
        int right = getSize2(root.right);
        return left + right + 1;
    }

    //求叶子节点个数(遍历)
    private static int leafSize = 0;

    private static void getLeafSize(Node root) {
        if (root == null) {
            return;
        }
        if (root.left == null && root.right == null) {
            leafSize++;
        }
        getLeafSize(root.left);
        getLeafSize(root.right);
    }

    private static int getLeafSize2(Node root) {
        if (root == null) {
            return 0;
        }
        if (root.left == null && root.right == null) {
            return 1;
        }
        int left = getLeafSize2(root.left);
        int right = getLeafSize2(root.right);
        return left + right;
    }

    //最大高度
    private static int getHeight(Node root) {
        if (root == null) {
            return 0;
        }
        int left = getHeight(root.left);
        int right = getHeight(root.right);
        return Math.max(left, right) + 1;
    }

    //计算第K层的节点的个数
    private static int getKLevel(Node root, int k) {
        if (k < 1) {
            return 0;
        }
        if (k == 1) {
            return 1;
        }
        return getKLevel(root.left, k - 1) + getKLevel(root.right, k - 1);
    }


    private static Node find(Node root, int val) {
        if (root == null) {
            return null;
        }
        if (root.val == val) {
            return root;
        }
        Node n = find(root.left, val);
        if (n != null) {
            return n;
        }
        n = find(root.right, val);
        if (n != null) {
            return n;
        }
        return null;
    }

    public static boolean find2(Node root, int val) {
        if (root == null) {
            return false;
        }
        if (root.val == val) {
        }
        if (find2(root.left, val)) {
            return true;
        }

        return find2(root.right, val);
    }

    public static boolean find3(Node root, int val) {
        return root != null
                && (
                root.val == val
                        || find3(root.left, val)
                        || find3(root.right, val)
        );
    }


    //判断两个二叉树是否为同一颗树
    public boolean isSameTree(Node p, Node q) {
        if (p == null && q == null) {
            return true;
        }
        if (p != null && q != null && p.val == q.val) {
            return isSameTree(p.left, q.left) && isSameTree(p.right, q.right);
        } else {
            return false;
        }
    }
    public static void main(String[]args){
        Node root=buildTree();
        System.out.println("Success");
        preOrderTraversal(root);
        System.out.println("====================");
        inOrderTraversal(root);
        System.out.println("====================");
        postOrderTraversal(root);
        System.out.println("====================");
        count = 0;
        getSize(root);
        System.out.println("结点个数: " + count);
        System.out.println("结点个数: " + getSize2(root));

        System.out.println("====================");
        inorderList.clear();
        inorderReturnList(root);
        System.out.println(inorderList);
        System.out.println(inorderReturnList2(root));
        System.out.println("====================");
        leafSize = 0;
        getLeafSize(root);
        System.out.println("叶子结点个数： " + leafSize);
        System.out.println(getLeafSize2(root));
        System.out.println("====================");
        System.out.println(getHeight(root));
        System.out.println("====================");
        System.out.println(getKLevel(root, 1)); // 1
        System.out.println(getKLevel(root, 2)); // 2
        System.out.println(getKLevel(root, 3)); // 4
        System.out.println(getKLevel(root, 4)); // 1
        System.out.println(getKLevel(root, 5)); // 0
        Random random = new Random(20190917);
        for (int i = 0; i < 70; i++) {
            System.out.println(random.nextInt(70));
        }
    }
    }