【数据结构】二叉树前中后层序遍历代码实现以及各种操作与二叉树OJ题目

最新推荐文章于 2024-08-17 19:33:32 发布
最新推荐文章于 2024-08-17 19:33:32 发布
阅读量778 收藏 1
点赞数
分类专栏： Java 文章标签： 数据结构 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_61903414/article/details/131961794
版权

目录

一、二叉树的遍历

1、前序遍历

2、后续遍历

3、中序遍历

二、二叉树简单的操作

1、计算节点个数

1.二叉树所有节点个数

2.二叉树叶子节点个数

3.二叉树第K层节点个数

2、二叉树的高度

3、二叉树是否存在key

1.二叉树中是否存在key

2.寻找二叉树中key节点

三、二叉树OJ题目

1、力扣OJ：相同的树

2、力扣OJ：另一颗树的子树

3、力扣OJ：平衡二叉树

4、力扣OJ：对称二叉树

5、力扣OJ：层序遍历

6、牛客OJ：完全二叉树

一、二叉树的遍历

1、前序遍历

二叉树的前序遍历，顾名思义就是将根节点放在最前面进行遍历，也就是先遍历跟节点，然后再遍历左节点，最后右节点。如下图，按照前序遍历对这棵树进行遍历，我们先要遍历跟节点，然后左子树最后右子树 1-》2 -》4 -》8 -》5 -》9 -》 3 -》6 -》 7

144. 二叉树的前序遍历 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/binary-tree-preorder-traversal/

