二叉树完整练习

最新推荐文章于 2025-02-25 02:45:50 发布
最新推荐文章于 2025-02-25 02:45:50 发布
阅读量617 收藏
点赞数
分类专栏： 二叉树 文章标签： 二叉树 
import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Stack;

class TreeNode{
    TreeNode left;
    TreeNode right;
    int val;

    public TreeNode(int val){
        this.val = val;
    }
}

public class TestForString {

    static int total=0;

    public static void main(String[] arg){

        StringBuffer sb = new StringBuffer();

        System.out.print(sb.length());

    }


    public static int getNodeNumRec(TreeNode root){
        if(root == null){
            return 0;
        }else{
            return getNodeNumRec(root.left)+getNodeNumRec(root.right)+1;
        }
    }

    public static int getNodeNum(TreeNode root){
        if(root == null){
            return 0;
        }

        Queue<TreeNode> q = new LinkedList<TreeNode>();
        q.offer(root);

        int cnt = 0;
        while(!q.isEmpty()){
            TreeNode node = q.poll();
            if(node.left!=null){
                q.offer(node.left);
            }

            if(node.right!=null){
                q.offer(node.right);
            }

            cnt++;
        }

        return cnt;
    }

    public static int getDepthRec(TreeNode root){
        if(root==null){
            return 0;
        }else{
            return 1+Math.max(getDepthRec(root.left), getDepthRec(root.right));
        }
    }

    public static int getDepth(TreeNode root){
        if(root==null){
            return 0;
        }

        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        TreeNode dumy = new TreeNode(0);
        queue.offer(root);
        queue.offer(dumy);

        int cnt=0;
        while(!queue.isEmpty()){
            TreeNode current = queue.poll();
            if(current==dumy){
                cnt++;
                if(!queue.isEmpty()){
                    queue.offer(dumy);
                }
            }

            if(current.left!=null){
                queue.offer(current.left);
            }

            if(current.right!=null){
                queue.offer(current.right);
            }
        }

        return cnt;
    }

    public static void preorderTraversalRec(TreeNode root){
        if(root==null){
            return;
        }

        System.out.print(root.val+" ");
        preorderTraversalRec(root.left);
        preorderTraversalRec(root.right);
    }

    public static void preorderTraversal(TreeNode root){
        if(root == null){
            return;
        }

        Stack<TreeNode> s = new Stack<TreeNode>();
        s.push(root);

        while(!s.isEmpty()){
            TreeNode node = s.pop();
            System.out.print(node.val+" ");

            if(node.right!=null){
                s.push(node.right);
            }

            if(node.left!=null){
                s.push(node.left);
            }
        }

    }

    public static void inorderTraversalRec(TreeNode root){
        if(root==null){
            return;
        }

        inorderTraversalRec(root.left);
        System.out.print(root.val+" ");
        inorderTraversalRec(root.right);
    }

    public static void inorderTraversal(TreeNode root){
        if(root==null){
            return;
        }

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode current = root;

        while(true){
            while(current!=null){
                stack.push(current);
                current=current.left;
            }

            if(!stack.isEmpty()){
                break;
            }

            current = stack.pop();
            System.out.print(current.val+" ");

            current = current.right;
        }
    }

    public static void postorderTraversalRec(TreeNode root){
        if(root==null){
            return;
        }

        postorderTraversalRec(root.left);
        postorderTraversalRec(root.right);
        System.out.print(root.val+" ");

    }

    public static void postorderTraversal(TreeNode root){
        if(root==null){
            return;
        }

        Stack<TreeNode> stackIn = new Stack<TreeNode>();
        Stack<TreeNode> stackOut = new Stack<TreeNode>();

        stackIn.push(root);

        while(!stackIn.isEmpty()){
            TreeNode current = stackIn.pop();
            stackOut.push(current);

            if(current.left!=null){
                stackIn.push(current.left);
            }

            if(current.right!=null){
                stackIn.push(current.right);
            }
        }

        while(!stackOut.isEmpty()){
            System.out.print(stackOut.pop().val+" ");
        }
    }

