Java数据结构之二叉树—模拟实现＋OJ练习

已于 2024-04-29 13:16:17 修改
阅读量839 收藏 7
点赞数 22
分类专栏： Java数据结构基础+总结 文章标签： 数据结构
于 2024-04-22 22:25:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_78838401/article/details/138072763
版权

 模拟实现：

首先创建一个树：

由于每一个TreeNode都是一个结点，所以创建为内部类；

public class BinaryTree {
    static class TreeNode{
        public char val;
        public TreeNode left;
        public TreeNode right;

        public TreeNode(char val) {
            this.val = val;
        }
    }
    public TreeNode creatTree(){
        TreeNode A = new TreeNode('A');
        TreeNode B = new TreeNode('B');
        TreeNode C = new TreeNode('C');
        TreeNode D = new TreeNode('D');
        TreeNode E = new TreeNode('E');
        TreeNode F = new TreeNode('F');
        TreeNode G = new TreeNode('G');
        TreeNode H = new TreeNode('H');
        A.left = B;
        A.right = C;
        B.left = D;
        B.right = E;
        E.right = H;
        C.left = F;
        C.right = G;
        return A;
    }
}

不管是哪种方法遍历，可以想象在最后一个结点的时候代码会打印哪个字母，并且return后打印哪个，这样想思考的更清楚

每种方法都要画图

前序遍历：

   // 前序遍历
    void preOrder(TreeNode root){
        if (root == null){
            return;
        }
        System.out.println(root.val);
        postOrder(root.left);
        postOrder(root.right);
        return;
    }

中序遍历：

    // 中序遍历
    void inOrder(TreeNode root){
        if (root == null){
            return;
        }
        postOrder(root.left);
        System.out.println(root.val);
        postOrder(root.right);
        return;
    }

