JAVA-二叉树习题

最新推荐文章于 2023-04-03 14:37:06 发布

超分辨菜鸟

最新推荐文章于 2023-04-03 14:37:06 发布

阅读量1.2k

点赞数 1

分类专栏： JAVA 二叉树文章标签：二叉树数据结构

本文链接：https://blog.csdn.net/weixin_44712669/article/details/117431256

版权

JAVA 同时被 2 个专栏收录

97 篇文章 0 订阅

订阅专栏

二叉树

11 篇文章 0 订阅

订阅专栏

二叉树相关习题

概念

树

1.概念

树是非线性的数据结构，有n个有限节点组成一个具有层次关系的集合，看起来像一个倒挂的树
根节点无前驱节点，其余节点被分成M个互不相交的集合T1,T2…Tm,每个集合又是一棵与树类似的子树，每棵子树的根节点只有一个前驱节点，可以有0个或多个后继节点。
树是递归定义的
节点的度：
一个节点含有的子树的个数称为该节点的度—>树的度为最大节点的度，

叶子节点也称为终端节点，度为0的节点，
深度：该节点到根
高度：该节点到叶子节点

二叉树

一颗二叉树是节点的一个有限集合，该集合或为空或有一个根节点加上两颗左右子树组成
特点：1.每个节点最多有两颗子树，即二叉树不存在度大于2的节点
2.二叉树的子树有左右之分，其子树的次序不能颠倒，因此是有序树。
基本形态：
满二叉树：除了叶子节点外，所有节点均有左右子节点
完全二叉树：对整个二叉树的节点进行层序编号之后，所有序号都紧挨着
二叉树：任意形状，

二叉树的性质：

1.若规定根节点的层数为1，一颗非空二叉树的第i层最多有2的i-1次方个节点。
2.只有根节点的二叉树的深度为1，则深度为k的二叉树的最大节点数为(2^k)-1
3.对任何一颗二叉树，如果叶子节点个数为n0，度为2的非叶子节点个数为n2，则有n0=n2+1
4.具有n个节点的完全二叉树的深度为log2（n+1）向上取整
5.具有n个节点的完全二叉树，按照从上到下从左到右的顺序，对所有的节点从0开始编号，则对于序号为i的节点有：
(1)若i>0；其双亲序号：(i-1)/2，i=0；i为根节点编号，无双亲节点。
(2)若2i+1<n,左孩子序号为2i+1；否则无左孩子
(3)若2i+2<n,右孩子序号：2i+2；否则无右孩子
如一颗完全二叉树总共有1000个节点，则该二叉树中(500 )个叶子节点，(500)个非叶子节点，(1)个节点只有左孩子，(0)个几点只有右孩子，共多少层
1.有多少层？10层，
10=log2(1000+1);第10层没放满
2.前9层能放多少节点？
2^9-1=511个节点，
第10层有1000-511=489个
489个节点是由第9层的节点244父节点产生，第9层有2^8个节点256个节点，256-245=11；
489+11=500个叶子节点，
计算 n0+n2+1=1000；n0+n0-1+1=1000；n0=500；

二叉树的遍历：

1.前序遍历:NLR,先根遍历–访问根节点–根的左子树–根的右子树
2.中序遍历:LNR中根遍历–根的左子树–根节点–根的右子树
3.后序遍历:LRN后根遍历–根的左子树–根的右子树–根节点

1.前序遍历：

void preOrederTraversal(BtNode root){
    if(root==null){
        sout(root.val);    
    }
    preOrederTraversal(root.left);
    preOrederTraversal(root.right);
}

2.中序遍历

void preOrederTraversal(BtNode root){
    if(root==null){
           
    }    
    preOrederTraversal(root.left);    

       sout(root.val);
    preOrederTraversal(root.right);
}

3.后序遍历：

void preOrederTraversal(BtNode root){
    if(root==null){
     return;      
    }    
    preOrederTraversal(root.left);    
    preOrederTraversal(root.right);
    
    sout(root.val);
}

4.层序遍历

