数据结构【二叉树高频笔试题】

最新推荐文章于 2024-02-05 17:09:43 发布
最新推荐文章于 2024-02-05 17:09:43 发布
阅读量412 收藏
点赞数
分类专栏： 笔记 文章标签： 数据结构 java intellij-idea
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62764440/article/details/126379612
版权

[FKDWSJFS](HTTP//:WWW.MFKD .GS)

二叉树01-02

n0(叶子节点) = n2(度为2的节点)+1
import java.util.LinkedList;
import java.util.Queue;
/**
 * Created with IntelliJ IDEA.
 * User: 12629
 * Date: 2022/1/17
 * Time: 8:28
 * Description:
 */
public class Test {

    public static void main(String[] args) {
        BinaryTree binaryTree = new BinaryTree();
        TreeNode root = binaryTree.createTree();
        binaryTree.preOrder(root);
        System.out.println();
        binaryTree.inOrder(root);
        System.out.println();
        binaryTree.postOrder(root);
        System.out.println();
        System.out.println(binaryTree.size1(root));
        System.out.println(binaryTree.size(root));
        System.out.println("=========叶子节点的个数===========");
        binaryTree.getLeafNodeCount(root);
        System.out.println(BinaryTree.leafCount);
        System.out.println("============叶子节点个数===========");
        System.out.println(binaryTree.getKLevelNodeCount(root,1));
        System.out.println("==============树的高度======");
        System.out.println(binaryTree.getHeight(root));
        System.out.println("=====查找节点=======");
        try {
            TreeNode ret = binaryTree.find(root,'E');
            System.out.println(ret.val);
        }catch (NullPointerException e) {
            e.printStackTrace();
            System.out.println("没有这个节点！");
        }
        System.out.println("============是否是完全二叉树==============");
        System.out.println(binaryTree.isCompleteTree(root));


       /* Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(null);
        queue.offer(null);
        queue.offer(null);
        queue.offer(null);
        System.out.println(queue.size());*/
    }
}

import org.omg.CORBA.PUBLIC_MEMBER;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;

class TreeNode {
    public char val;
    public TreeNode left;//左孩子的引用
    public TreeNode right;//右孩子的引用
    public TreeNode(char val) {
        this.val = val;
    }
}

public class BinaryTree  {

    public TreeNode createTree() {
        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;
        C.left = F;
        C.right = G;
        E.right = H;
        return A;
    }

    // 前序遍历
    public void preOrder(TreeNode root) {
        if(root == null) {
            return;
        }
        System.out.print(root.val+" ");
        preOrder(root.left);
        preOrder(root.right);
    }
    
      // 中序遍历
    public  void inOrder(TreeNode root) {
        if(root == null) {
            return;
        }
        inOrder(root.left);
        System.out.print(root.val+" ");
        inOrder(root.right);
    }
    
     // 后序遍历
    public void postOrder(TreeNode root) {
        if(root == null) {
            return;
        }
        postOrder(root.left);
        postOrder(root.right);
        System.out.print(root.val+" ");
    }
    //shift+f6->回车才会生效

    public List<Character> preorderTraversal(TreeNode root) {
        List<Character> retlist = new ArrayList<>();
        if(root == null) {
            return retlist;
        }
        retlist.add(root.val);
        List<Character> leftTree = preorderTraversal(root.left);
        retlist.addAll(leftTree);

        List<Character> rightTree =preorderTraversal(root.right);
        retlist.addAll(rightTree);

        return retlist;
    }

    /*public List<Integer> inorderTraversal(TreeNode root) {
        List<Integer> retlist = new ArrayList<>();
        if(root == null) {
            return retlist;
        }
        List<Integer> leftTree = inorderTraversal(root.left);
        retlist.addAll(leftTree);

        retlist.add(root.val);


        List<Integer> rightTree =inorderTraversal(root.right);
        retlist.addAll(rightTree);

        return retlist;
    }*/

    //树的节点的个数
    int count = 0;
    public int size(TreeNode root){
        if (root == null) {
            return 0;
        }
        count++;
        size(root.left);
        size(root.right);
        return count;
    }

    public int size1(TreeNode root){
        if (root == null) {
            return 0;
        }
        return size(root.left)+size(root.right)+1;
    }

    /**
     * 获取叶子节点的个数
     * 遍历思路：
     */
    static int leafCount = 0;
    public void getLeafNodeCount(TreeNode root){
        if (root == null) {
            return 0;
        }
        if(root.left == null && root.right == null){
            leafCount++;
        }
        getLeafNodeCount(root.left);
        getLeafNodeCount(root.right);
    }

    /**
     * 获取叶子节点的个数
     * 子问题思路
     * @param root
     * @return
     */
    public int getLeafNodeCount1(TreeNode root){
        if (root == null) {
            return 0;
        }
        if(root.left == null && root.right == null){
            //当前的root是叶子节点
            return 1;
        }
        return getLeafNodeCount1(root.left) + getLeafNodeCount1(root.right);
    }

    /**
     * 获取第K层节点的个数
     * 子问题思路：
     *
     */
    public int getKLevelNodeCount(TreeNode root,int k) {
        if (root == null || k<= 0) {
            return 0;
        }
        if (k == 1) {
            return 1;
        }
        return getKLevelNodeCount(root.left,k-1)+getKLevelNodeCount(root.right,k-1);
    }

    /**
     * 获取二叉树的高度
     * 时间复杂度：O(n)
     * 空间复杂度：O()
     */
    public int getHeight(TreeNode root){
        if (root == null) {
            return 0;
        }
        int leftHeight = getHeight(root.left);
        int rightHeight = getHeight(root.right);
        return leftHeight > rightHeight ? leftHeight+1 :rightHeight+1;
        //return Math.max(getHeight(root.left),getHeight(root.right))+1;
    }
    /**
     * 检测值为value的元素是否存在
     */
    TreeNode find(TreeNode root, char val) {
        if(root == null) return null;
        if(root.val == val) return root;


        TreeNode ret = find(root.left,val);
        if(ret != null) {
            return ret;
        }
        ret = find(root.right,val);
        if(ret != null) {
            return ret;
        }
        return null;
    }
    /**
     * 是不是完全二叉树
     * @param root
     * @return
     */
    public 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 top = queue.peek();
            if (top != null) {
                return false;
            }
            queue.poll();
        }
        return true;
    }

    /*public List<Integer> postorderTraversal(TreeNode root) {
        List<Integer> retlist = new ArrayList<>();
        if(root == null) {
            return retlist;
        }
        List<Integer> leftTree = postorderTraversal(root.left);
        retlist.addAll(leftTree);



        List<Integer> rightTree =postorderTraversal(root.right);
        retlist.addAll(rightTree);


        retlist.add(root.val);


        return retlist;
    }*/

}
/**
 * Created with IntelliJ IDEA.
 * User: 12629
 * Date: 2022/1/17
 * Time: 8:28
 * Description:
 */