    public static void levelTraversalRec(TreeNode root){
        ArrayList<ArrayList<Integer>>ret = new ArrayList<ArrayList<Integer>>();
        levelTraversalVisit(root,0,ret);
        System.out.print(ret);
    }


    private static void levelTraversalVisit(TreeNode root, int level,
            ArrayList<ArrayList<Integer>> ret) {
        if(root==null){
            return;
        }

        if(level>=ret.size()){
            ret.add(new ArrayList<Integer>());
        }

        ret.get(level).add(root.val);
        levelTraversalVisit(root.left,level+1,ret);
        levelTraversalVisit(root.right,level+1,ret);
    }

    public static void levelTraversalVisit(TreeNode root){
        if(root==null){
            return;
        }


        Queue<TreeNode> queue = new LinkedList<TreeNode>();

        queue.offer(root);
        while(!queue.isEmpty()){
            TreeNode current  = queue.poll();
            System.out.print(current.val+" ");

            if(current.left!=null){
                queue.offer(current.left);
            }

            if(current.right!=null){
                queue.offer(current.right);
            }
        }
    }


    public static TreeNode convertBST2DLLRec(TreeNode root){
        return converBST2DLLRecHelp(root)[0];
    }


    public static TreeNode[] converBST2DLLRecHelp(TreeNode root) {

        TreeNode[] ret = new TreeNode[2];
        //ret[0]表示由这个节点以及他的所有的子节点所创建的链表的做端点；
        //ret[1]表示整个链表的右边的第一个节点，也就是链表的右边头部节点
        ret[0]=null;
        ret[1]=null;

        if(root==null){
            return ret;
        }

        if(root.right!=null){
            TreeNode[] right=converBST2DLLRecHelp(root.right);
            right[0].left=root;
            root.right=right[0];

            ret[1]=right[1];
        }else{
            ret[1]=root;
        }

        if(root.left!=null){
            TreeNode[] left=converBST2DLLRecHelp(root.left);
            left[1].right=root;
            root.left=left[1];

            ret[0]=left[0];
        }else{
            ret[0]=root;
        }

        return ret;
    }

    public static TreeNode convertBST2DLL(TreeNode root){
        while(root==null){
            return null;
        }

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode head = null;
        TreeNode current = root;
        TreeNode pre = null;

        while(true){
            while(current!=null){
                stack.push(current);
                current = current.left;
            }

            if(stack.isEmpty()){
                break;
            }

            current = stack.pop();

            if(head==null){
                head=current;
            }

            current.left = pre;
            if(pre!=null){
                pre.right=current;
            }

            pre=current;
            current = current.right;
        }

        return head;
    }

    public static int getNodeNumKthLevel(TreeNode root,int k){
        if(root==null||k<=0){
            return 0;
        }

        int level=0;
        int count=0;
        Queue<TreeNode> queue = new LinkedList<TreeNode>();

        TreeNode current = root;
        TreeNode dummy = new TreeNode(0);

        queue.offer(current);
        queue.offer(dummy);

        while(!queue.isEmpty()){
            current = queue.poll();

            if(current==dummy){
                level++;
                if(level==k){
                    return count;
                }else{
                    count=0;
                    if(queue.isEmpty()){
                        return count;
                    }
                    queue.offer(dummy);
                }
            }else{
                count++;
                if(current.left!=null){
                    queue.offer(current.left);
                }

                if(current.right!=null){
                    queue.offer(current.right);
                }
            }
        }

        return 0;
    }

    public static int getNodeNumKthLevelRec(TreeNode root,int k){
        if(root==null){
            return 0;
        }

        if(k==1){
            return 1;
        }

        //根树的第K层其实就是左右子树的第K-1层，因为子树要比跟往下走一层；
        return getNodeNumKthLevelRec(root.left,k-1)
                +getNodeNumKthLevelRec(root.right,k-1);
    }

