java数据结构之二叉树（2）

最新推荐文章于 2024-05-30 19:34:38 发布
最新推荐文章于 2024-05-30 19:34:38 发布
阅读量120 收藏
点赞数 1
文章标签： 二叉树 数据结构 dfs 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1451516/article/details/115064113
版权

对称二叉树

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isSymmetric(TreeNode root) {
        if(root==null) return true;
        return dfs(root.left,root.right);

    }
    public boolean dfs(TreeNode right , TreeNode left){
        if(right==null && left!=null) return false;
        else if(right!=null && left==null) return false;
        else if(right.val!=left.val) return false;
        else if(right!=null && left!=null) return true;
		// 左节点的左孩子  和右节点的右孩子  是否相等
        boolean outside =dfs(left.left,right.right);
        // 左节点的右孩子 和右节点的左孩子  是否相等
        boolean inside = dfs(left.right,right.left);
        boolean is = outside&&inside;
        return is;
    }
}

二叉树的最大深度

在这里插入图片描述

递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {

        return dfs(root);
    }
    public int dfs(TreeNode root){
        if(root==null) return 0;
        Deque<TreeNode> stack = new LinkedList<>();
        int ld= dfs(root.right);
        int rd= dfs(root.left);
        int d = 1 +Math.max(ld,rd);
        return d;
    }
}
迭代
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int maxDepth(TreeNode root) {
        Deque<TreeNode> stack = new LinkedList<>();
        if(root==null) return 0;
        stack.add(root);
        int d = 0;
        while(!stack.isEmpty()){            
            int cur = stack.size();
            for(int i =0;i<cur;i++){
                TreeNode node = stack.pop();
                if(node.left!=null) stack.add(node.left);
                if(node.right!=null)stack.add(node.right);
            }
            d++;
        }
        return d;
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int minDepth(TreeNode root) {
        if(root==null) return 0;
        return mind(root);

    }
    public int mind(TreeNode node){
        if(node==null) return 0;
        int ld = mind(node.left);
        int rd = mind(node.right);
        if(node.left == null && node.right!=null){
            return rd+1;
        }
        if(node.left != null && node.right==null){
            return ld+1;
        }
        int s = 1+Math.min(ld,rd);
        return s;
    }
}

二叉树的所有路径

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> paths = new ArrayList<>();
        constructPatchs(root,"",paths);
        return paths;

    }
    public void constructPatchs(TreeNode root,String path,List<String> paths){
        if(root!=null){
            StringBuffer pathSB = new StringBuffer(path);
            pathSB.append(Integer.toString(root.val));
            if(root.left==null && root.right==null){ // 左右孩子都为空 说明当前结点已经是叶子结点了
                paths.add(pathSB.toString()); // 将当前路径放到答案里
            }else{
                pathSB.append("->");// 当前不是叶子结点
                constructPatchs(root.left,pathSB.toString(),paths);
                constructPatchs(root.right,pathSB.toString(),paths);
            }
        }
    }
}
//放心大胆的递归吧

广度优先搜索

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> res = new LinkedList<>();
        if(root==null) return res;

        Queue<TreeNode> stack = new LinkedList<>();
        Queue<String> paths = new LinkedList<>();
        stack.offer(root);
        paths.offer(Integer.toString(root.val));
        while(!stack.isEmpty()){
            TreeNode node = stack.poll();
            String path = paths.poll();
            if(node.left==null&&node.right==null){
                res.add(path);
            }else{
                if(node.left!=null){
                    stack.offer(node.left);
                    paths.offer(new StringBuffer(path).append("->").append(node.left.val).toString());
                }
                if(node.right!=null){
                    stack.offer(node.right);
                    paths.offer(new StringBuffer(path).append("->").append(node.right.val).toString());
                }
            }
        }
        return res;
    }
}
找树的左下角的值

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int findBottomLeftValue(TreeNode root) {
        dfs(root,0);
        return leftValue;// 首先 了解到我们要返回的是一个整形的 左下角的点的值。

    }

    int maxLength = -1;
    int leftValue;

    // 了解到 我们需要找到最后一层   然后找最后一层的最左边的结点
    public void dfs(TreeNode node , int curLength){
        if(node.left==null && node.right==null){//终止条件就是  左孩子 右孩子都为空 说明该结点是叶子结点。
            if(curLength>maxLength){  // 寻找到最大深度  最大深度就需要 中 左右 的遍历顺序  即 前序遍历
                maxLength = curLength;  // 如果当前深度比上一个深度深  可以赋值
                leftValue = node.val;
            }
            return ;
        }        
        if(node.left!=null){  // 左节点不为空向左递归 要先左 后右  这样可以优先赋值左节点 深度更新 右节点就跳过了
            curLength++;
            dfs(node.left,curLength);
            curLength--; // 要回朔
        }        
        if(node.right!=null){
            curLength++;
            dfs(node.right,curLength);
            curLength--;
        }
    }
}
迭代
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public int findBottomLeftValue(TreeNode root) {
        // 层序遍历大法 干干干
        if(root==null) return 0;
        Queue<TreeNode> stack = new LinkedList<>();
        stack.offer(root);
        int res=0;
        while(!stack.isEmpty()){
            int size = stack.size();
            for(int i = 0;i<size;i++){
                TreeNode node = stack.poll();
                if(i==0) res=node.val;
                if(node.left!=null) stack.offer(node.left);
                if(node.right!=null) stack.offer(node.right);
            }

        }
        return res;
    }
}
路径总和