二叉树02

检查两颗树是否相同 https://leetcode-cn.com/problems/same-tree/

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(q.left,p.left) && isSameTree(q.left,q.right);
    }

另一颗树的子树 https://leetcode-cn.com/problems/subtree-of-another-tree/

//判两棵树是否i相同
    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;
        }
        //根节点和subRoot是不是两颗相同的树
        if (isSameTree(root, subRoot)) {
            return true;
        }
        //subRoot是不是root的左子树
        if (isSubtree(root.left, subRoot)) {
            return true;
        }
        //subRoot是不是root的右子树
        if (isSubtree(root.right, subRoot)) {
            return true;
        }
        return false;
    }

判断一颗二叉树是否是平衡二叉树 https://leetcode-cn.com/problems/balanced-binary-tree/

//求左树和树的高度，时间复杂度:O(n);
    public int height(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftHeight = height(root.left);
        int righttHeight = height(root.right);
        return (leftHeight > righttHeight) ? (leftHeight + 1) : (righttHeight + 1);
    }

    //判断是不是平衡二叉树，书记兼复杂度：O(n^2);
    public boolean isBalanced(TreeNode root) {
        if(root == null) return true;
        int left = height(root.left);
        int right = height(root.right);
        return Math.abs(left-right) <= 1 && isBalanced(root.left) && isBalanced(root.right);
    }

    //求左树和树的高度，时间复杂度:O(n);
    public int height2(TreeNode root) {
        if(root == null) {return 0;}
        int leftHeight = height2(root.left);
        int righttHeight = height2(root.right);

        if(leftHeight >= 0 && righttHeight >= 0 && Math.abs(leftHeight-righttHeight) <= 1){
            return Math.max(leftHeight,righttHeight)+1;
        }else{
            //说明不平衡
            return -1;
        }
    }