    public static int getNodeNumLeaf(TreeNode root){

        if(root==null){return 0;}

        int count=0;
        TreeNode current = root;
        Stack<TreeNode> stack = new Stack<TreeNode>();

        while(true){
            while(current!=null){
                stack.push(current);
                current=current.left;
            }

            if(stack.isEmpty()){
                break;
            }

            current = stack.pop();

            if(current.left==null&&current.right==null){
                count++;
            }

            current=current.right;
        }

        return count;

    }

    public static int getNodeNumLeafRec(TreeNode root){
        if(root==null){
            return 0;
        }

        if(root.left==null&&root.right==null){
            return 1;
        }

        return getNodeNumLeafRec(root.left)+getNodeNumLeafRec(root.right);
    }


    public static boolean isSameRec(TreeNode root1,TreeNode root2){
        if(root1==null&&root2==null){
            return true;
        }

        if(root1==null||root2==null){
            return false;
        }

        return root1.val==root2.val&&
                isSameRec(root1.left,root2.left)&&
                isSameRec(root1.right,root2.right);
    }

    public static boolean isSame(TreeNode root1,TreeNode root2){
        Stack<TreeNode> stack1 = new Stack<TreeNode>();
        Stack<TreeNode> stack2 = new Stack<TreeNode>();

        TreeNode current1 = root1;
        TreeNode current2 = root2;

        while(true){
            while(current1!=null&&current2!=null){
                stack1.push(current1);
                current1=current1.left;

                stack2.push(current2);
                current2=current2.left;
            }

            if(current1!=null||current2!=null){
                return false;
            }

            if(stack1.isEmpty()&&stack2.isEmpty()){
                break;
            }

            current1=stack1.pop();
            current2=stack2.pop();

            if(current1.val!=current2.val){
                return false;
            }

            current1=current1.right;
            current2=current2.right;
        }

        return true;
    }

    public static boolean isAVLRec(TreeNode root){
        if(root==null){
            return true;
        }

        if(!isAVLRec(root.left)||!isAVLRec(root.right)){
            return false;
        }

        int dif =  Math.abs(getDepthRec(root.left)-getDepthRec(root.right));
        if(dif>1){
            return false;
        }

        return true;

    }

    public static TreeNode mirrorRec(TreeNode root){
        if(root==null){
            return null;
        }

        TreeNode right = root.right;
        root.right = mirrorRec(root.left);
        root.left = mirrorRec(right);

        return root;
    }


    public static TreeNode mirror(TreeNode root){
        if(root==null){
            return null;
        }

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode current = root;
        stack.push(current);

        while(!stack.isEmpty()){
            current = stack.pop();

            TreeNode right = current.right;
            current.right = current.left;
            current.left = right;

            if(current.right!=null){
                stack.push(current.right);
            }

            if(current.left!=null){
                stack.push(current.left);
            }
        }

        return root;
    }

    public static TreeNode mirrorCopy(TreeNode root){
        if(root==null){
            return null;
        }

        TreeNode rootCopy = new TreeNode(root.val);
        TreeNode currentCopy = rootCopy;
        Stack<TreeNode> stackCopy = new Stack<TreeNode>();
        stackCopy.push(currentCopy);

        Stack<TreeNode> stack = new Stack<TreeNode>();
        TreeNode current = root;
        stack.push(current);

        while(!stack.isEmpty()){
            current = stack.pop();
            currentCopy = stack.pop();

            TreeNode copyLeft = null;
            TreeNode copyRight = null;

            if(current.right!=null){
                copyLeft = new TreeNode(current.right.val);
                currentCopy.left=copyLeft;
                stackCopy.push(currentCopy.left);
                stack.push(current.right);
            }

            if(current.left!=null){
                copyRight = new TreeNode(current.left.val);
                currentCopy.right = copyRight;
                stackCopy.push(currentCopy.right);
                stack.push(current.left);   
            }

        }

        return rootCopy;
    }

    public static TreeNode mirrorCopyRec(TreeNode root){
        if(root==null){
            return null;
        }

        TreeNode copyRoot = new TreeNode(root.val);
        copyRoot.left = mirrorCopyRec(root.right);
        copyRoot.right = mirrorCopyRec(root.left);

        return root;
    }