后序遍历：

    // 后序遍历
    void postOrder(TreeNode root){
        if (root == null){
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.println(root.val);
        return;
    }

二叉树的基本操作：

获取树中结点个数：

 关键在于只要不是空就++

第一种解法：

    public int nodeSize;
    int size(TreeNode root){
        if(root == null){
            return 0;
        }
        //关键：只要不是空就++
        nodeSize++;
        size(root.left);
        size(root.right);

        return nodeSize;
    }

 子问题解法：

树的结点个数 = 左子树的结点个数 + 右子树的结点个数 + 1；

当拿只有三个结点的二叉树去理解很清楚，当结点很多，同样适用：

  int size(TreeNode root){
        if(root == null){
            return 0;
        }
        //子问题
        return  size(root.left)+
        size(root.right)+1;
    }

 获取叶子结点的个数：

遍历思路：

 按照某种遍历方式（四种遍历方法），遍历到某个结点判断式是叶子结点，计数器++

  public int leafNodeCount;
    int getLeafNodeCount(TreeNode root){
        if(root == null){
            return 0;
        }
        if(root.left == null&&root.right == null){
            leafNodeCount++;
        }
        getLeafNodeCount(root.left);

        getLeafNodeCount(root.right);

        return leafNodeCount;

    }

 子问题解法：

叶子个数 = 左子树子叶个数 + 右子树子叶个数

  int getLeafNodeCount(TreeNode root){
        if(root == null){
            return 0;
        }
        if(root.left == null&&root.right == null){
            return 1;
        }
        return getLeafNodeCount(root.left)+
                getLeafNodeCount(root.right);
    }

获取第K层结点的个数：

子问题方法：

整棵树的第K层节点个数 = 左子树第 K -1 层结点个数 + 右子树第 K - 1 层结点个数 



   int getKLevelNodeCount(TreeNode root,int k){
        if(root == null){
            return 0;
        }
        if(k == 1){
            return 1;
        }
        return getKLevelNodeCount(root.left,k-1)
                + getKLevelNodeCount(root.right, k-1);
    }

 获取二叉树的高度：

 二叉树的高度 = 左子树的高度 和 右子树高度 的最大的值 + 1；

加的1 是根结点，对于叶子结点，左右树都是0 返回的就是自己单独一个结点的高度 

  // 获取二叉树的高度
    int getHeight(TreeNode root){
        if(root == null){
            return 0;
        }
        int leftTree = getHeight(root.left);
        int rightTree = getHeight(root.right);
        return leftTree > rightTree ?
                leftTree + 1 : rightTree + 1;
    }

 检测值为value的值是否存在：

 思路：

1.先判断是否为null

2.判断根结点的val是否等于 val

3.遍历左子树

4.遍历右子树

从3 .4 开始递归

   // 检测值为value的元素是否存在
    TreeNode find(TreeNode root, int val){
        if(root == null){
            return null;
        }
        if(root.val == val){
            return root;
        }
        TreeNode ret1 = find(root.left,val);
        if (ret1 != null){
            return ret1;
        }
        TreeNode ret2 = find(root.right,val);
        if(ret2 != null){
            return ret2;
        }
        return null;

    }

层序遍历：

使用队列去实现：

   void levelOrder(TreeNode root){
        if(root == null){
            return ;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
           TreeNode cur = queue.poll();
            System.out.print(cur.val+" ");
           if(cur.left != null){
               queue.offer(cur.left);
           }
           if(cur.right != null){
               queue.offer(cur.right);
            }
        }

    }

 判断一棵树是不是完全二叉树：

思路：

    boolean isCompleteTree(TreeNode root){
        if(root == null){
            return true;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode cur = queue.poll();
            if(cur != null){
               queue.offer(cur.left);
               queue.offer(cur.right);
            }else {
                break;
            }
        }
//出现空 判断队列中是否还有非空
        while(!queue.isEmpty()){
            TreeNode tmp = queue.peek();
            if(tmp == null){
                queue.poll();
            }else {
                return false;
            }
        }
        return true;
    }

LeetCode题目：

144.二叉树的前序遍历

遍历思维做法：

  List<Integer> List = new ArrayList<>();
    public List<Integer> preorderTraversal(TreeNode root) {

            if (root == null){
                return List;
            }
        List.add(root.val);
        preorderTraversal(root.left);
        preorderTraversal(root.right);
            return List;

    }

利用好返回值：

      public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> list = new ArrayList<>();
       if (root == null){
           return list;
       }
       list.add(root.val);

       List<Integer> leftTree = preorderTraversal(root.left);
      list.addAll(leftTree);
       List<Integer> rightTree = preorderTraversal(root.right);
       list.addAll(rightTree);
       return list;

   }

 非递归：

void preorderTraversal(TreeNode root) {
        if(root == null){
            return ;
        }
        Stack<TreeNode> stack = new Stack();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                System.out.print(cur.val+ " ");
                cur = cur.left;

            }
            TreeNode top  = stack.pop();
            cur = top.right;
        }

    }
}

94. 二叉树的中序遍历

非递归打印：

思路：

  void inorderTraversal(TreeNode root) {
        if(root == null){
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            TreeNode top = stack.pop();
            System.out.print(top.val + " ");
            cur = top.right;
        }
    }

145. 二叉树的后序遍历

 博哥代码：

    void postorderTraversal(TreeNode root) {
        if(root == null){
            return;
        }
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        TreeNode prev = null;
        while(cur != null || !stack.isEmpty()){
            while(cur != null){
                stack.push(cur);
                cur = cur.left;
            }
            TreeNode top = stack.peek();
            if(top.right == null || top.right == prev) {
                System.out.print(top.val+" ");
                stack.pop();
                prev = top;
            }else {
                cur = top.right;
            }
        }

    }

我的思路： 

    void postorderTraversal2(TreeNode root) {
    if(root == null){
        return;
    }
    Stack<TreeNode> stack1 = new Stack<>();
    Stack<TreeNode> stack2= new Stack<>();
    TreeNode cur = root;
    while(cur != null || !stack1.isEmpty()){
        while(cur != null){
            stack1.push(cur);
            cur = cur.left;
        }
        TreeNode top = stack1.peek();
        stack2.push(top);
        cur = top.right;
        if(cur == null){
            while(!stack1.isEmpty()&&!stack2.isEmpty()&&
                    stack2.peek()==stack1.peek() ){
                System.out.print(stack1.peek().val+" ");
                stack1.pop();
                stack2.pop();
            }
            if(stack1.isEmpty())
            {
                break;
            }
                top = stack1.peek();
                stack2.push(top);
                cur = top.right;
        }
    }
    }

 100. 相同的树