在这里插入图片描述
唉 也放心了 也大胆了 就是缝缝补补 修改了半天
可怜啊~~~~~~~~~~~~~~~

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean hasPathSum(TreeNode root, int targetSum) {
        if(root==null) return false;
        return helper(root,targetSum-root.val);

    }
    // 放心大胆的递归
    public boolean helper(TreeNode node , int targetSum){
        if(node.left == null && node.right==null && targetSum==0) return true;
        if(node.left==null && node.right==null) return false;
        if(node.left!=null){
            targetSum = targetSum - node.left.val;
            if(helper(node.left,targetSum)) return true;
            targetSum+=node.left.val;
        }
        if(node.right!=null){
            targetSum = targetSum - node.right.val;
            if(helper(node.right,targetSum)) return true;
            targetSum+=node.right.val;
        }
        return false;
    }
}

构造二叉树

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        return helper(inorder,postorder);

    }
    public TreeNode helper(int[] inorder,int[] postorder){

        if(postorder.length==0) return null; // 如果后序数组大小为0 说明没有结点了

        int rootValue = postorder[postorder.length-1]; // 后序数组的最后一个数为当前树的根结点
        TreeNode root = new TreeNode(rootValue); //

        if(postorder.length==1) return root;

        int segementpoint; // 中序数组的分割点
        for(segementpoint = 0;segementpoint<inorder.length;segementpoint++){
            if(inorder[segementpoint]==rootValue) break;
        }
        //切割中序数组，得到中序左数组和中序右数组
        int[] leftInorder = Arrays.copyOfRange(inorder, 0,segementpoint);
        int[] rightInorder = Arrays.copyOfRange(inorder, segementpoint+1,inorder.length);

        //切割后序数组，得到后序左数组和后序右数组
        postorder=Arrays.copyOfRange(postorder,0,postorder.length-1); // 因为最后一个数字 作为分割结点所以 删除最后一个结点
        int[] leftPostorder=Arrays.copyOfRange(postorder, 0,leftInorder.length);
        int[] rightPostorder=Arrays.copyOfRange(postorder, leftInorder.length,postorder.length);

        root.left=helper(leftInorder,leftPostorder);
        root.right=helper(rightInorder,rightPostorder);
        return root;
    }
}

同样的原理，本方法不需要重复赋值数组，同时通过 map对根结点进行查找、节省了空间复杂度和时间复杂度

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */


class Solution {
    int post_idx;
    int[] postorder;
    int[] inorder;
    Map<Integer, Integer> idx_map = new HashMap<Integer, Integer>();

    public TreeNode helper(int in_left, int in_right) {
        // 如果这里没有节点构造二叉树了，就结束
        if (in_left > in_right) {
            return null;
        }

        // 选择 post_idx 位置的元素作为当前子树根节点
        int root_val = postorder[post_idx];
        TreeNode root = new TreeNode(root_val);

        // 根据 root 所在位置分成左右两棵子树
        int index = idx_map.get(root_val);

        // 下标减一
        post_idx--;
        // 构造右子树
        root.right = helper(index + 1, in_right);
        // 构造左子树
        root.left = helper(in_left, index - 1);
        return root;
    }