//时间复杂度O(n)
    public boolean isBalanced2(TreeNode root) {
        if(root == null)  return true;
        return height2(root) >= 0;
    }

判断是不是对称二叉树https://leetcode-cn.com/problems/symmetric-tree/

 public boolean isSymmetricChild(TreeNode leftTree,TreeNode rightTree){
        if(leftTree == null && rightTree != null) return false;
        if(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);
    }
    public boolean isSymmetric(TreeNode root) {
        i
    }

二叉树遍历https://www.nowcoder.com/practice/4b91205483694f449f94c179883c1fef

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-f79btSxw-1660701594371)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1643174270287.png)]

import java.util.Scanner;
class TreeNode1{
    public char val;
    public TreeNode1 left;
    public TreeNode1 right;

    public TreeNode1(char val){
        this.val = val;
    }
}
public class Main{
    public static int i = 0;
    public static TreeNode1 creatTree(String str){
        TreeNode1 root = null;
        if(str.charAt(i) != '#'){
            root = new TreeNode1(str.charAt(i));
            i++;
            root.left= creatTree(str);
            root.right= creatTree(str);
        }else{
            i++;
        }
        return root;
    }
    public static void inorder(TreeNode1 root){
        if (root == null) {
            return;
        }
        inorder(root.left);
        System.out.print(root.val+" ");
        inorder(root.right);
    }

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        while(in.hasNextLine()){
            String str = in.nextLine();
            TreeNode1 root = creatTree(str);
            inorder(root);
        }
    }
}

二叉树的分层遍历(层序遍历) https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

public void levelOrder(TreeNode root){
        Queue<TreeNode> queue = new LinkedList<>();
        if(root == null) return;
        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);
            }
        }
     }

     public List<List<Integer>> levelOrder2(TreeNode root){
         List<List<Integer>> ret = new ArrayList<>();
         if(root == null) return ret;
         Queue<TreeNode> queue = new LinkedList<>();
         queue.offer(root);
         while(!queue.isEmpty()){
             int size = queue.size();//代表当前层有多少个节点
             List<Integer> list = new ArrayList<>();
             while (size != 0) {
                 TreeNode cur = queue.poll();
                 //list.add(cur.val); //Oj上要放开注释；
                 if (cur.left != null) {
                     queue.offer(cur.left);
                 }
                 if (cur.right != null) {
                     queue.offer(cur.right);
                 }
                 size--;
             }
             ret.add(list);
         }
         return ret;
     }

二叉树03

二叉树的最近公共祖先 https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-GveULd7i-1660701703576)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1644393501978.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-h9vyLyi5-1660701656064)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1644393536786.png)]

/**
     * 最近公共祖先
     * 思路一
     */
    public TreeNode lOwestCommonAncestor(TreeNode root,TreeNode p,TreeNode q){
        if (root == null) {
            return null;
        }
        if (root == p || root == q) {
            return root;
        }
        TreeNode leftT = lOwestCommonAncestor(root.left,p,q);
        TreeNode rightT = lOwestCommonAncestor(root.right,p,q);
        if (leftT != null && rightT != null) {
            return root;
        } else if (leftT != null) {
            return leftT;
        }else{
            return rightT;
        }
    }

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-C0SxjZbw-1660701656065)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1644394758697.png)]