思路： 

  public boolean isSameTree(TreeNode p, TreeNode q) {
//先从结构上，再从数值上

//结构上
//一个为空一个不为空 肯定不相同
        if (p == null && q != null || p != null && q == null){
            return false;
        }
//两个都为空
        if(p == null && q == null){
            return true
        }
//数值上
//值不相等 不相同{根节点的判断}
        if(p.val != q.val){
            return false;
        }
//左右树的值进行以上 结构 和 值上的判断 
        return isSameTree(p.left,q.left)&&
        isSameTree(p.right,q.right);

    }

心得：

在二叉树的操作或者题目上，都是针对结点进行各种情况的判断（一般是先判断结构 再 判断数值），然后再递归，这样递归到任何结点，进行的还是以上红色字体的操作

本题再return之前的操作都针对具体结点的分析 先结构 再 数值 然后递归 重复以上循环

572. 另一棵树的子树

正确代码：

错误代码，还没有解决

 public boolean isSameTree(TreeNode p, TreeNode q) {
        if (p == null && q != null || p != null && q == null){
            return false;
        }
        if(p == null && q == null){
            return true;
        }
        if(p.val != q.val){
            return false;
        }
        return isSameTree(p.left,q.left)&&
        isSameTree(p.right,q.right);

    }
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        if(root == null || subRoot == null){
            return false;
        }
      if(isSameTree(root,subRoot)){
          return true;
      }

      return isSameTree(root.left,subRoot) ||
        isSameTree(root.right,subRoot);

    }

 226. 翻转二叉树

思路：

抽象到只有三个节点的满二叉树，那么只需要根节点的左右子树进行交换就可以实现

所以具体到结点，交换根结点的左右子树，抽象到整体使用前序遍历对所有的结点进行上面红色的操作

 其中，判断结点左右子树是否都为空，这样最起码会减少一般的遍历次数

public TreeNode invertTree(TreeNode root) {
        if(root == null){
            return null;
        }
        //如果左右子树都为空就不再交换
        if (root.left == null && root.right == null){
            return root;
        }
        TreeNode tmp = root.left;
        root.left = root.right;
        root.right = tmp;
        invertTree(root.left);
        invertTree(root.right);
        return root;
    }

110. 平衡二叉树

子问题：

当左右子树都为平衡二叉树，整棵树才是平衡二叉树 

 public boolean isBalanced(TreeNode root) {

        if(root == null){
            return true;
        }
            return getHeight(root) >= 0;
    }
      int getHeight(TreeNode root){
        if(root == null){
            return 0;
        }
        int leftTree = getHeight(root.left);
        if(leftTree < 0){
            return -1;
        }
        int rightTree = getHeight(root.right);
       if(leftTree >= 0 && rightTree >= 0 && Math.abs(leftTree - rightTree) <= 1){
        return Math.max(leftTree,rightTree)+1;
       }else{
        return -1;
       }
    }

时间复杂度O（N）； 

101. 对称二叉树

思路：

关键：判断2.3同时为真时才是对称的 

    public boolean isSymmetric(TreeNode root) {

if(root == null){
    return true;
}
return isSymmetricChild(root.left,root.right);
    }
    private boolean isSymmetricChild(TreeNode leftTree,TreeNode rightTree) {
        if(leftTree == null && rightTree != null || leftTree != null && rightTree == null){
            return false;
        }
        if(leftTree == null && rightTree == null){
            return true;
        }
       
            if(leftTree.val != rightTree.val){
                return false;
            }
            return isSymmetricChild(leftTree.left,rightTree.right)&&isSymmetricChild(leftTree.right,rightTree.left);
        
    }

注意：

两个值相同时，return ture ； 局部的正确， 当该结点下面的不相同时就是错的 

 

KY11 二叉树遍历

 注意：

i被static修饰的原因：