    public TreeNode buildTree(int[] inorder, int[] postorder) {
        this.postorder = postorder;
        this.inorder = inorder;
        // 从后序遍历的最后一个元素开始
        post_idx = postorder.length - 1;

        // 建立（元素，下标）键值对的哈希表
        int idx = 0;
        for (Integer val : inorder) {
            idx_map.put(val, idx++);
        }
        
        return helper(0, inorder.length - 1);
    }
}

前序中序构造二叉树

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    int root_index ;
    int[] preorder;
    int[] inorder;
    Map<Integer,Integer> map = new HashMap<>();
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        this.preorder=preorder;
        this.inorder=inorder;
        root_index = 0;
        int index = 0;
        for(int i:inorder){
            map.put(i,index++);
        }
        return helper(0,inorder.length-1);
        


    }
    // 左边界 与  右边界指的是       前序遍历中的!  前序遍历中的!  前序遍历中的! 对左右边界进行更新
    public TreeNode helper(int left_bord , int right_bord){
        if(left_bord>right_bord) return null;
        
        // 获得根结点
        int root_val=preorder[root_index];

        //在中序遍历中定位根结点
        int inorder_root = map.get(root_val);
        // 创建子树
        TreeNode root = new TreeNode(root_val);
        //根结点进行加一 可以获得左子树的根结点
        root_index++;

        //分割中序遍历
        int bord = map.get(root_val);
        // 在这里就是对左右边界进行了更新
        root.left=helper(left_bord,bord-1); // 左子树
        root.right=helper(bord+1,right_bord); // 右子树

        return root;
    }
}

最大二叉树

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode constructMaximumBinaryTree(int[] nums) {
        return helper(nums,0,nums.length);
    }

    //第一步找到数组中的最大值为根节点
    //第二步根结点左侧的最大值为左子树根结点
    //第三步根结点右侧的最大值为右子树的根结点

    //递归
    // 实际就是 确定最大值位置  然后左子树为左数组的最大值  右子树为右数组的最大值

    // 确定 输入的参数 以及 返回值类型
    // 确定递归终止条件
    // 确定逻辑语句

    public TreeNode helper(int[] nums,int l,int r){

        if(l==r) return null;

        int max_i = max(nums,l,r);

        TreeNode root = new TreeNode(nums[max_i]);

        root.left=helper(nums,l,max_i);
        root.right=helper(nums,max_i+1,r);

        return root;   

    }
    public int max(int[]nums,int l ,int r){
        int max_i = l;
        for(int i = l;i<r;i++){
            if(nums[max_i]<nums[i]){
                max_i=i;
            }
        }
        return max_i;
    }
}

合并二叉树

在这里插入图片描述

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode mergeTrees(TreeNode root1, TreeNode root2) {
        return helper(root1,root2);
    }
    //递归
    // 前序遍历
    //返回一个树  输入参数为两个树
    public TreeNode helper(TreeNode root1 , TreeNode root2){
        //递归终止条件
        if(root1==null&&root2==null) return null;
        if(root1==null) return root2;//如果root1为空 则返回root2 
        if(root2==null) return root1;
        // 逻辑语句
        root1.val+=root2.val;
        root1.left=helper(root1.left,root2.left);
        root1.right=helper(root1.right,root2.right);
        return root1;
        }
}

二叉搜索树中的搜素

在这里插入图片描述

递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        return helper(root,val);

    }
    public TreeNode helper(TreeNode root,int val){
        if(root==null||root.val==val) return root;

        if(root.val>val) return helper(root.left,val);
        if(root.val<val) return helper(root.right,val);
        return null;
    }
}
迭代
class Solution {
    public TreeNode searchBST(TreeNode root, int val) {
        while(root!=null){
            if(val>root.val){
                root=root.right;
            }else if(val<root.val){
                root=root.left;
            }else{
                return root;
            }
        }
        return null;
        // 如果val 大于当前值 则向右寻找  加入他的右孩子
    }
}

验证二叉搜索树

在这里插入图片描述