/**
     * 最近公共祖先
     * 思路二
     */
     // root:根节点     node:指定的节点        stack:存放根节点到指定节点的路径
    public boolean getPath(TreeNode root,TreeNode node,Stack<TreeNode> stack){
        if(root == null || node == null) return false;
        stack.push(root);
        if(root == node) return true;
        boolean flag = getPath(root.left,node,stack);
        if (flag) {
            return true;
        }
        flag = getPath(root.right,node,stack);
        if (flag) {
            return true;
        }
        stack.pop();
        return false;
    }

    public TreeNode lOwestCommonAncestor1(TreeNode root,TreeNode p,TreeNode q){
        if(root == null)  return null;
        Stack<TreeNode> stack1 = new Stack<>();
        getPath(root,p,stack1);
        Stack<TreeNode> stack2 = new Stack<>();
        getPath(root,q,stack2);
        int size1 = stack1.size();
        int size2 = stack2.size();
        if (size1 > size2) {
            int size = size1 - size2;
            while (size != 0) {
                stack1.pop();
                size--;
            }
            while(!stack1.isEmpty() && !stack2.isEmpty()){
                if (stack1.peek() == stack2.peek()) {
                    return stack1.pop();
                }else{
                    stack1.pop();
                    stack2.pop();
                }
            }
        }else{
            int size = size2 - size1;
            while (size != 0) {
                stack1.pop();
                size--;
            }
            while(!stack1.isEmpty() && !stack2.isEmpty()){
                if (stack1.peek() == stack2.peek()) {
                    return stack1.pop();
                }else{
                    stack1.pop();
                    stack2.pop();
                }
            }
        }
        return null;
    }

二叉树搜索树转换成排序双向链表 https://www.nowcoder.com/practice/947f6eb80d944a84850b0538bf0ec3a5

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-II2ROyZb-1660701656065)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1644395602024.png)]

    //二叉搜索树转换为排序的双向链表
    TreeNode prev = null;
    public void inorder(TreeNode pCur){
        if(pCur == null) return;
        inorder(pCur.left);
        //打印
        pCur.left = prev;
        if (prev != null) {
            prev.right = pCur;
        }
        prev = pCur;
        inorder(pCur.right);
    }


    public TreeNode Covert(TreeNode pRootOfTree){
        if(pRootOfTree == null) return null;
        inorder(pRootOfTree);
        TreeNode head = pRootOfTree;
        while (head.left != null) {
            head = head.left;
        }
        return head;
    }
从前序与中序遍历序列构造二叉树
从中序与后序遍历序列构造二叉树
根据二叉树创建字符串
public void treeToString(TreeNode t,StringBuilder sb){
        if(t == null) return;
        sb.append(t.val);
        if (t.left != null) {
            sb.append("(");
            treeToString(t.left,sb);
            sb.append(")");
        }else{
            //t.left == null
            if (t.right == null) {
                return;
            }else{
                sb.append("()");
            }
        }
        if(t.right == null){
            return;
        }else{
            sb.append("(");
            treeToString(t.right,sb);
            sb.append(")");
        }
    }

    public String tree2str(TreeNode root){
        if(root == null) return null;
        StringBuilder sb = new StringBuilder();
        treeToString(root,sb);
        return sb.toString();
    }
}

二叉树04

二叉树的非递归前序遍历

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Etvl1piN-1660701732449)(C:\Users\Administrator\AppData\Roaming\Typora\typora-user-images\1644639857784.png)]

 public List<Integer> preoderTraversal(TreeNode root){
        List<Integer> ret = new ArrayList<>();
        Stack<TreeNode> stack = new Stack<>();
        TreeNode cur = root;
        while (cur != null || !stack.isEmpty()) {
            while(cur != null){
                stack.push(cur);
                //System.out.println(cur.val+" ");
                ret.add(cur.val);
                cur = cur.left;
            }
            TreeNode top = stack.pop();
            cur = top.right;
        }
        return ret;
    }
二叉树的前序遍历
 public List<Integer> inoderTraversal(TreeNode root){
        List<Integer> ret = new ArrayList<>();
        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.println(cur.val+" ");
            ret.add(top.val);
            cur = top.right;
        }
        return ret;
    }
二叉树的后序遍历
 public List<Integer> postoderTraversal(TreeNode root) {
        List<Integer> ret = new ArrayList<>();
        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) {
                stack.pop();
                //System.out.println(cur.val+" ");
                ret.add(top.val);
                prev = top;//记录一下最近一次打印的节点
            } else {
                cur = top.right;
            }
        }
        return ret;
    }