思路：利用队列实现，动态的将当前层的节点保存到队列中，通过设置循环将队列中的节点释放，然后将值保存在列表中
并且在循环中给队列保存新的一层的节点，这里需要注意的是，循环的终止条件；

 public ArrayList<ArrayList<Integer>> levelOrder (TreeNode root) {
        // write code here
        ArrayList<ArrayList<Integer>> result = new ArrayList<ArrayList<Integer>>();
        if(root ==null)return result;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()){
        //设置循环条件，队列不为空，则不终止
            ArrayList<Integer> list = new ArrayList<Integer>();
            int len = queue.size();
            //len表示当前队列中节点的个数，也就是之前层的节点个数；
            //上设置每一层的循环条件；for循环负责将当前层的所有节点保存；这里需要理解的是len代表当前层的节点个数
            for(int i=0;i<len;i++){
                TreeNode cur = queue.poll();
                list.add(cur.val);
                if(cur.left!=null){
                    queue.offer(cur.left);
                }
                if(cur.right!=null){
                    queue.offer(cur.right);
                }
            } 
            result.add(list);
            
        }
        return result;
        
        
    }

二叉树的相关习题

1.求节点的个数

遍历思路：递归遍历，每次不为空size++；

void getSize(BTNode root){
    if(root==null)return;
    size++;
    getSize(root.left);
    getSize(root.right);
}

子问题思路：左树节点+右树节点+1

void getSize(BTNode root){
    if(root==null)return 0;
    return getSize(root.left)+getSize(root.right)+1;
}

2.求叶子节点个数

以遍历思路求叶子节点个数：

void getLeafSize(BTNode root){
    if(root==null)return;
    if(root.left==null&&root.right==null){
        leafsize++;
    }
    getLeafSize(root.left);
    getLeafSize(root.right);

}

子问题思路：

void getLeafSize(BTNode root){
    if(root==null)return 0;
    if(root.left==null&&root.right==null){
        return 1;
    }
    return getLeafSize(root.left)+getLeafSize(root.right);

}

3.求第k层节点的个数

递归过程中 k要发生改变，当前树的左树和右数的第k层

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

}

4.求二叉树的高度

求左树和右树的高度，比较之后，返回再+1

int getHight(BTNode root){
    if(root==null)return 0;
    
    letfHight = getHight(root.left);
    rightHight = getHight(root.right);
    if(leftHight>rightHight)return lefthHight+1;
    else{
        return  rightHight +1;   
    }
}

5.判断s是否为t的子树;

public boolean isSubtree(TreeNode s,TreeNode t){
    if(s==null || t==null){
        return false;
    }
    if(isSameTree(s,t))return true;
    if(isSubtree(s.left,t))return true;
    if(isSubtree(s.right,t))return true;
    return  false;

}

6.检查二叉树树是否镜像对称：

public Boolean isSymmertric(TreeNode root){
    if(root==null){
        return true;
    }
    return isSymmetricChild(root.left,root.right);
}
public boolean isSymmertricChild(TreeNode left,TreeNode right){
    if(left==null&&right!=null||left!=null&&left==null){
        return false;    
    }
    if(left==null&&right==null){
        return true;
    }
    if(left.val!=right.val)return false;
    return isSymmertricChild(left.left,right.right)&&
                isSymmertricChild(left.right,right.left);
}

7.判断平衡二叉树：

一个二叉树的每个节点的左右两颗子树的高度差不能超过1；
1.当前节点的左树和右树的差是否<=1;
2.看左树是否平衡，右树是否平衡，

public int hight(TreeNode root){
    if(root==null)return 0;
    int leftHight = hight(root.left);
    int rightHight = hight(root.right);
    if(Math.abs(leftHight-rightHigt)<=1){
        return Math.max(leftHight,rightHight)+1;
    }else{
        retuen -1;
    }

}
public boolean isBalanced(TreeNode root){
     if(hight(root)>=0){
        return true;
    }   
    return false;

}

8.构造二叉树：

从前序遍历创建,递归栈为空时，返回null遍历停止；

public static int i=0;
public static BTNode creatTree(String str){
    if(str==null || str.length()<=0)return null;
    
    BTNode root = null;
    if(s.charAt(i)!='#'){
        root = new BTNode(str.charAt(i));
        i++;
        root.left = createTree(str);
        root.right = createTree(str);
    }else{
        i++;    
    }
    return root;
}