递归
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        return helper(root,Long.MIN_VALUE,Long.MAX_VALUE);
    }
    public boolean helper(TreeNode node ,long lower,long upper){
        if(node == null){
            return true;
        }
        if(node.val<=lower || node.val>=upper){
            return false;
        }      // 大于最小值 小于根结点               小于最大值 大于根结点  
        return helper(node.left,lower,node.val) && helper(node.right,node.val,upper);
    }
}
迭代
/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public boolean isValidBST(TreeNode root) {
        
        Deque<TreeNode> stack = new LinkedList<>();
        double inorder = -Double.MAX_VALUE;
        while(!stack.isEmpty() || root!=null){
            while(root!=null){
                stack.push(root);
                root=root.left;
            }
            root =stack.pop();
            if(root.val<=inorder){
                return false;
            }
            inorder = root.val;
            root=root.right;
        }
        return true;
    }

}
脱发小能手
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
数据结构之二叉树（JAVA实现）
weixin_38419670的博客
02-22 1877
1. 什么是二叉树 满足以下两个条件的树称之为二叉树： 1. 本质上为有序树； 2. 每个结点的度不能超过2，即结点的度仅能为0，1，2。 2. 二叉树的性质 性质1：二叉树第i层的结点数最多为2^(i-1) (i>=1)。 性质2：深度为k的二叉树最多有2^k - 1个结点。 性质3：在任意一颗二叉树中，若终端结点（叶子结点）的个数为n0，度为2的结点树为n2，则n0=n2+1。 证明：设二叉树中度为1的结点数为n1，结点总数为n，则n = n0 + n1 +n2。同时，度为2的子结
Java - 数据结构，二叉树
ryy1999的博客
03-01 786
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：1、有一个特殊的结点，称为根结点，根结点没有前驱结点除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合 Ti (1
java利用链表和二叉排序树实现 Map
weixin_45649686的博客
01-11 156
Map 特点：双列存储，键对应值，键不能重复，值可以重复，后面的键的值会将已经添加的键的值覆盖掉。 链表实现Map 1.实现链表代码 package com.ff.数据结构.mymap; public class LinkedArray<K,V> { //内部类 private class Node{ K key; V value; Node next; public Node(K key){
二叉排序树怎么构造java_学习记录11 --- 数据结构之二叉排序树的java实现
weixin_35901163的博客
02-28 181
通过java实现前，先搞懂二叉排序树的定义，其实定义很简单，要么是空树，要么就拥有以下特性：(1)若任意节点的左子树不空，则左子树上所有结点的值均小于它的根结点的值；(2) 若任意节点的右子树不空，则右子树上所有结点的值均大于它的根结点的值；(3) 任意节点的左、右子树也分别为二叉查找树；(4) 没有键值相等的节点。以及关于二叉树的遍历，有三种，分别为先序、中序和后序先序遍历：从根节点开始，先遍历...
Java数据结构之二叉树
fear_wolf的博客
10-25 2218
二叉树的创建很简单，但是难就难在操作上，我们为了简便，先自己手动创建一个简陋的二叉树的结构，着重介绍二叉树的操作，先创建一棵二叉树。我们有前面的概念可以看出，二叉树定义是递归式的，因此后序基本操作中基本都是按照递归实现的。完全二叉树：完全二叉树是效率很高的数据结构，完全二叉树是从满二叉树中引出来的，对于。的数据结构，它是由n（n >= 0）个有限节点组成的一个具有层次关系的集合，遍历是二叉树上最重要的操作之一，是二叉树进行其他运算的基础。称之为完全二叉树，由此可知，满二叉树是一种特殊的完全二叉树。
数据结构之二叉树（Java）
weixin_73060900的博客
05-31 1175
对树的概述以及对二叉树的详细讲解，不仅有前中后遍历的递归与非递归操作，更有二叉树的基本操作以及练习的一些oj题.
Java数据结构之二叉树的构建与遍历
shizhongruyi0606的博客
11-09 795
Java数据结构之二叉树的构建与遍历
数据结构 Java数据结构 --- 二叉树
wwzzzzzzzzzzzzz的博客
12-11 5078
二叉树 1. 树形结构 1.1 概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点： 有一个特殊的节点，称为根节点，根节点没有前驱节点 除根节点外，其余节点被分成M(M > 0)个互不相交的集合T1、T2、…Tm，其中每一个集合 Ti (1 <= i<= m) 又是一棵与树类似的子树。每棵子树的根节点有且只有一个前驱，可以有0个或多个后继 树是递归定义的。
Java数据结构实现二叉树
cccccccmmm的博客
08-10 1281
第一步：判断新结点中的元素是否小于当前结点对象，如果小于那么新结点则放到当前结点的左边，那放到左边我们又要判断了，如果当前结点有左子树了那我们又得判断新结点的元素是否小于当前结点的左子树，如果小于又放到当前结点的左子树的左子树上，反之则放到当前结点的左子树的右子树上，如果当前结点的左子树的左子树上又有结点，然后又要判断......我们就用节点Node来表示，那么节点类的实现我们刚刚看过二叉树的图了，二叉树节点的元素分为：左子树、元素、右子树，所以我们需要有三个成员变量，分别存放左子树、元素以及右子树。...
Java数据结构————二叉树
爱敲代码的三毛的博客
08-20 980
文章目录一、树型结构（了解）1.概念2. 树与非树3. 树的一些重要的概念4. 树的表示形式（了解）5. 树的一些应用二、二叉树1.二叉树的概念2.二叉树的基本形态3.两种特殊的二叉树4. 二叉树的性质5. 二叉树的存储三、二叉树的基本操作1.二叉树的遍历2.前序遍历3. 中序遍历4. 后序遍历5. 求结点个数6.求叶子结点个数7. 求第 k 层结点个数8.获取二叉树的高度9. 查找 val 所在结点10. 层序遍历11. 判断一棵树是不是完全二叉树完！ 要想了解二叉树先要知道什么是树 一、树型结构（..
java版数据结构的 算术表达式与二叉树源码
06-08
Java版的源码，可应用于数据结构的课程设计，非常完美的源码
数据结构-二叉树 JAVA语言实现
10-16
使用教程：http://blog.csdn.net/z740852294/article/details/78250911
【java 数据结构】还不会二叉树？一篇搞定二叉树
12-21
二叉树是我们常见的数据结构之一，在学习二叉树之前我们需要知道什么是树，什么是二叉树，本篇主要讲述了二叉树，以及二叉树的遍历。 你能get到的知识点？ 1、树的介绍 2、二叉树的介绍 3、二叉树遍历的四种方法 4、...
数据结构-二叉树（Java实现）
11-27
编程实现如下功能： 1、假设二叉树的结点值是字符...2、对二叉树进行先根、中根和后根遍历操作，并输出遍历序列，同时观察输出序列是否与逻辑上的序列一致。 3、统计二叉树的结点个数和叶子结点个数，并分别输出其值。
java 数据结构二叉树的实现代码
09-01
主要介绍了java 数据结构二叉树的实现代码的相关资料,需要的朋友可以参考下
10种排序算法总结-（c语言实现与动画演示）
qq_37040743的博客
05-29 480
十种常见排序算法可以分为：通过比较来决定元素间的相对次序，由于其时间复杂度不能突破，因此也称为非线性时间比较类排序。：不通过比较来决定元素间的相对次序，它可以突破基于比较排序的时间下界，以线性时间运行，因此也称为线性时间非比较类排序。：如果a原本在b前面，而a=b，排序之后a仍然在b的前面。：如果a原本在b的前面，而a=b，排序之后 a 可能会出现在 b 的后面。
二叉树的顺序结构及实现（堆的实现）
最新发布
2301_81154519的博客
05-30 1040
介绍了堆并且用代码去实现堆
【初阶数据结构】栈和队列（附题目）
2401_82610555的博客
05-30 1086
栈的初始化中，需要注意的是_top的初始值初始化为-1与初始化为0是截然不同的。我们知道，head是指向队列的头，tail指向尾的下一位，因为我们多开了一个空间，并且是按序的空出空间，因此，当数组满时，尾的空间后面就是空空间，tail指向它，这时如果tail再向前走一步，就与head相等，不过这时，为了避免出现越界的情况，tail+1需要%（K+1），这就相当于tail+1>5时，tail+1-5，tail回到数组开头，同时数组越界的情况是相对与数组总长的，因此这里是%（k+1）不是%k.
【数据结构】二叉树的实现
小八哥
05-30 1163
关于二叉树，你真的了解的吗？
java数据结构二叉树
01-05
二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点：左子节点和右子节点。以下是一个简单的Java实现二叉树的例子： ```java // 定义二叉树节点类 class TreeNode { int val; TreeNode left; ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值