    public static boolean isMirrorRec(TreeNode root1,TreeNode root2){
        if(root1==null&&root2==null){
            return true;
        }

        if(root1==null||root2==null){
            return false;
        }

        return root1.val==root2.val
                &&isMirrorRec(root1.left,root2.right)
                &&isMirrorRec(root1.right,root2.left);
    }

    public static boolean isMirror(TreeNode root1,TreeNode root2){
        if(root1==null&&root2==null){
            return true;
        }

        if(root1==null||root2==null){
            return true;
        }

        TreeNode current1 = root1;
        TreeNode current2 = root2;
        Stack<TreeNode> stack1 = new Stack<TreeNode>();
        Stack<TreeNode> stack2 = new Stack<TreeNode>();

        while(!stack1.isEmpty()&&!stack2.isEmpty()){

            current1 = stack1.pop();
            current2 = stack2.pop();

            if(current1.val!=current2.val){
                return false;
            } 

            if((current1.left==null&&current2.right!=null)
                    ||(current1.left!=null||current2.right==null)){
                return false;
            }
            if(current1.left!=null&&current2.right!=null){
                stack1.push(current1.left);
                stack2.push(current2.right);
            }

            if((current1.right==null&&current2.left!=null)
                    ||(current1.right!=null&&current2.left==null)){
                return false;   
            }
            if(current1.right!=null&&current2.left!=null){
                stack1.push(current1.right);
                stack2.push(current2.left);
            }
        }

        return true;

    }

    public static TreeNode LACRec(TreeNode root,TreeNode node1,TreeNode node2){
        if(root==null||node1==null||node2==null){
            return null;
        }

        if(root==node1||root==node2){
            return root;
        }

        TreeNode  left = LACRec(root.left,node1,node2);
        TreeNode  right= LACRec(root.right,node1,node2);

        if(left==null){
            return right;
        }

        if(right==null){
            return left;
        }

        return root;
    }

    public static TreeNode LACBstRec(TreeNode root,TreeNode node1,TreeNode node2){
        if(root==null||node1==null||node2==null){
            return null;
        }

        if(root.val==node1.val||root.val==node2.val){
            return root;
        }

        int max =Math.max(node1.val, node2.val);
        int min =Math.max(node1.val, node2.val);

        if(root.val<min){
            return LACBstRec(root.right,node1,node2);
        }

        if(root.val>max){
            return LACBstRec(root.left,node1,node2);
        }

        return root;
    }

    public static boolean LCAPath(TreeNode root,TreeNode node,ArrayList<TreeNode> path){
        if(root==null||node==null){
            return false;
        }

        path.add(root);

        if(root.val!=node.val
                &&!LCAPath(root.left,node,path)
                &&LCAPath(root.right,node,path)){
            path.remove(root);
            return false;
        }

        return true;
    }

    /*
     * 二叉树找寻最低公共节点
     * 
     * */
    public static TreeNode LCA(TreeNode root,TreeNode node1,TreeNode node2){
        if(root==null||node1==null||node2==null){
            return null;
        }

        ArrayList<TreeNode> path1 = new ArrayList<TreeNode>();
        ArrayList<TreeNode> path2 = new ArrayList<TreeNode>();

        boolean find1 = LCAPath(root,node1,path1);
        boolean find2 = LCAPath(root,node2,path2);

        if(!(find1&&find2)){
            return null;
        }

        Iterator<TreeNode> iter1 = path1.iterator();
        Iterator<TreeNode> iter2 = path2.iterator();

        TreeNode last = null;
        TreeNode nextNode1;
        TreeNode nextNode2;
        while(iter1.hasNext()&&iter2.hasNext()){
            nextNode1=iter1.next();
            nextNode2=iter2.next();

            if(nextNode1==nextNode2){
                last = nextNode1;
            }else{
                return last;
            }
        }

        return last;
    }

    public static int getMaxDistanceRec(TreeNode root){
        return getMaxDistanceRecHelp(root).maxDistance;
    }