class TreeNode{
    public char val;
    public TreeNode left;
    public TreeNode right;
    public TreeNode(char val){
        this.val = val;
    }
}
// 注意类名必须为 Main, 不要有任何 package xxx 信息
public class Main {
    public static int i;
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        // 注意 hasNext 和 hasNextLine 的区别
        while (in.hasNextLine()) { // 注意 while 处理多个 case
            String str = in.nextLine();
            TreeNode root = creatTree(str);
            inorder(root);
        }
    }
    public static TreeNode creatTree(String str){
            TreeNode root = null;
            if(str.charAt(i) != '#'){
                root = new TreeNode(str.charAt(i));
                i++;
                root.left = creatTree(str);
                root.right = creatTree(str);
            }else{
                i++;
            }
            return root;
      }  
    public static void inorder(TreeNode root){
        if(root == null){
        return ;
         }
        inorder(root.left);
         System.out.print(root.val+" ");
        inorder(root.right);
}


}

102. 二叉树的层序遍历

思路：

  public List<List<Integer>> levelOrder(TreeNode root) {
        //创建个二维数组
        List<List<Integer>> ret = new ArrayList<>();
        if(root == null){
            return ret;
        }
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while(!queue.isEmpty()){
            //每一层数值 封装在一个新的tmp数组内
            List<Integer> tmp = new ArrayList<>();
            int size = queue.size();
            while(size != 0) {
                TreeNode cur = queue.poll();
                //将本层的数值 添加到tmp中去
                tmp.add(cur.val);
                size--;
                System.out.print(cur.val + " ");
                if (cur.left != null) {
                    queue.offer(cur.left);
                }
                if (cur.right != null) {
                    queue.offer(cur.right);
                }
            }
            ret.add(tmp);
        }
        return ret;

    }

236. 二叉树的最近公共祖先

任何叶子结点的.left .right 都是 null ，当遍历到时 返回 null ， 像leftTree 接收的 会有 null 的情形

使用递归：

思路：

    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
        if(root == null){
            return null;
        }
        if(root == q || root == p){
            return root;
        }
        TreeNode leftTree = lowestCommonAncestor(root.left,p,q);
        TreeNode rightTree = lowestCommonAncestor(root.right,p,q);
        if(leftTree != null && rightTree != null){
            return root;
        }else if(leftTree != null){
            return leftTree;
        }else{
            return rightTree;
        }
    }

使用栈：

class Solution {
    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
      if(root == null){
        return null;
      }
      Stack<TreeNode> stackP = new Stack<>();
      Stack<TreeNode> stackQ = new Stack<>();
      getPath(root,p,stackP);
      getPath(root,q,stackQ);
    int sizeP = stackP.size();
    int sizeQ = stackQ.size();
    if(sizeP > sizeQ){
        int size = sizeP - sizeQ;
        while(size != 0){
            stackP.pop();
            size--;
        }
    }else{
        int size = sizeQ - sizeP;
        while(size != 0){
            stackQ.pop();
            size--;
        }
    }
    while(!stackP.isEmpty() && !stackQ.isEmpty()){
        if(stackP.peek() == stackQ.peek()){
            return stackP.peek();
        }else{
            stackP.pop();
            stackQ.pop();
        }
    }
    return null;

    }
    public boolean getPath(TreeNode root, TreeNode node, Stack<TreeNode>stack){
        if(root == null){
            return false;
        }
        stack.push(root);
        if(root == node){
            return true;
        }
        boolean leftTree = getPath(root.left,node,stack);
        if(leftTree == true){
            return true;
        }
        boolean rightTree = getPath(root.right,node,stack);
        if(rightTree == true){
            return true;
        }
        stack.pop();
        return false;
    }
}

105. 从前序与中序遍历序列构造二叉树

思路：

先序遍历找根节点，中序遍历找根节点左子树和右子树 