留在梦里
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构二叉树，c语言简单实现
01-12
数据结构二叉树，c语言简单实现
二叉搜索树经典笔试题【力扣、牛客】
A progressive ape!
09-16 272
二叉树经典笔试题【C++】
二叉树笔试题（一）
Nan_Feng726的博客
06-06 1072
1、二叉树的前序遍历、中序遍历、后序遍历 思路： 在二叉树那篇文章里已经介绍过，这里直接看代码： private ArrayList<Integer> list; //1、前序 private void preorder(TreeNode root) { if (root != null) { list.add(root.val...
二叉树经典题题解（超全题目）（力扣）
2301_79293429的博客
02-05 1382
二叉树超全题目
二叉树类型笔试面试题大总结（含代码）
844604778
10-15 287
一、二叉树的遍历-前序、中序、后序以及层次遍历（递归与非递归） 参考另外一篇笔记《二叉树的遍历-递归与非递归 -海子 - 博客园》。 二、重建二叉树，依据前序遍历结果和中序遍历结果 《剑指Offer》面试题6. 思想：递归 代码： // 《剑指Offer——名企面试官精讲典型编程题》代码 // 著作权所有者：何海涛 struct BinaryTreeNode { i...
二叉树的常见笔试面试题
Nessie_zhao的博客
05-16 4808
在二叉树的基本操作里已经说明如何用递归的方法进行二叉树的遍历，那么如何用非递归的方法来进行二叉树的遍历呢，请看下文1.使用非递归方式进行二叉树的先序遍历![这里写图片描述](//img-blog.csdn.net/20180429152827371?watermark/2/text/Ly9ibG9nLmNzZG4ubmV0L05lc3NpZV96aGFv/font/5a6L5L2T/fontsiz...
轻松搞定面试中的二叉树题目
热门推荐
计算机的艺术
08-29 26万+
版权所有，转载请注明出处，谢谢！ http://blog.csdn.net/walkinginthewind/article/details/7518888 树是一种比较重要的数据结构，尤其是二叉树。二叉树是一种特殊的树，在二叉树中每个节点最多有两个子节点，一般称为左子节点和右子节点（或左孩子和右孩子），并且二叉树的子树有左右之分，其次序不能任意颠倒。二叉树是递归定义的，因此，与二叉树有关
数据结构二叉树功能展示
06-02
数据结构二叉树功能展示包括以完全前序序列创建二叉树"; cout以前序和中序序列创建二叉树"; cout前序遍历二叉树"; cout中序遍历二叉树"; cout后序遍历二叉树"; cout广度优先遍历二叉树"; cout求某结点的双亲";...
数据结构 二叉树运算的实现
05-16
数据结构大作业，二叉树运算的实现，用c语言完成。包括创建二叉树，得到二叉树深度，得到叶子节点数目，得到先序遍历序列，得到中序遍历序列，得到后序遍历序列，得到层次遍历序列，得到交换左右子树后的序列。仅供...
数据结构-二叉树基础.pdf
最新发布
04-15
数据结构 -二叉树基础.pdf
数据结构——二叉树
02-06
该文件包括二叉树的头文件（BitTree开头）和堆栈的头文件（Seq开头），另外还实现了编写按层次顺序（同一层自左至右）遍历二叉树的算法、后序递归遍历计算二叉树的深度的算法、判断给定二叉树是否为完全二叉树（通过...
蓝桥杯必考数据结构之树和二叉树 && 期末考试重点考察内容
安然无虞的博客
12-02 6500
欢迎回到：遇见蓝桥遇见你，不负代码不负卿！ 【声明】 开头笔者要向铁汁们致歉，我没有把这些知识点顺序安排好，因为我也是刚写博客一个多月，所以很多东西正在慢慢熟悉，很抱歉给铁汁们带来不便，后面笔者会尽力整改，等到基础知识点讲解完再重新布局。抱拳了哈诸位。 【前言】 对于数据结构这块的话，蓝桥杯考的其实不是很多，但是二叉树是必考的数据结构，没有之一！当然后面还有一个高阶数据结构叫并查集，其实就是树的升级版本——森林，之后再说。所以二叉树这块特别特别重要，笔者也花了老长时间整理才出这篇博...
笔试面试高频考点 12道经典题目带你走进 二叉树（2）——数据结构
honglan297的博客
07-04 460
本篇文章紧接上集 通过 12 道二叉树经典题目的讲解，希望能让你对于面试、笔试中二叉树相关题目不再毫无头绪，收获自己独特的见解和思路，更好理解二叉树本身
【数据结构与算法面试题】二叉树镜像
null的专栏
06-15 210
题目来源“数据结构与算法面试题80道”。 问题分析：实质上仍然是二叉树的遍历，上述已经介绍过二叉树的不同的遍历方法，当遍历到每一个节点的时候，交换其左右子树，依次下去，直到叶子节点。 方法： 1、递归的方法： void tree_swap(BSTreeNode *root){ BSTreeNode *p_tmp = root->m_pLeft; root->m_pLeft = root->m_pRight; root->m_pRight = p_tmp;.
【数据结构与算法题目集】7-23 还原二叉树 （25 分）
mdjfk的博客
11-21 212
给定一棵二叉树的先序遍历序列和中序遍历序列，要求计算该二叉树的高度。 输入格式: 输入首先给出正整数N（≤50），为树中结点总数。下面两行先后给出先序和中序遍历序列，均是长度为N的不包含重复英文字母（区别大小写）的字符串。 输出格式: 输出为一个整数，即该二叉树的高度。 输入样例: 9 ABDFGHIEC FDHGIBEAC 输出样例: 5 前序：根、左子树、右子树 中序...
剖析二叉树常考笔试题
weixin_33859231的博客
10-06 118
前沿： 前段时间参加了:小米、东软、百度的笔试,多家公司都出了一道类似二叉树题来考查笔试者对二叉树基础掌握的情况。 一：笔试题描述 1:有一颗二叉树：前序遍历输出的字符串顺序为:ABCDEFG 中序遍历输出的...
【数据结构和算法】常见的数据结构笔试题
zzf_forgot的博客
09-20 943
队列 假设以数组A[60]存放循环队列的元素,其头指针是front=47,当前队列有50个元素,则队列的尾指针值为() 队列中元素的个数： (rear-front+QueueSize)%QueueSize 根据题意得：（rear - 47 + 60）% 60 = 50 => rear = 37 栈 在一个栈的输入序列为12345 下面哪个不可能是栈的输出序列...
二叉树数常见笔试题汇总（遍历，最大深度，反向构造，共同祖先，对称判断，路经总和，序列化及反序列化操作） c++实现
weixin_42034081的博客
04-18 606
二叉树1.二叉树结构体定义2.反序列化与序列化2.1 反序列化2.2 序列化2.3 层序遍历2.4 测试3. 遍历3.1 前序及测试3.2 中序及测试3.3 后序及测试4.反向构造4.1 由中序和前序反向构造4.2 由中序和后序反向构造 1.二叉树结构体定义 struct TreeNode { int val; TreeNode* left; TreeNode* right; TreeNode() : val(0), left(nullptr), right(nullptr) {} TreeNod
二叉树经典练习题合集(Java实现)
qq_58284486的博客
03-22 1718
二叉树的问题大多是以递归思想求解，也可以利用迭代思想利用队列实现，熟练运用递归对于解决二叉树问题十分重要，本篇博客为一些基础的二叉树问题，对于理解二叉树的结构以及递归思想有着很大的帮助. 本篇文章所有的代码已上传至gitee中：二叉树OJ练习 目录 树的重要概念总结 相同的树 另一颗树的子树 二叉树的最大深度 平衡二叉树 对称二叉树 迭代实现(利用队列实现) 递归实现 二叉树的层次遍历 树的重要概念总结 ①结点的度：一个结点含有子树的个数称为该结点的度； ②树...
数据结构编程题二叉树
08-19
二叉树是一种常见的数据结构，它由一组节点组成，每个节点包含一个值和指向左右子节点的指针。在提供的引用中，我们可以看到一些与二叉树相关的代码和函数。 首先，在引用中，我们可以看到一个定义了二叉树节点的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值