    public static Result getMaxDistanceRecHelp(TreeNode root){
        Result ret = new Result(-1,-1);

        if(root==null){
            return ret;
        }

        Result left = getMaxDistanceRecHelp(root.left);
        Result right = getMaxDistanceRecHelp(root.right);

        ret.depth = Math.max(left.depth,right.depth)+1;
        int crossLen = left.depth + right.depth +2;
        ret.maxDistance = Math.max(left.maxDistance, right.maxDistance);
        ret.maxDistance = Math.max(crossLen, ret.maxDistance);

        return ret;
    }

    private static class Result{
        int depth;
        int maxDistance;
        public Result(int depth,int maxDistance){
            this.depth = depth;
            this.maxDistance = maxDistance;
        }
    }

    public static TreeNode rebuildBinaryTreeRec(List<Integer> preOrder,List<Integer>inOrder){
        if(preOrder==null||inOrder==null){
            return null;
        }

        int rootVal = preOrder.get(0);
        int rootIndex = inOrder.indexOf(rootVal);

        if(rootIndex<0){
            return null;
        }

        TreeNode root = new TreeNode(rootVal);
        List<Integer> inOrderLeftTree = 
                inOrder.subList(0, rootIndex);
        List<Integer> inOrderRightTree = 
                inOrder.subList(rootIndex+1, inOrder.size());

        List<Integer> preOrderLeftTree = 
                preOrder.subList(1, inOrderLeftTree.size()-1);
        List<Integer> preOrderRightTree = 
                preOrder.subList(preOrderLeftTree.size()+1, preOrder.size());


        root.left = rebuildBinaryTreeRec(preOrderLeftTree,inOrderLeftTree);
        root.right = rebuildBinaryTreeRec(preOrderRightTree,inOrderRightTree);

        return root;
    }

    public static boolean isCompleteBinaryTree(TreeNode root){
        if(root==null){
            return false;
        }

        Queue<TreeNode> queue=new LinkedList<TreeNode>();
        TreeNode dummy = new TreeNode(0);
        TreeNode current = root;
        queue.offer(current);
        queue.offer(dummy);
        boolean noChild = false;

        while(!queue.isEmpty()){
            current = queue.poll();
            if(current==dummy){
                if(queue.isEmpty()){
                    break;
                }
                queue.offer(dummy);
            }

            if(current.left!=null){
                if(noChild){
                    return false;
                }
                queue.offer(current.left);
            }else{
                noChild = true;
            }
            if(current.right!=null){
                if(noChild){
                    return false;
                }
                queue.offer(current.right);
            }else{
                noChild = true;
            }
        }

        return true;
    }

    private static class ReturnBinaryTree{
        boolean isCompleteBT;
        boolean isPerfectBT;
        int height;

        ReturnBinaryTree(boolean isCompleteBT,boolean isPerfectBT,int height){
            this.isCompleteBT = isCompleteBT;
            this.isPerfectBT = isPerfectBT;
            this.height = height;
        }
    }

    public static ReturnBinaryTree isCompleteBinaryTreeRecHelp(TreeNode root){
        ReturnBinaryTree ret = new ReturnBinaryTree(true,true,-1);

        if(root==null){
            return ret;
        }

        ReturnBinaryTree leftRet = isCompleteBinaryTreeRecHelp(root.left);
        ReturnBinaryTree rightRet = isCompleteBinaryTreeRecHelp(root.right);

        ret.height = Math.max(leftRet.height,rightRet.height)+1;
        ret.isPerfectBT=leftRet.isPerfectBT
                &&rightRet.isPerfectBT&&leftRet.height==rightRet.height;

        ret.isCompleteBT = ret.isPerfectBT
                ||(leftRet.isCompleteBT&&rightRet.isPerfectBT&&leftRet.height==rightRet.height+1)
                ||(leftRet.isPerfectBT&&rightRet.isCompleteBT&&leftRet.height==rightRet.height);

        return ret;

    }