class Solution {
    public int preIndex;
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        return buildTreeChilde(preorder,inorder,0,inorder.length - 1);
    }
    public TreeNode buildTreeChilde(int[] preorder, int[] inorder,int inbegin,int inend){
        if(inbegin > inend){
            return null;
        }
        TreeNode root = new TreeNode(preorder[preIndex]);
       
        int rootIndex = findRootIndex(inorder,inbegin,inend,preorder[preIndex]);
         //找到root的下标
        if(rootIndex == -1){
            return null;
        }
        preIndex++;
        root.left =buildTreeChilde(preorder,inorder,inbegin,rootIndex-1);
        root.right =buildTreeChilde(preorder,inorder,rootIndex + 1,inend);
        return root;
    }
    public int findRootIndex(int[] inorder,int inbegin,int inend,int key){
        for(int i = inbegin; i <= inend; i++){
            if(inorder[i] == key){
                return i;
            }
        }
        return -1;
    }
}

 106. 从中序与后序遍历序列构造二叉树

后序遍历找根结点，创建二叉树的时候先创建右树，因为后序遍历时左右根，倒着遍历时先遍历到右根 

class Solution {
    public int postIndex;
    public TreeNode buildTree(int[] inorder, int[] postorder) {
        postIndex = postorder.length - 1;
        return buildTreeChilde(postorder,inorder,0,inorder.length - 1);
    }
       public TreeNode buildTreeChilde(int[] postorder, int[] inorder,int inbegin,int inend){
        if(inbegin > inend){
            return null;
        }
        TreeNode root = new TreeNode(postorder[postIndex]);
       
        int rootIndex = findRootIndex(inorder,inbegin,inend,postorder[postIndex]);
         //找到root的下标
        if(rootIndex == -1){
            return null;
        }
        postIndex--;
        root.right =buildTreeChilde(postorder,inorder,rootIndex + 1,inend);
        root.left =buildTreeChilde(postorder,inorder,inbegin,rootIndex-1);
        return root;
    }
    public int findRootIndex(int[] inorder,int inbegin,int inend,int key){
        for(int i = inbegin; i <= inend; i++){
            if(inorder[i] == key){
                return i;
            }
        }
        return -1;
    }
}

606. 根据二叉树创建字符串

思路： 

理解一下，当右边为空，回溯后在上次层的递归添加小括号

class Solution {
    public String tree2str(TreeNode root) {
    StringBuilder stringbuilder = new StringBuilder();
    tree2strChiled(root,stringbuilder);    
    return stringbuilder.toString();
    }
     public void tree2strChiled(TreeNode t,StringBuilder stringbuilder) {
        if(t == null){
            return;
        }
        stringbuilder.append(t.val);
        if(t.left != null){
            stringbuilder.append("(");
            tree2strChiled(t.left,stringbuilder);
            stringbuilder.append(")");
        }else{
            //右边为空
            if(t.right == null){
               return; 
            }else{
                //右边不为空
                stringbuilder.append("()");
            }

        }
        if(t.right != null){
            stringbuilder.append("(");
            tree2strChiled(t.right,stringbuilder);
            stringbuilder.append(")");
        }else{
            return;
        }

    }
}