/**
 * 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<Integer> preorderTraversal(TreeNode root) {
        // 1. 创建List
        List<Integer> res = new ArrayList<>();
        // 2. 判断如果为空则直接返回
        if (root == null) {
            return res;
        }

        // 3. 先将根节点的值存入List
        res.add(root.val);
        // 4. 再去遍历他的左子树，将遍历的结果存入List
        res.addAll(preorderTraversal(root.left));
        // 5. 最后遍历右子树，再将结果存入List
        res.addAll(preorderTraversal(root.right));
        // 6. 最后返回
        return res;
    }
}

2、后序遍历

与前序遍历不同的是后序遍历是先遍历左节点然后右节点最后遍历根节点

145. 二叉树的后序遍历 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/binary-tree-postorder-traversal/

/**
 * 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<Integer> postorderTraversal(TreeNode root) {
        // 1. 创建List
        List<Integer> res = new ArrayList<>();
        // 2. 如果根节点为空则直接返回
        if (root == null) {
            return res;
        }

        // 3. 遍历左子树并将结果存入List
        res.addAll(postorderTraversal(root.left));
        // 4. 遍历右子树并将结果存入List
        res.addAll(postorderTraversal(root.right));
        // 5. 最后遍历根节点
        res.add(root.val);
        // 6. 返回List
        return res;
    }
}

3、中序遍历

中序遍历就是先遍历左节点，然后遍历根节点，最后再遍历右节点

94. 二叉树的中序遍历 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/binary-tree-inorder-traversal/

/**
 * 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<Integer> inorderTraversal(TreeNode root) {
        // 1. 创建List存储数据
        List<Integer> res = new ArrayList<>();
        // 2. 如果根节点为空则直接返回res
        if (root == null) {
            return res;
        }

        // 3. 先遍历左子树，将左子树的数据存入List
        res.addAll(inorderTraversal(root.left));
        // 4. 再遍历根节点
        res.add(root.val);
        // 5. 最后遍历右子树
        res.addAll(inorderTraversal(root.right));
        // 6. 返回数据
        return res;
    }
}

二、二叉树简单的操作

1、计算节点个数

1.二叉树所有节点个数

在计算节点个数的时候，采用子问题法将二叉树看作若干个子二叉树，则节点个数=当前节点的左子树个数+右子树节点个数+1，此时我们只需要进行递归遍历即可

    public int size(TreeNode root) {
        // 1. 如果根节点为空则返回0
        if (root == null) {
            return 0;
        }
        
        // 2. 节点个数 = 左子树节点个数 + 右子树节点个数 + 1（自身）
        return size(root.left) + size(root.right) + 1;
    }

2.二叉树叶子节点个数

与上树不同的是，我们只需计算叶子节点个数即可，那么叶子节点有什么特点呢，他的左右节点都为null，根据这一特点，我们可以知道一颗二叉树的叶子节点个数就 = 左子树叶子节点个数 + 右子树叶子节点个数

    public int leafSize(TreeNode root) {
        // 1. 如果根节点为空则返回0
        if (root == null) {
            return 0;
        }
        
        // 2. 如果该节点是叶子节点 则返回0
        if (root.left == null && root.right == null) {
            return 1;
        }
        
        // 3. 叶子节点 = 左子树叶子节点个数 + 右子树叶子节点个数
        return leafSize(root.left) + leafSize(root.right);
    }

3.二叉树第K层节点个数

我们在遍历整个树的过程中，第k层节点的个数 = 左子树第k层的个数 + 右子树第k层的个数

    public int getKSize(TreeNode root, int k) {
        // 1. 如果根节点是空则返回0
        if (root == null) {
            return 0;
        }
        
        // 2. 如果此时是第k层节点，则返回1
        if (k == 1) {
            return 1;
        }

        // 3. 第k层节点个数 = 左子树k层个数 + 右子树k层个数
        return getKSize(root.left,k - 1) + getKSize(root.right, k - 1);
    }

2、二叉树的高度

二叉树的高度其实就是左子树与右子树两个树的最大高度+1，而左子树的高度也就是左子树的左子树与左子树的右子树高度最大值+1

    public int height(TreeNode root) {
        // 1. 如果根节点为空则返回0
        if (root == null) {
            return 0;
        }
        
        // 2. 树的高度 = max（左子树高度，右子树高度） + 1
        return Math.max(height(root.left),height(root.right)) + 1;
    }

3、二叉树是否存在key

1.二叉树中是否存在key

二叉树中是否存在key，我们可以在遍历的时候进行判断，如果存在则返回，只要左子树或者右子树中的一个有就存在

    public boolean contains(TreeNode root, int key) {
        // 如果根节点为空，则返回false
        if (root == null) {
            return false;
        }

        // 如果相同则存在
        if (root.val == key) {
            return true;
        }

        return contains(root.left,key) || contains(root.right,key);
    }

2.寻找二叉树中key节点

在上面操作的基础上，我们如果发现这个节点后可直接将该节点进行返回

    public TreeNode find(TreeNode root, int key) {
        // 1. 如果根节点为空则不存在
        if (root == null) {
            return null;
        }

        // 2. 如果找到则直接返回该节点
        if (root.val == key) {
            return root;
        }

        // 3. 遍历左子树寻找该节点
        TreeNode left = find(root.left,key);
        if (left != null) {
            // 3.1 找到则返回
            return left;
        }

        // 4. 遍历右子树寻找该节点
        TreeNode right = find(root.right,key);
        if (right != null) {
            // 4.1 找到则返回
            return right;
        }

        // 5. 走到此处说明左子树与右子树都没有，则返回null
        return null;
    }

三、二叉树OJ题目

1、力扣OJ：相同的树

100. 相同的树 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/same-tree/

判断两颗二叉树是否相同，我们只需在遍历时判断这两棵树是否相同，可能存在以下几种情况 

 

/**
 * 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 isSameTree(TreeNode p, TreeNode q) {
        // 1. 如果都为空则相同
        if (p == null && q == null) return true;

        // 2. 如果一个有节点 一个没有则不相同
        if (p == null && q != null || q == null && p != null) return false;

        // 3. 如果节点的值不同,则两个树不相同
        if (p.val != q.val) return false;

        // 4. 此时说明根节点相同，还需要满足左子树相同并且右子树也相同
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
}

2、力扣OJ：另一颗树的子树

572. 另一棵树的子树 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/subtree-of-another-tree/

 

我们需要拿着子树与二叉树的根节点进行比较，看是否是相同的树，如果不是则与他的左子树进行比较，如果也不是则与他的右子树进行比较，以此类推，所有此处我们需要使用上一题的代码 

/**
 * 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 isSameTree(TreeNode p,TreeNode q) {
         // 1. 如果都为空则相同
        if (p == null && q == null) return true;

        // 2. 如果一个有节点 一个没有则不相同
        if (p == null && q != null || q == null && p != null) return false;

        // 3. 如果节点的值不同,则两个树不相同
        if (p.val != q.val) return false;

        // 4. 此时说明根节点相同，还需要满足左子树相同并且右子树也相同
        return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
    }
    public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        // 1. 如果两个树其中一个是空则返回false
        if (root == null || subRoot == null) return false;

        // 2. 只要他与根节点 或者 左子树 或者 右子树 其中一个树相同，则他就是子树
        return isSameTree(root,subRoot) || isSubtree(root.left,subRoot) || isSubtree(root.right,subRoot);
    }
}

3、力扣OJ：平衡二叉树

110. 平衡二叉树 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/balanced-binary-tree/

以下是对平衡二叉树的定义 

那么判断一棵树是否是平衡二叉树，只需要根节点是平衡二叉树且他的左右子树都是平衡二叉树即可，因为需要判断左右子树的高度差，所有我们需要将前面求树的高度的代码用在此处 

/**
 * 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 {
    private int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }

        return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
    }

    public boolean isBalanced(TreeNode root) {
        // 1. 如果根节点为空则返回真
        if (root == null) {
            return true;
        }

        // 2. 根节点满足 && 左右子树满足
        return Math.abs(maxDepth(root.left) - maxDepth(root.right)) <= 1 && isBalanced(root.left) && isBalanced(root.right);
    }
}

 但是上述代码的时间复杂度O(n^2)，那么可以优化上述代码吗，我们在上述代码中在求左右子树高度的时候其实可以在递归遍历的时候进行处理，当求高度递归过程中发现存在根节点的左右子树高度差不满足<=1时就可返回一个负值表示，该二叉树中存在不平衡的子树，进而根据求高度时的返回值来判断是否是平衡二叉树了。这种实现方式时间复杂度则为O(n)

 

/**
 * 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 {
    private int maxDepth(TreeNode root) {
        // 1. 如果根节点为空则高度为0
        if (root == null) {
            return 0;
        }

        // 2. 计算左右子树高度
        int left = maxDepth(root.left);
        int right = maxDepth(root.right);
        // 3. 判断是否满足平衡二叉树
        if (left != -1 && right != -1 &&Math.abs(left - right) <= 1) {
            return Math.max(left,right) + 1;
        } else {
            // 3.1 不满足则返回-1
            return -1;
        }
    }

    public boolean isBalanced(TreeNode root) {
        // 1. 如果根节点为空则返回真
        if (root == null) {
            return true;
        }

        // 2. 根据求高度时返回值判断
        return maxDepth(root) >= 0;
    }
}

4、力扣OJ：对称二叉树

101. 对称二叉树 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/symmetric-tree/

我们只需要判断根节点的左右子树是否对称即可 

/**
 * 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) {
        // 1. 处理特殊情况
        if (root == null) {
            return true;
        }
        
        // 2. 只要左子树与右子树对称即可
        return isSymmetric(root.left,root.right);
    }

    private boolean isSymmetric(TreeNode root1,TreeNode root2) {
        // 1. 如果两颗树都为空则对称
        if (root1 == null && root2 == null) return true;

        // 2. 如果一棵树为空另一颗树不为空则不对称
        if (root1 == null && root2 != null || root1 != null && root2 == null) return false;

        // 3. 如果值不相同也不对称
        if (root1.val != root2.val) return false;

        // 4. 最后递归判断root1的左子树与root2的右子树，root1的右子树与root2的左子树是否相同
        return isSymmetric(root1.left,root2.right) && isSymmetric(root1.right,root2.left);
    }
}

5、力扣OJ：层序遍历

102. 二叉树的层序遍历 - 力扣（LeetCode）icon-default.png?t=N6B9https://leetcode.cn/problems/binary-tree-level-order-traversal/二叉树的层序遍历，此处我们使用队列来进行处理

 

 

 

/**
 * 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<List<Integer>> levelOrder(TreeNode root) {
        // 1. 如果根节点为空则直接返回
        List<List<Integer>> res = new ArrayList<>();
        if (root == null) {
            return res;
        }

        // 2. 将根节点存入队列
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        // 3. 循环处理
        while (!queue.isEmpty()) {
            // 3.1 计算该层元素个数
            int size = queue.size();
            List<Integer> row = new ArrayList<>();

            // 3.2 开始将该层元素存入row，并将下一层元素存入queue
            while (size-- != 0) {
                // 3.2.1 弹出队顶元素
                TreeNode top = queue.poll();
                // 3.2.2 将值存入row
                row.add(top.val);
                // 3.2.3 将下一层节点存入queue
                if (top.left != null) queue.offer(top.left);
                if (top.right != null) queue.offer(top.right);
            }

            // 3.3 将row存入res
            res.add(row);
        }

        // 4. 返回
        return res;
    }
}

6、牛客OJ：完全二叉树

判断是不是完全二叉树_牛客题霸_牛客网 (nowcoder.com)icon-default.png?t=N6B9https://www.nowcoder.com/practice/8daa4dff9e36409abba2adbe413d6fae?tpId=196&tqId=39379&ru=/exam/oj

以上是对完全二叉树的定义，我们此处也可以使用队列来处理，按照层序遍历的方法进行处理，不过在存入根节点的左右子树时不进行null值判断，也就是将null值也存入，最后通过判断队列里的元素是否全是null来判断是否是完全二叉树，如果是完全二叉树，按照层序遍历方式处理完队列中剩余元素全是null，而如果不是完全二叉树则不仅仅只要null 

 

 

 

 

上述 以不完全二叉树进行举例，可将完全二叉树进行上述操作，发现结果中队列里全为null

import java.util.*;

/*
 * public class TreeNode {
 *   int val = 0;
 *   TreeNode left = null;
 *   TreeNode right = null;
 *   public TreeNode(int val) {
 *     this.val = val;
 *   }
 * }
 */