    public static int findLongest(TreeNode root){
        if(root==null){
            return -1;
        }

        int countLeft = 0;
        TreeNode left=root;
        if(left.left!=null){
            countLeft++;
            left=left.left;
        }

        int countRight=0;
        TreeNode right=root;
        if(right.right!=null){
            countRight++;
            right=right.right;
        }

        int longest = Math.max(findLongest(root.left), findLongest(root.right));
        longest = Math.max(longest, countRight);
        longest = Math.max(longest, countLeft);

        return longest;
    }
}
二叉树的练习题
AlinaQ05的博客
08-12 616
思路1：二叉树的递归，则是将某个节点的左子树、右子树看成一颗完整的树，那么对于子树的访问或者操作就是对于原树的访问或者操作的子问题，因此可以自我调用函数不断进入子树。思路2：使用辅助栈来存放每次遍历的根节点，弹出栈顶元素，然后判断该元素是否有左右子节点，有的话的加入栈中，优先加入右节点。给定一个二叉树，返回该二叉树层序遍历的结果，（从左到右，一层一层地遍历）给定的二叉树是{3,9,20,#,#,15,7},给定一个二叉树，返回他的后序遍历的序列。输入：{1,2,#,#,3}输入：{1,#,2,3}.....
二叉树的练习
heinara的博客
03-22 318
一、实验目的及要求 以下练习都需要用广度优先和深度优先算法实现一遍。 1：给定一棵二叉树，求二叉树的层数 2：给定一棵二叉树，求整棵树节点个数以及叶结点的个数 3：将树结点的数据域声明为int型，然后求出一棵树的最大值，最小值 （以上每一个题目的子题目都要用广度优先和深度优先实现） 二、实验内容及步骤 1、求二叉树的层数 （1） import circleSqQueue.QueueDemo; im...
二叉树练习
weixin_49038319的博客
08-22 1120
树的根节点及其子树，都是相对的概念。在任何一棵树中都有一个根节点，而这棵树本身又可以是别的树的子树。树的基本概念有：A)双亲和孩子：一个节点的后继节点被称为该节点的孩子，该节点称为这些孩子的双亲。B)结点的度：一个节点孩子的个数。C)兄弟：拥有双亲的节点互为兄弟节点；D）节点的层次：人为规定根节点的层次为1或0（具体看说明），他的后代节点得层依次加一。E）树的高度：树中结点层次的最大值。F）终端节点：树最末端的叶子节点。
二叉树练习题
最新发布
2302_76314368的博客
02-25 809
单值二叉树、检查两颗树是否相同、翻转二叉树、对称二叉树、另一棵树的子树、二叉树的前序遍历、二叉树的中序遍历、二叉树的后序遍历、利用前序遍历创建二叉树、根据前序和中序序列创建二叉树、根据后序和中序序列创建二叉树
二叉树习题
01-16
（1）非递归定义 树（tree）是由n（n≥0）个结点组成的有限集合。n=0的树称为空树；n＞0的树T： ① 有且仅有一个结点n0，它没有前驱结点，只有后继结点。n0称作树的根（root）结点。 ② 除结点外n0 ， 其余的每一个结点都有且仅有一个直接前驱结点；有零个或多个直接后继结点。 （2）递归定义 一颗大树分成几个大的分枝，每个大分枝再分成几个小分枝，小分枝再分成更小的分枝，… ，每个分枝也都是一颗树，由此我们可以给出树的递归定义。 树（tree）是由n（n≥0）个结点组成的有限集合。n=0的树称为空树；n＞0的树T： ① 有且仅有一个结点n0，它没有前驱结点，只有后继结点。n0称作树的根（root）结点。 ② 除根结点之外的其他结点分为m（m≥0）个互不相交的集合T0，T1，…，Tm-1，其中每个集合Ti（0≤i＜m）本身又是一棵树，称为根的子树（subtree）。 2、掌握树的各种术语： （1） 父母、孩子与兄弟结点 （2） 度 （3） 结点层次、树的高度 （4） 边、路径 （5） 无序树、有序树 （6） 森林 3、二叉树的定义 二叉树（binary tree）是由n（n≥0）个结点组成的有限集合，此集合或者为空，或者由一个根结点加上两棵分别称为左、右子树的，互不相交的二叉树组成。 二叉树可以为空集，因此根可以有空的左子树或者右子树，亦或者左、右子树皆为空。 4、掌握二叉树的五个性质 5、二叉树的二叉链表存储。
判断二叉树是否是平衡二叉树
qq_32534441的博客
03-23 388
二叉树的节点定义为 public class TreeNode { int val; TreeNode left; TreeNode right; TreeNode(int x) { val = x; } } 二叉树的深度：根节点到叶节点的最长路径长度 平衡二叉树：二叉树中任一节点的左右子树的深度相差不超过1 递归的方法代码如下： public bool...
二叉树——经典练习题
2302_81016149的博客
05-27 2646
二叉树的学习，我们目前就告一段落了，后续的进阶内容会在c++部分讲解。今天讲解的题目中最后三道难度较大，还望各位读者在学习完后能够多多练习，这样才能够掌握。如在学习中，有啥问题可在评论区交流，也可私信。期待与读者再会。完！
[C++算法入门]-二叉树打印练习题
09-26
该资源提供了入门级别的C++算法练习，旨在帮助读者熟悉二叉树的打印操作和相关算法。文档中包含了一系列的练习题，涵盖了二叉树的构建、遍历和打印等方面。 通过完成这些练习，读者将能够掌握二叉树的基本概念和...
二叉树的简单练习
m0_68989458的博客
05-13 548
二叉树的基础练习
二叉树及其练习题
2302_77179144的博客
02-21 862
文章目录树概念及结构树的概念树的相关概念树的表示形式树的应用二叉树概念及结构概念两种特殊的二叉树二叉树的性质二叉树的存储二叉树的基本操作二叉树的遍历前中后序遍历递归实现二叉树的基本操作二叉树相关oj题 树概念及结构 树的概念 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。 有一个特殊的结点，称为根结点，根节点没有前驱结点 除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2
二叉树（练习题）
c_study__c的博客
10-04 487
二叉树（练习题）
【数据结构练习】二叉树练习
m0_73067372的博客
03-19 1266
对两个二叉树同时进行深度优先搜索，只有当两个二叉树中的对应结点都不为空是才会访问该节点，因此被访问到的结点数不会超过较小的二叉树的节点数。空间复杂度取决于递归调用的层数，递归调用的层数不会超过较小的二叉树的最大高度，最坏情况下，二叉树的高度等于节点数。可能有多组测试数据，对于每组数据， 输出将输入字符串建立二叉树后中序遍历的序列，每个字符后面都有一个空格。的方式，将二叉树转化为一个由括号和整数组成的字符串，返回构造出的字符串。如果两个数在结构上相同，并且结点具有相同的值，则认为他们是相同的。
二叉树各种练习
sss2951的博客
10-19 796
树节点构造： public class BinaryTree { public Node root; public Node temp; public class Node{ int data; Node lchild; Node rchild; public Node(int data) { this.data=data; this.lchild=
二叉树习题集
btzxlin的博客
04-07 819
1.单值二叉树 965. 单值二叉树 - 力扣（LeetCode） (leetcode-cn.com) 如果二叉树每个节点都具有相同的值，那么该二叉树就是单值二叉树。 只有给定的树是单值二叉树时，才返回 true；否则返回 false。 /** * Definition for a binary tree node. * struct TreeNode { * int val; * struct TreeNode *left; * struct TreeNode *rig
二叉树相关练习题（C++）
DjangoBUAA的博客
04-09 4987
一、二叉树 1、用递归方法实现二叉树的先序、中序、后序遍历 class TreeToSequence { public:           void preOrder(TreeNode* root,vectorint> &pre) {          if (!root)              return;          pr
数据结构——二叉树练习题
weixin_49449676的博客
08-13 2890
4道二叉树OJ练习题
二叉树算法练习3
05-30
好的，我来为你讲解一下二叉树算法练习3。 题目描述： 给定一个二叉树，找出其最大深度。 示例： 输入：[3,9,20,null,null,15,7] 输出：3 解释：该二叉树的深度为3。 解题思路： 二叉树最大深度的求解可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值