Yile&&G椿琳
关注
  • 22
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
java 数据结构二叉树的实现代码
09-01
主要介绍了java 数据结构二叉树的实现代码的相关资料,需要的朋友可以参考下
数据结构-二叉树（Java实现）
11-27
编程实现如下功能： 1、假设二叉树的结点值是字符，根据输入的一颗二叉树的标明了空子树的完整先根遍历序列，建立一棵以二叉链表表示的二叉树。 2、对二叉树进行先根、中根和后根遍历操作，并输出遍历序列，同时观察...
数据结构之二叉树（Java）
weixin_73060900的博客
05-31 1169
对树的概述以及对二叉树的详细讲解，不仅有前中后遍历的递归与非递归操作，更有二叉树的基本操作以及练习的一些oj题.
Java 【数据结构OJ题十道】—— 二叉树篇1
yzhcjl_的博客
02-23 574
收录十道二叉树相关OJ题, 感兴趣的小伙伴来看看吧~
Java - 数据结构，二叉树
ryy1999的博客
03-01 774
树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。它具有以下的特点：1、有一个特殊的结点，称为根结点，根结点没有前驱结点除根结点外，其余结点被分成M(M > 0)个互不相交的集合T1、T2、…、Tm，其中每一个集合 Ti (1
Java【二叉树】详细图解 + 掌握重点基本操作
yzhcjl_的博客
02-22 888
关于二叉树的相关知识和相关操作代码整理分享~
【数据结构 Java 版】二叉树的实现（超多图、超详解）
2401_84408814的博客
04-20 860
外链图片转存中…(img-Tagg2LA9-1713549071340)][外链图片转存中…(img-8RPdBjtL-1713549071343)][外链图片转存中…(img-0cwFlrsL-1713549071345)]
【数据结构Java版】二叉树堆与优先级队列PriorityQueue
m0_63372226的博客
12-31 1177
目录 一、优先级队列 （1）优先级队列的概念 （2）优先级队列的模拟实现 二、堆 （1）堆的概念 （2）堆的存储方式 （3）堆的创建 1.堆的向下调整 2.堆的创建3.建堆的时间复杂度（4）堆的操作1.堆的插入2.堆的删除（5）堆的应用1.优先级队列（PriorityQueue）的实现2.Top-k问题 三、PriorityQueue接口（1）PriorityQueue的特性（2）PriorityQueue常用接口介绍1. 优先级队列的构造2. 优先级队列常用功能3.优先级队列扩容方式四、相关oj练习题
【数据结构 Java 版】二叉树的实现（超多图、超详解）(1)
2401_84408780的博客
04-20 719
一次偶然，从朋友那里得到一份“java高分面试指南”，里面涵盖了25个分类的面试题以及详细的解析：JavaOOP、Java集合/泛型、Java中的IO与NIO、Java反射、Java序列化、Java注解、多线程&并发、JVM、Mysql、Redis、Memcached、MongoDB、Spring、Spring Boot、Spring Cloud、RabbitMQ、Dubbo 、MyBatis 、ZooKeeper 、数据结构、算法、Elasticsearch 、Kafka 、微服务、Linux。
【Java】二叉树入门详解（包含二叉树0J练习解析）
热门推荐
意愿三七
06-05 3万+
目录一、 树型结构（了解）1.1 概念1.2 概念（重要）1.3 树的表示形式（了解）1.4 树的应用二、 二叉树的认识（重点）2.1 概念2.2 二叉树的基本形态2.3 两种特殊的二叉树2.4 二叉树的性质2.5 二叉树的存储2.6 二叉树的基本操作2.6.1 二叉树的遍历.2.6.2 二叉树的基本操作（1）前序遍历（2）中序遍历（3）后序遍历(4)遍历思路-求结点个数(5.)子问题思路-求结点个数(6)遍历思路-求叶子结点个数(7)子问题思路-求叶子结点个数(8)子问题思路-求第 k 层结点个数(9)获
Java版数据结构与算法笔记
QWQ___qwq的博客
02-01 850
:front并没有直接指向数据,而是数据前一位,所以当你要用front读取队列头时需要代码实现 问题分析与优化方向: 目前数组使用一次就不能用， 没有达到复用的效果. ​ :取出数据时是将列表头()向后移动,导致队列前面的空间并没有被释放,如上图第三个队列示例图初始化为0:因为要指向队列第一个位置,所以为0队列满条件:–>原理如上方环形队列示例图队列为空:假使你队列曾经加到8个数据,所以你,但当你将队列一个一个取出时front发生如下变化:,所以当frontrear8时,就可以判断队列为空队列的有效
数据结构-二叉树 JAVA语言实现
10-16
使用教程：http://blog.csdn.net/z740852294/article/details/78250911
java版数据结构的 算术表达式与二叉树源码
06-08
Java版的源码，可应用于数据结构的课程设计，非常完美的源码
【java 数据结构】还不会二叉树？一篇搞定二叉树
12-21
二叉树是我们常见的数据结构之一，在学习二叉树之前我们需要知道什么是树，什么是二叉树，本篇主要讲述了二叉树，以及二叉树的遍历。 你能get到的知识点？ 1、树的介绍 2、二叉树的介绍 3、二叉树遍历的四种方法 4、...
P2【练习力扣933】【数据结构】【队列queue】C++版
qq_50891451的博客
05-18 457
，范围是 [-2900,100]，返回 2。]，范围是 [-2999,1]，返回 1。]，范围是 [1,3001]，返回 3。]，范围是 [2,3002]，返回 3。类来计算特定时间范围内最近的请求。的调用都使用比之前更大的。
P6【力扣144，94，145】【数据结构】【二叉树遍历】C++版
最新发布
qq_50891451的博客
05-22 379
从根节点开始遍历，并将根节点入栈，再遍历他的左子树，并依次入栈，直到该结点没有左子树。判断这个结点是否有右子树，如果没有，则将该结点弹出栈，并记录结点值。如果有则继续从他的右子树进行遍历，同时记录该结点的右子树是否遍历过，如果遍历过，则弹栈并记录结点值。时间复杂度：O（N）每个结点会遍历一次且只遍历一次。空间复杂度：O（N）栈至多会存放所有树节点。
数据结构——AVL树
mastershooter的博客
05-16 964
在结点的定义中，我们直接定义成KV模型的结点，并新增一个平衡因子，还有一个_parent指针，也就是说，该结点拥有三个指针+一对键值对+一个平衡因子，在初始化时指针都初始化为空，平衡因子设定成0。//左子树指针//右子树指针//每个结点都包含了一个父结点地址//键值对int _bf;//平衡因子//构造函数, _kv(kv), _bf(0){}
P0【知识点】【数据结构】【数组Array】讲解C++版
qq_50891451的博客
05-16 208
大O表示法 O(1) < O(logN) < O(N) < O(NlogN) < O(N^2) < O(2^N)at() 这个方法返回的是一个引用，可以吧一个常量 int 赋值给它。数组索引（Access）：是通过数组的下标去找这个元素。大O表示法 O(1) < O(N) < O(N^2)数组搜索（Search）：是找这个元素的位置（索引）3.插入 Insert O(N)4.删除 Delete O(N)1.访问access O(1)2.搜索search O(N)【485】最大连续1的个数。
java数据结构二叉树
01-05
二叉树是一种常见的数据结构，它由节点组成，每个节点最多有两个子节点：左子节点和右子节点。以下是一个简单的Java实现二叉树的例子： ```java // 定义二叉树节点类 class TreeNode { int val; TreeNode left; TreeNode right; public TreeNode(int val) { this.val = val; this.left = null; this.right = null; } } // 构建二叉树 public class BinaryTree { TreeNode root; public BinaryTree(int val) { this.root = new TreeNode(val); } // 插入节点 public void insert(int val) { TreeNode newNode = new TreeNode(val); if (root == null) { root = newNode; } else { TreeNode current = root; TreeNode parent; while (true) { parent = current; if (val < current.val) { current = current.left; if (current == null) { parent.left = newNode; return; } } else { current = current.right; if (current == null) { parent.right = newNode; return; } } } } } // 先序遍历 public void preOrderTraversal(TreeNode node) { if (node != null) { System.out.print(node.val + " "); preOrderTraversal(node.left); preOrderTraversal(node.right); } } // 中序遍历 public void inOrderTraversal(TreeNode node) { if (node != null) { inOrderTraversal(node.left); System.out.print(node.val + " "); inOrderTraversal(node.right); } } // 后序遍历 public void postOrderTraversal(TreeNode node) { if (node != null) { postOrderTraversal(node.left); postOrderTraversal(node.right); System.out.print(node.val + " "); } } } // 创建二叉树并进行遍历 public class Main { public static void main(String[] args) { BinaryTree binaryTree = new BinaryTree(5); binaryTree.insert(3); binaryTree.insert(7); binaryTree.insert(2); binaryTree.insert(4); binaryTree.insert(6); binaryTree.insert(8); System.out.println("先序遍历结果："); binaryTree.preOrderTraversal(binaryTree.root); System.out.println(); System.out.println("中序遍历结果："); binaryTree.inOrderTraversal(binaryTree.root); System.out.println(); System.out.println("后序遍历结果："); binaryTree.postOrderTraversal(binaryTree.root); System.out.println(); } } ``` 这个例子展示了如何构建一个二叉树，并对其进行先序、中序和后序遍历。你可以根据需要修改节点的值和插入顺序来构建不同的二叉树。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值