public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param root TreeNode类 
     * @return bool布尔型
     */
    public boolean isCompleteTree (TreeNode root) {
        // 1. 特殊处理
        if (root == null) {
            return true;
        }

        // 2. 创建队列，将根节点存入队列
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);

        // 3. 开始操作
        while (!queue.isEmpty()) {
            // 3.1 弹出队首元素
            TreeNode top = queue.poll();
            if (top != null) {
                // 3.1.2 将左右节点存入
                queue.offer(top.left);
                queue.offer(top.right);
            } else {
                // 3.1.3 出现null 结束循环
                break;
            }
        }

        // 4. 开始判断队列中是否全是null
        while (!queue.isEmpty()) {
            TreeNode top = queue.peek();
            if (top != null) {
                return false;
            } else {
                queue.poll();
            }
        }

        return true;
    }
}

 后续题目正在补充中……

1886i
关注
专栏目录
【数据结构入门】链式二叉树的遍历及相关接口的实现
codewinter的博客
03-01 1107
文章目录前言一、二叉树的链式结构二、二叉树的遍历方式1.1 遍历方式的规则1.2 前序遍历1.3 中序遍历1.4 后序遍历1.5 层序遍历三、二叉树的相关接口实现3.1 二叉树节点个数3.2 二叉树叶子节点个数3.3 二叉树第 k 层节点个数3.4 二叉树的深度(高度)3.5 二叉树查找值为 x 的节点3.6 总结 & 注意四、二叉树的创建和销毁4.1 通过前序遍历的字符串来构建二叉树4.2 二叉树销毁4.3 判断二叉树是否是完全二叉树 前言 二叉树的顺序结构就是用数组来存储，而「数组」一般只适合表
【数据结构】二叉树的链式结构（前序遍历）（中序遍历）（后序遍历）（层序遍历）
m0_57018588的博客
12-16 1036
二叉树的链式结构，前序遍历，中序遍历，后序遍历，层序遍历的实现
二叉树的前序中序后序遍历代码
01-03
用C语言实现数据结构中二叉树的前序中序后序遍历 int main()//主函数部分 { BiTree T=NULL; int Layer=0; int LayerT=0; printf("请输入二叉树：\n"); CreatBiTree(&T);printf("你输入的二叉树为：(竖型树状表示)\n"); PrintBinary(T,Layer); printf("\n"); printf("先序遍历二叉树为：\n"); PreOrderTraverse(T); printf("\n"); printf("中序遍历二叉树为：\n"); InOrderTraverse(T); printf("\n"); printf("后序遍历二叉树为：\n"); PostOrderTraverse(T); printf("\n"); printf("二叉树转换为树显示出来为：(竖型树状表示)\n"); PrintTree(T,LayerT); system("pause"); return 0; }
二叉树的前序遍历，中序遍历，后序遍历-详解-配套例题
热门推荐
爱吃橘子的小翟
04-03 1万+
二叉树作为数据结构中一种简单而且重要的数据结构，他的存储结构和算法都相对比较简单，因此他也显得特别重要，因为很多问题都可以抽象为二叉树的问题。 在这里我们对于二叉树的基本概念不做详细介绍，我们这里主要介绍二叉树的前序遍历，中序遍历，和后序遍历三种问题和如何通过他的前序遍历，中序遍历，后序遍历构造相应的二叉搜索树的问题。 在这之前，我们先简单了解一下二叉树的三种遍历到底是什么样子的。 我的记忆方式为： 前序遍历-DLR（根...
二叉树系列题目（包含 深度，广度，先序，中序，层次遍历）
最新发布
wrs__lele的博客
08-17 677
树的深度优先遍历最简单的实现方式是实现。从根节点出发依次遍历根节点的每颗子树，对于子树可以视作一颗新的树采用相同的策略继续往下遍历子树的子树，直到无子树为止。
二叉树的前中后序遍历(考试常考)
qq_59774127的博客
11-19 2013
讲解二叉树三种遍历方式以及根据两种遍历方式重构二叉树的方法
二叉树的遍历——前序、中序，后序，层次遍历以及相关题解
Concise200的博客
11-28 2823
二叉树的遍历结点类型1. 前序遍历（preorder traversal）2. 中序遍历（inorder traversal）3. 后序遍历（postorder traversal）4. 三者区别5. 根据前序遍历中序遍历重构二叉树4.1 解法一算法思想代码时间复杂度分析4.2 解法二代码 结点类型 struct TreeNode { int val; TreeNode *left; //左子 TreeNode *right; //右孩子 TreeNode(int x) : val(x), le
二叉树之前序、中序、后序遍历(结合图解例题包你看懂)
qq_41570752的博客
09-13 5107
文章目录二叉树之前序、中序、后序遍历前序遍历中序遍历后序遍历LeetCode简单题总结 二叉树之前序、中序、后序遍历 下面遍历以下面这课二叉树为例 对应每个节点的代码(Java)如下： Class BinaryTree{ private int val; private BinaryTree left; private BinaryTree right; } 前序遍历 思想 前序遍历，也就是先遍历根结点，再遍历左右结点。 那么对应遍历顺序应为 1->4->3->2->5
数据结构实验之二叉树五：层序遍历 (sdut OJ 3344)
rain_snowing的博客
08-06 685
层序遍历
【OJ - 二叉树】二叉树的前、中、后序遍历
codewinter的博客
03-03 964
文章目录一、二叉树的前序遍历1.1 题目描述1.2 解题思路二、二叉树的中序遍历2.1 题目描述2.2 解题思路三、二叉树的后序遍历3.1 题目描述3.2 解题思路 这三道OJ题解题思路类似，你只要会其中一道，其它两道也就会了 一、二叉树的前序遍历 题目难度：简单 1.1 题目描述 给你二叉树的根节点 root ，返回它节点值的 前序 遍历。 LeetCode链接：144. 二叉树的前序遍历 - 力扣（LeetCode） 1.2 解题思路 递归遍历 /** * Definition for a
西南科技大学SWUST OJ 数据结构 树和二叉树答案 树和二叉树.zip
01-01
在IT领域，数据结构是计算机科学的基础，而树和二叉树是其中极其重要的概念。西南科技大学（SWUST）的在线编程平台（OJ）提供了关于这些主题的编程题目，帮助学生深入理解和应用这些知识。以下是对这些题目涉及知识...
一图看懂二叉树的前序、中序、后序遍历（附代码）(●‘◡‘●)
weixin_73926390的博客
11-30 571
图中列举的双亲表示法以及孩子表示法是在前序遍历的基础上的。
题目1084: 二叉树遍历
落日小屋
03-16 7682
题目描述 二叉树的前序、中序、后序遍历的定义： 前序遍历：对任一子树，先访问跟，然后遍历其左子树，最后遍历其右子树； 中序遍历：对任一子树，先遍历其左子树，然后访问根，最后遍历其右子树； 后序遍历：对任一子树，先遍历其左子树，然后遍历其右子树，最后访问根。 给定一棵二叉树的前序遍历和中序遍历，求其后序遍历（提示：给定前序遍历与中序遍历能够唯一确定后序遍历）。
二叉树前中后序结构遍历代码实现
sakeww的博客
09-19 179
test.c int main() { TestBinTree(); return 0; } BinaryTree.c #define _CRT_SECURE_NO_WARNINGS 1 #include "BinaryTree.h" BTNode* BUyBinTreeNode(BTNDataType data) { BTNode* newNode = (BTNode*)malloc(sizeof(BTNode)); if (NULL == newNode) { assert(0);
二叉树的前中后序遍历算法
iechenyb专栏
01-08 725
从二叉树的递归定义可知，一棵非空的二叉树由根结点及左、右子树这三个基本部分组成。因此，在任一给定结点上，可以按某种次序执行三个操作：⑴访问结点本身（N），⑵遍历该结点的左子树（L），⑶遍历该结点的右子树（R）。以上三种操作有六种执行次序： package cyb.lxf.staring.test; /** * java 实现的一个二叉树的前中后序遍历算法，使用递归。 * @author ch
♥二叉树前、中、后序遍历代码实现♥
m0_52711790的博客
10-17 223
直接上代码： #include<iostream> #include<vector> #include<stack> using namespace std; //用结构体创建结点，包括创建一个数据域以及两个指向左右结点的指针 template<class DataType> struct TreeNode { DataType val; TreeNode<DataType> *lchild, *rchild; }; //创
数据结构基础15：二叉树的前序、中序和后序遍历
何哥的博客
01-28 4373
前言：到目前为止，我们已经介绍了线性数据结构和表数据机构（哈希表）。这些数据机构一般都不适合表示具有层级结构的数据。在层次化的元素之间有祖先—后代、上级—下属、整体—部分以及其他类似的关系。 一、树的介绍 1、树的定义： 树状图是一种数据结构，它是由n（n&gt;=0）个结点组成一个具有层次关系的有穷集合。把它叫做“树”是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。n=0...
【二叉树初阶】前中后序遍历+层序遍历+基础习题
weixin_46016019的博客
04-19 6138
图解二叉树前序、中序、后序、层序遍历详解，以及基础习题解析，
代码题（8）— 二叉树的遍历：前、中、后序
dbsggal90047018的博客
06-23 78
1、144.二叉树的前序遍历 （1）递归 /** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

1886i

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值