9.找到两个节点的最近公共祖先：

根节点本身是否为p，q当中的某个节点
根的左，根的右，
左右两边都不为空，root是公共祖先。左边不为空，右边为空，左边第一次找到的节点就是公共祖先。左边为空，右边不为空右边第一个节点为公共祖先

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

}

10.二叉搜索树：

左树的值是小于根的，右树的值大于根，所有节点满足此条件
转换为二叉搜索树；利用中序遍历解答

public TreeNode prev = null;
public void ConvertChild(TreeNode pcur){
    if(pcur==null)return;
    ConvertChild(pcur.left);
    pcur.left = prev;
    if(prev!=null){
        prev.right = pcur;    
    }  
      prev=pcur;
   
    
    ConvertChild(pcur.right);
    
}
public TreeNode Convert(TreeNode proottree){
    if(proottree==null)return null;
    ConvertChild(proottree);
    TreeNode head = proottree;
    while(head.left!=null){
        head=head.left;
    }

}

11.根据树的前序遍历和中序遍历构建二叉树(根据中序和后续遍历创建同理)

思路：用前序遍历找到根，用中序遍历确定左树和右树

class Solution {
    private int preIndex=0;
    public TreeNode buildTreeChild(int[] preorder,int[] inorder,int inbegin,int inend){
            if(inbegin>inend)return null;
            TreeNode root = new TreeNode(preorder[preIndex]);
            int index = findValInorder(inorder,preorder[preIndex],inbegin,inend);
            preIndex++;
            root.left = buildTreeChild(preorder,inorder,inbegin,index-1);
            root.right = buildTreeChild(preorder,inorder,index+1,inend);
            return root;


    }
    public int findValInorder(int[] inorder,int key,int inbegin,int inend){
        for(int i=inbegin;i<=inend;i++){
            if(inorder[i]==key){
                return i;
            }
        }
        return -1;


    }
    public TreeNode buildTree(int[] preorder, int[] inorder) {
            if(preorder ==null||inorder==null)return null;
            if(preorder.length==0||inorder.length==0){
                return null;
            }
            int preIndex = 0;
            TreeNode root = buildTreeChild(preorder,inorder,0,inorder.length-1);
            return root;
    }
}

12.根据二叉树创建字符串：

你需要采用前序遍历的方式，将一个二叉树转换成一个由括号和整数组成的字符串。

空节点则用一对空括号 “()” 表示。而且你需要省略所有不影响字符串与原始二叉树之间的一对一映射关系的空括号对。

需要注意的是：二叉树的遍历中间需要添加括号，递归的终止条件和递归的起始条件


class Solution {
    public String tree2str(TreeNode root) {
            StringBuilder sb = new StringBuilder();
            tree2strChild(root,sb);
            return sb.toString();
    }
     public void tree2strChild(TreeNode t,StringBuilder sb){
        if(t==null)return;
        sb.append(t.val);
        if(t.left==null){
            if(t.right==null){
                return;
            }else{
                  sb.append("()");  
            }

		}else{
            sb.append("(");
            tree2strChild(t.left,sb);
            sb.append(")");
        }
        if(t.right==null){
            return;
        }else{
            sb.append("(");
            tree2strChild(t.right,sb);
            sb.append(")");
        }
    }
}

超分辨菜鸟

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
6
评论
JAVA-二叉树习题

二叉树相关习题概念树1.概念树是非线性的数据结构，有n个有限节点组成一个具有层次关系的集合，看起来像一个倒挂的树根节点无前驱节点，其余节点被分成M个互不相交的集合T1,T2…Tm,每个集合又是一棵与树类似的子树，每棵子树的根节点只有一个前驱节点，可以有0个或多个后继节点。树是递归定义的节点的度：一个节点含有的子树的个数称为该节点的度—>树的度为最大节点的度，叶子节点也称为终端节点，度为0的节点，深度：该节点到根高度：该节点到叶子节点二叉树一颗二叉树是节点的一个有限集合，该集合
复制链接

扫一扫