精华内容
下载资源
问答
  • java 二叉树

    2017-06-22 21:28:49
    java 二叉树 leetcode(一)首先来看看 java 生成二叉树 直接上代码 生成二叉树步骤 创建二叉树节点对象 创建存储所有二叉树节点的集合 list 使用LinkedList是因为这是链表数组结构 add 和 remove 操作比arrayList ...

    java 二叉树 leetcode(一)

    首先来看看 java 生成二叉树
    直接上代码
    生成二叉树步骤

    1. 创建二叉树节点对象
    2. 创建存储所有二叉树节点的集合 list 使用LinkedList是因为这是链表数组结构 add 和 remove 操作比arrayList 更快。
    3. 将数组元素转换为 树的节点
    4. 根据 规则生成自己的二叉树 (这里生成的是完全二叉树)
    public class mergeTree {
    
        public static class  TreeNode{
            int val;
            TreeNode left;
            TreeNode right;
    
            TreeNode(int x){
                val = x;
                left = null;
                right = null;
            }
        }
        private static List<TreeNode> nodeList = null;
    
        public static void main(String arg[]){
            int[] arr = {1,2,3,4,5,6,7};
            nodeList = new LinkedList<TreeNode>();
    
            //先把 数组转换为 节点
            for (int i=0;i<arr.length;i++){
                nodeList.add(new TreeNode(arr[i]));
            }
            //然后 将 1 作为根节点 (构造最简单的完全二叉树)
            // 最后一位 必须单独处理 因为可以有两种情况
            // 这种方式 是一个二叉树一个二叉树的遍历
            for(int i=0;i<arr.length/2 -1;i++){
                nodeList.get(i).left = nodeList.get(i*2 + 1);
                nodeList.get(i).right = nodeList.get(i*2 + 2);
            }
    
            //判断 节点个数是否为 奇数个
            if(arr.length%2 ==1){
                int i =arr.length /2 -1;
                nodeList.get(i).left = nodeList.get(i*2 + 1);
                nodeList.get(i).right = nodeList.get(i*2 + 2);
            }else{
                //判断 节点个数为 偶数个 该节点没有右子树
                int i =arr.length /2 -1;
                nodeList.get(i).left = nodeList.get(i*2 + 1);
            }
    
            //先按照先序 输出 生成的二叉树
            preNode(nodeList.get(0));
    
            System.out.println("\n");
            //一道 关于 二叉树的 题
            TreeNode d = mergeTree(nodeList.get(0),nodeList.get(1));
            preNode(d);
        }
    
        /**
         * 遍历两个二叉树 并相加对应节点的值 赋给t1二叉树
         * @param t1
         * @param t2
         * @return
         */
        public static TreeNode mergeTree(TreeNode t1 , TreeNode t2){
    
            // 判断如果某一个对应节点为空 就返回另一个不为空的节点
            if(t1 == null){
                return t2;
            }
            if(t2 == null){
                return t1;
            }
            t1.val +=t2.val;
            t1.left = mergeTree(t1.left,t2.left);
            t1.right = mergeTree(t1.right,t2.right);
            return t1;
        }
    
        /**
         * 先序遍历 二叉树
         * @param treeNode
         */
        public static void preNode(TreeNode treeNode){
            if(treeNode == null){
                return ;
            }
            System.out.print(treeNode.val +" ");
            preNode(treeNode.left);
            preNode(treeNode.right);
        }
    }

    关于上图中生成完全二叉树 的 最后一个节点必须单独来判断 ,是因为有两种不同的情况
    这里写图片描述

    展开全文
  • Java二叉树

    2017-02-24 20:09:10
    Java二叉树前序遍历方式为:根节点->左子树->右子树中序遍历方式为:左子树->根节点->右子树后序遍历方式为:左子树->右子树->根节点1.二叉树的遍历 先访问根节点,在访问左子树,最后访问右子树该博客已对此问题...

    Java二叉树


    前序遍历方式为:根节点->左子树->右子树

    中序遍历方式为:左子树->根节点->右子树

    后序遍历方式为:左子树->右子树->根节点

    1.二叉树的遍历
    先访问根节点,在访问左子树,最后访问右子树

    这里写图片描述

    该博客已对此问题描述比较清楚根据前序,中序构造二叉树
    以下内容为代码实现过程中的总结

    public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
    }

    在写该算法之前可以通过一个例子引导,同时不去考虑边界情况(在这里就是递归停止的情况),这样可以集中精力放在算法过程中

    1. 在前序遍历中选择第一个节点也就是整颗二叉树的根节点,同时在中序遍历中找到该节点
    int root=pre[0];
    TreeNode rootNode=new TreeNode(pre[0]);

    2.中序遍历中该节点左侧便是整个根节点的左子树部分,中序遍历该节点的右侧便是根节点的右子树部分
    这里写图片描述

    3.此时求出中序遍历中节点左侧长度,以及节点右侧长度,从而构造出下一轮中 int[]pre,以及int[]in

    int leftLength=index;
            int rightLength=in.length-index-1;
            int[] preNow=Arrays.copyOfRange(pre, 1, 1+leftLength);
            int[] inNow=Arrays.copyOfRange(in, 0, index);
            rootNode.left=reConstructBinaryTree(preNow, inNow);
            int[]preNowRight=Arrays.copyOfRange(pre, leftLength+1, pre.length);
            int[]inNowRight=Arrays.copyOfRange(in, index+1,in.length);
            rootNode.right=reConstructBinaryTree(preNowRight, inNowRight);

    4.此时我们注意到,有可能左子树,或者右子树不存在,什么时候不存在呢,即如果前序遍历第一个元素在中序遍历中也是第一个,则其不存在左子树,如果其为中序遍历的最后一个则其不存在右子树,如果前序遍历和中序遍历中只存在一个元则左右子树均不存在,因此这也就是递归的结束条件。代码如下:

     public TreeNode reConstructBinaryTree(int [] pre,int [] in) {
            int root=pre[0];
            TreeNode rootNode=new TreeNode(pre[0]);
            int index=0;
            for(int i=0;i<in.length;i++){
                if(in[i]==root){
                    index=i;
                }
            }
    
            if(index==0&&pre.length==1){
                rootNode.left=null;
                rootNode.right=null;
            }
            else if(index==0&&pre.length!=1){
             rootNode.left=null;
             int[]preNowRight=Arrays.copyOfRange(pre, index+1, pre.length);
             int[]inNowRight=Arrays.copyOfRange(in, index+1,in.length);
             rootNode.right=reConstructBinaryTree(preNowRight, inNowRight);
            }
            else if(index==in.length-1){
                int leftLength=index;
                int rightLength=in.length-index-1;
                int[] preNow=Arrays.copyOfRange(pre, 1, 1+leftLength);
                int[] inNow=Arrays.copyOfRange(in, 0, index);
                rootNode.left=reConstructBinaryTree(preNow, inNow);
                rootNode.right=null;
            }
    
            else{
            int leftLength=index;
            int rightLength=in.length-index-1;
            int[] preNow=Arrays.copyOfRange(pre, 1, 1+leftLength);
            int[] inNow=Arrays.copyOfRange(in, 0, index);
            rootNode.left=reConstructBinaryTree(preNow, inNow);
            int[]preNowRight=Arrays.copyOfRange(pre, leftLength+1, pre.length);
            int[]inNowRight=Arrays.copyOfRange(in, index+1,in.length);
            rootNode.right=reConstructBinaryTree(preNowRight, inNowRight);
            }
            return rootNode;
    
        }
    展开全文
  • java二叉树是非常重要的,它相关的每一个知识点,java人员都要熟练的运用,这是作为Java人员的基本素质,那么java二叉树怎么转成数组?下面我们就来讲解一下。将一个数组转换成一个二叉树的java实现,如下:importorg...

    java二叉树是非常重要的,它相关的每一个知识点,java人员都要熟练的运用,这是作为Java人员的基本素质,那么java二叉树怎么转成数组?下面我们就来讲解一下。

    将一个数组转换成一个二叉树的java实现,如下:import org.junit.Test;

    import java.util.ArrayList;

    import java.util.List;

    /**

    * 二叉树的生成

    *

    * @author DangerShi

    */

    public class TreeBuilder

    {

    class TreeNode

    {

    Object data;

    TreeNode left;

    TreeNode right;

    public TreeNode()

    {}

    public TreeNode(Object data, TreeNode left, TreeNode right)

    {

    this.data = data;

    this.left = left;

    this.right = right;

    }

    }

    public TreeNode arrayToBTree(Object[] arrs)

    {

    if (arrs == null || arrs.length == 0)

    {

    return new TreeNode();

    }

    List nodes = new ArrayList  (arrs.length);

    for (Object obj: arrs)

    {

    TreeNode treeNode = new TreeNode();

    treeNode.data = obj;

    nodes.add(treeNode);

    }

    for (int i = 0; i 

    {

    TreeNode node = nodes.get(i);

    node.left = nodes.get(i * 2 + 1);

    node.right = nodes.get(i * 2 + 2);

    }

    // 只有当总节点数是奇数时,最后一个父节点才有右子节点

    int lastPNodeIndex = arrs.length / 2 - 1;

    TreeNode lastPNode = nodes.get(lastPNodeIndex);

    lastPNode.left = nodes.get(lastPNodeIndex * 2 + 1);

    if (arrs.length % 2 != 0)

    {

    lastPNode.right = nodes.get(lastPNodeIndex * 2 + 2);

    }

    return nodes.get(0);

    }

    @Test

    public void test()

    {

    /**

    * 1

    * 2 3

    * 4 5 6 7

    */

    TreeNode treeNode = arrayToBTree(new Object[]

    { 1, 2 , 3, 4, 5, 6, 7});

    }

    }

    java怎么实现二叉树?

    二叉树是一个递归的数据结构,每个节点最多有两个子节点。

    通常二叉树是二分查找树,每个节点它的值大于或者等于在它左子树节点上的值,小于或者等于在它右子树节点上的值。如下图

    a994ac44e67682b33c972f3e171b625b.png

    为了实现二叉树,我们使用一个Node类来表示节点,节点存储int类型的值,还有对子节点的引用。package com.java.node.BinaryTree;

    public class Node

    {

    int data;

    Node left;

    Node right;

    public Node(int data)

    {

    this.data = data;

    this.left = null;

    this.right = null;

    }

    }

    然后添加树的root节点package com.java.node.BinaryTree;

    public class BinaryTree

    {

    Node root;

    }

    通常的操作

    添加节点

    首先我们必须找到新节点的位置,是为了保持树排序。我们必须从root节点开始,必须遵循下面的规则:

    如果新节点小于当前的值,我们将会进入左子树。

    如果新节点大于当前的节点。我们将会进入右子树。

    当当前的节点是null时,我们已经到达叶子节点,我们可以添加新节点到这个位置。

    我们将会创建递归方法做添加节点操作private Node addNode(Node current, int value)

    {

    if (current == null)

    {

    return new Node(value);

    }

    if (value 

    {

    current.left = addNode(current.left, value);

    }

    else if (value > current.data)

    {

    current.right = addNode(current.right, value);

    }

    else

    {

    return current;

    }

    return current;

    }

    public void addNode(int value)

    {

    root = addNode(root, value);

    }

    可以使用方法创建一个二叉树了public BinaryTree createBinaryTree()

    {

    BinaryTree bt = new BinaryTree();

    bt.addNode(6);

    bt.addNode(4);

    bt.addNode(8);

    bt.addNode(10);

    return bt;

    }

    查找一个节点private boolean containNode(Node current, int value)

    {

    if (current == null)

    {

    return false;

    }

    if (value == current.data)

    {

    return true;

    }

    return value 

    }

    public boolean containNode(int value)

    {

    return containNode(root, value);

    }

    删除一个节点private Node deleteNode(Node current, int value)

    {

    if (current == null)

    {

    return null;

    }

    if (value == current.data)

    {

    if (current.left == null && current.right == null)

    {

    return null;

    }

    if (current.left == null)

    {

    return current.right;

    }

    if (current.right == null)

    {

    return current.left;

    }

    int smallestValue = findSmallestValue(current.right);

    current.data = smallestValue;

    current.right = deleteNode(current.right, smallestValue);

    return current;

    }

    if (value 

    {

    current.left = deleteNode(current.left, value);

    return current;

    }

    current.right = deleteNode(current.right, value);

    return current;

    }

    private int findSmallestValue(Node root)

    {

    return root.left == null ? root.data : findSmallestValue(root.right);

    }

    从文章中,我们可以看出java二叉树的知识还是非常重要的,有难点也有易点,要想熟练运用,还是要下功夫才行哦!最后大家如果想要了解更多java常见问题知识,敬请关注奇Q工具网。

    推荐阅读:

    展开全文
  • java二叉树是java知识点中最重要的,每一个java人员都要熟练掌握java二叉树知识,那么java二叉树如何遍历?接下来,我们就来给大家讲解一下这方面的内容。大家可以参考以下内容。前序遍历:先访问根结点,再访问左子...

    java二叉树是java知识点中最重要的,每一个java人员都要熟练掌握java二叉树知识,那么java二叉树如何遍历?接下来,我们就来给大家讲解一下这方面的内容。大家可以参考以下内容。

    前序遍历:先访问根结点,再访问左子结点,最后访问右子结点。图中的二叉树的前序遍历的顺序是10、6、4、8、14、12、16。

    中序遍历:先访问左子结点,再访问根结点,最后访问右子结点。图中的二叉树的中序遍历的顺序是4、6、8、10、12、14、16。

    后序遍历:先访问左子结点,再访问右子结点,最后访问根结点。图中的二叉树的后序遍历的顺序是4、8、6、12、16、14、10。

    e0b1c9cb6478cc1856a81a3f58509c21.png

    宽度优先遍历:先访问树的第一层结点,再访问树的第二层结点……一直到访问到最下面一层结点。在同一层结点中,以从左到右的顺序依次访问。我们可以对包括二叉树在内的所有树进行宽度

    优先遍历。图中的二叉树的宽度优先遍历的顺序是10、6、14、4、8、12、16。

    构造一颗如下图所示的二叉树,用java实现其前序,中序,后序遍历

    137fe3b22462d346b1ce989481b70d39.png

    注意二叉树节点的定义如下:public class TreeNode

    {

    int val;

    TreeNode left;

    TreeNode right;

    TreeNode(int x)

    {

    val = x;

    }

    }

    递归实现:// 用递归的方法进行先序遍历

    public void qinaxuDigui(TreeNode treeNode)

    {

    qianxuNumList.add(treeNode.val);

    if (treeNode.left != null)

    {

    qinaxuDigui(treeNode.left);

    }

    if (treeNode.right != null)

    {

    qinaxuDigui(treeNode.right);

    }

    }

    // 用递归的方法进行中序遍历

    public void zhongxuDigui(TreeNode treeNode)

    {

    if (treeNode.left != null)

    {

    zhongxuDigui(treeNode.left);

    }

    zhongxuNumList.add(treeNode.val);

    if (treeNode.right != null)

    {

    zhongxuDigui(treeNode.right);

    }

    }

    // 用递归的方法进行后序遍历

    public void houxuDigui(TreeNode treeNode)

    {

    if (treeNode.left != null)

    {

    houxuDigui(treeNode.left);

    }

    if (treeNode.right != null)

    {

    houxuDigui(treeNode.right);

    }

    houxuNumList.add(treeNode.val);

    }

    非递归实现:// 用非递归的方法进行先序遍历

    public void qinaxuFeiDigui(TreeNode treeNode)

    {

    Stackstack = new Stack();

    while (treeNode != null || !stack.isEmpty())

    {

    while (treeNode != null)

    {

    qianxuNumList.add(treeNode.val);

    stack.push(treeNode);

    treeNode = treeNode.left;

    }

    if (!stack.isEmpty())

    {

    treeNode = stack.pop();

    treeNode = treeNode.right;

    }

    }

    }

    // 用非递归的方法进行中序遍历

    public void zhongxuFeiDigui(TreeNode treeNode)

    {

    Stackstack = new Stack();

    while (treeNode != null || !stack.isEmpty())

    {

    while (treeNode != null)

    {

    stack.push(treeNode);

    treeNode = treeNode.left;

    }

    if (!stack.isEmpty())

    {

    treeNode = stack.pop();

    zhongxuNumList.add(treeNode.val);

    treeNode = treeNode.right;

    }

    }

    }

    // 用非递归的方法进行后序遍历

    public void houxuFeiDigui(TreeNode treeNode)

    {

    Stackstack = new Stack();

    while (treeNode != null || !stack.isEmpty())

    {

    while (treeNode != null)

    {

    stack.push(treeNode);

    treeNode = treeNode.left;

    }

    boolean tag = true;

    TreeNode preNode = null; // 前驱节点

    while (!stack.isEmpty() && tag == true)

    {

    treeNode = stack.peek();

    if (treeNode.right == preNode)

    { // 之前访问的为空节点或是栈顶节点的右子节点

    treeNode = stack.pop();

    houxuNumList.add(treeNode.val);

    if (stack.isEmpty())

    {

    return;

    }

    else

    {

    preNode = treeNode;

    }

    }

    else

    {

    treeNode = treeNode.right;

    tag = false;

    }

    }

    }

    }

    运行结果如下:

    efa83ae480dd0f8038247b9b0528fcd5.png

    这些就是java二叉树遍历的实例,我们可以看出,其实java二叉树的知识最重要的就是逻辑思维,只要将思维理清了,java二叉树的知识也就不难了,最后大家如果想要了解更多java常见问题知识,敬请关注奇Q工具网。

    推荐阅读:

    展开全文
  • 下面要给大家分享的java实例是和java二叉树层次遍历相关的内容,一起来了解一下这个实例吧!从上往下打印出二叉树的每个节点,同层节点从左至右打印。代码实现:importjava.util.ArrayList;importjava.util....
  • java二叉树

    2011-08-18 19:56:40
    如果树的每个节点至多有两个后代,那么就成为二叉树。  二叉树有很多种,接触比较多的有两种。  1,完全二叉树——树的每个结点都只有2个后代  2,满二叉树——除了叶结点外每一个结点都有左右子叶且叶结点都...
  • java二叉树和叶子节点的实现发布时间:2020-05-28 09:52:40来源:亿速云阅读:202作者:Leah今天小编就为大家带来一篇有关实现java二叉树和叶子节点的文章。小编觉得挺实用的,为此分享给大家做个参考。一起跟随小编...
  • Java 二叉树层次遍历

    2020-06-06 16:28:41
    Java 二叉树层次遍历
  • 主要介绍了Java二叉树路径和代码示例,具有一定借鉴价值,需要的朋友可以参考下。
  • java二叉树创建

    2019-09-24 13:18:51
    最近在刷剑指offer,里面提到二叉树,一直以来用java的多,所以编写了一个java二叉树结构和工具类。工具类包括创建,遍历等方法。定期更新。 关于输入,假如我的二叉树结构为,则输入的数据为1 2 0 0 3 0 0 。如果...
  • java 二叉树新增删除

    2012-09-17 15:10:47
    二叉树是每个结点最多有两个子树的有序树。java 二叉树新增删除,遍历二叉树
  • 二叉树的非递归遍历二叉树的非递归遍历java的非递归后续遍历文章yichudu2014-04-04791浏览量Java工程师必知词汇:二叉树|名词定义|二叉树(Binary tree)是每个节点最多只有两个分支(即不存在分支度大于2的节点)的树...
  • 二叉树的最大深度Given a binary tree, find its maximum depth.The maximum depth is the number of nodes along the longest path from the root node down to the farthest leaf node.Note:A leaf is a node with...
  • java 二叉树详解 + 实现代码

    千次阅读 2020-04-29 10:21:56
    java二叉树的每个根节点最多有两颗字数,不存在子树大于2的节点,也就是说,二叉树是节点的最大度数为2的树,通常子树分为左子树和右子树,次序不能颠倒。 创建二叉树: public void createTree(Object[] objs) {...
  • JAVA二叉树横向打印

    2009-11-06 11:23:56
    JAVA二叉树横向打印,利用二叉树节点类来完成二叉树的打印。
  • java 二叉树遍历

    2018-11-14 22:26:40
    使用java语言,对数据结构中的二叉树进行遍历,包含算法逻辑。
  • 今天小编就为大家分享一篇关于Java二叉树的遍历思想及核心代码实现,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 二叉树的深度优先遍历,可以使用栈,因为栈有后进先出的特性,二叉树的广度优先遍历,可以使用队列来实现。package sjjg;import java.util.ArrayDeque;import java.util.Deque;import java.util.Stack;public class ...
  • java二叉树与递归算法

    2019-07-03 05:20:29
    java二叉树与递归算法 public class Solution { // Definition for a binary tree node. public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) ...
  • 之前也讲了很多关于二叉树的知识,不知道大家是否知道使用二叉树的作用在哪里?为什么要使用二叉树呢?在平常我们在哪些情景下使用二叉树呢?接下来跟着小编的步伐一起来了解下吧。在实际操作的过程中,我们会根据链表...
  • java二叉树的实现

    千次阅读 2015-11-07 19:32:49
    java二叉树的实现 树在编程问题中有着很广泛的应用,而二叉树又是其中出现频次较高的一种(可以很方便的将普通的树转化为二叉树)。本文从无到有的实现了二叉树,如果对树的基础概念不太了解可以先看一下概念。 ...
  • java二叉树的遍历算法

    2016-10-19 14:57:42
    原文地址:java二叉树的遍历算法作者:听雨泽今天练习用java实现二叉树的遍历算法,首先我先编写二叉树类BinaryTree,代码如下: package package2; public class BinaryTree {    int data; //根节点数据  ...
  • Java集合框架 二叉树示例 1 : 二叉树概念二叉树由各种节点组成 二叉树特点: 每个节点都可以有左子节点,右子节点 每一个节点都有一个值 package 示例 2 : 二叉树排序-插入数据假设通过二叉树对如下10个随机数进行...
  • Java二叉树的实现

    2011-03-16 10:03:00
    Java二叉树的实现
  • Java 二叉树前序遍历(递归/非递归)
  • java二叉树遍历

    千次阅读 2019-02-25 16:17:23
    数据结构主要是数据以及数据与数据之间的关系。二叉树这种数据结构的数据:就是节点里面存放的值,数据与数据之间的关系就是:一个节点最多有2个子节点。...import java.util.Stack; public class Bin...
  • java二叉树的创建

    2020-11-26 19:51:13
    二叉树的创建一、二叉树二、二叉树的创建 ...使用创建Java创建二叉树时,创建二叉树节点,通过节点递归生成二叉树 源码 创建节点 package tree; public class NodeTree { //定义数据域 int data; /

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 23,145
精华内容 9,258
热门标签
关键字:

java二叉树

java 订阅