二叉树

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

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

资源下载链接为: https://pan.quark.cn/s/9e7ef05254f8 在苹果的生态系统中,IAP(应用内购买)是苹果应用商店(App Store)中应用开发者常采用的一种盈利模式,允许用户在应用内直接购买虚拟商品或服务。苹果为开发者提供了一份详细的人民币(CNY)IAP定价表,这份定价表具有以下特点: 价格分级:定价表由多个价格等级组成,开发者可根据虚拟商品的价值选择相应等级,等级越高,价格越高。例如,低等级可能对应基础功能解锁,高等级则对应高级服务或大量虚拟道具。 税收与分成:苹果会从应用内购买金额中抽取30%作为服务费或佣金,这是苹果生态的固定规则。不过,开发者实际到手的收入会因不同国家和地区的税收政策而有所变化,但定价表中的价格等级本身是固定的,便于开发者统一管理。 多级定价策略:通过设置不同价格等级,开发者可以根据商品或服务的类型与价值进行合理定价,以满足不同消费能力的用户需求,从而最大化应用的总收入。例如,一款游戏可以通过设置不同等级的虚拟货币包,吸引不同付费意愿的玩家。 特殊等级:除了标准等级外,定价表还包含备用等级和特殊等级(如备用等级A、备用等级B等),这些等级可能是为应对特殊情况或促销活动而设置的额外价格点,为开发者提供了更灵活的定价选择。 苹果IAP定价表是开发者设计应用内购机制的重要参考。它不仅为开发者提供了标准的收入分成模型,还允许开发者根据产品特性设定价格等级,以适应市场和满足不同用户需求。同时,开发者在使用定价表时,还需严格遵守苹果的《App Store审查指南》,包括30%的分成政策、使用苹果支付接口、提供清晰的产品描述和定价信息等。苹果对应用内交易有严格规定,以确保交易的透明性和安全性。总之,苹果IAP定价表是开发者在应用内购设计中不可或缺的工具,但开发者也需密切关注苹果政策变化,以确保应用的合规运营和收益最大化。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值