二叉树

本文深入探讨了二叉树的各种操作,包括构建、遍历、查找、计算节点和叶子节点数量、获取树的高度及特定层级节点数等核心算法。通过具体实例展示了前序、中序和后序遍历的方法,并提供了计算二叉树属性的实用代码。

摘要生成于 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));
        }
    }
    }

内容概要:本文详细介绍了900W或1Kw,20V-90V 10A双管正激可调电源充电机的研发过程和技术细节。首先阐述了项目背景,强调了充电机在电动汽车和可再生能源领域的重要地位。接着深入探讨了硬件设计方面,包括PCB设计、磁性器件的选择及其对高功率因数的影响。随后介绍了软件实现,特别是程序代码中关键的保护功能如过流保护的具体实现方法。此外,文中还提到了充电机所具备的各种保护机制,如短路保护、欠压保护、电池反接保护、过流保护和过温度保护,确保设备的安全性和可靠性。通讯功能方面,支持RS232隔离通讯,采用自定义协议实现远程监控和控制。最后讨论了散热设计的重要性,以及为满足量产需求所做的准备工作,包括提供详细的PCB图、程序代码、BOM清单、磁性器件和散热片规格书等源文件。 适合人群:从事电力电子产品研发的技术人员,尤其是关注电动汽车充电解决方案的专业人士。 使用场景及目标:适用于需要高效、可靠充电解决方案的企业和个人开发者,旨在帮助他们快速理解和应用双管正激充电机的设计理念和技术要点,从而加速产品开发进程。 其他说明:本文不仅涵盖了理论知识,还包括具体的工程实践案例,对于想要深入了解充电机内部构造和工作原理的人来说是非常有价值的参考资料。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值