第十五天|二叉树的属性| 110.平衡二叉树， 257. 二叉树的所有路径，404.左叶子之和， 222.完全二叉树的节点个数

已于 2024-10-02 13:20:39 修改
阅读量158 收藏 3
点赞数 7
文章标签： 算法 数据结构 java leetcode
于 2024-09-30 21:38:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51726003/article/details/142633356
版权

目录

110.平衡二叉树

递归法

迭代法

优化迭代法

257. 二叉树的所有路径

递归法

迭代法

404.左叶子之和

递归法

迭代法

层序遍历迭代法

222.完全二叉树的节点个数

普通二叉树的求法

递归法（后序--左右中）

迭代法

完全二叉树的求法

110.平衡二叉树

本题总结：

通过本题可以了解求 二叉树深度 和 二叉树高度 的差异，求深度适合用前序遍历，而求高度适合用后序遍历。

本题迭代法有点复杂，可以有一个思路，不一定说非要写出来。但是递归方式是一定要掌握的！

开始正题：

给定一个二叉树，判断它是否是高度平衡的二叉树。

本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。

递归法

1.明确递归函数的参数和返回值

参数：当前传入节点。 返回值：以当前传入节点为根节点的树的高度。

如果已经不是二叉平衡树了，可以返回 -1 来标记已经不符合平衡树的规则了。

// -1 表示已经不是平衡二叉树了，否则返回值是以该节点为根节点树的高度
int getHeight(TreeNode* node)

2.明确终止条件

递归的过程中依然是遇到空节点了为终止，返回0，表示当前节点为根节点的树高度为0

if (node == NULL) {
    return 0;
}

3.明确单层递归的逻辑

如何判断以当前传入节点为根节点的二叉树是否是平衡二叉树呢？当然是其左子树高度和其右子树高度的差值。

分别求出其左右子树的高度，然后如果差值小于等于1，则返回当前二叉树的高度，否则返回-1，表示已经不是二叉平衡树了。

int leftHeight = getHeight(node->left); // 左
if (leftHeight == -1) return -1;
int rightHeight = getHeight(node->right); // 右
if (rightHeight == -1) return -1;

int result;
if (abs(leftHeight - rightHeight) > 1) {  // 中
    result = -1;
} else {
    result = 1 + max(leftHeight, rightHeight); // 以当前节点为根节点的树的最大高度
}

return result;

精简版：

int leftHeight = getHeight(node->left);
if (leftHeight == -1) return -1;
int rightHeight = getHeight(node->right);
if (rightHeight == -1) return -1;
return abs(leftHeight - rightHeight) > 1 ? -1 : 1 + max(leftHeight, rightHeight);

此时递归的函数就已经写出来了，这个递归的函数传入节点指针，返回以该节点为根节点的二叉树的高度，如果不是二叉平衡树，则返回-1。

整体递归代码如下：

class Solution {
        /**
         * 递归法
         */
        public boolean isBalanced(TreeNode root){
            return getHeight(root) !=-1;
        }
        private int getHeight(TreeNode root) {
            if (root == null) {
                return 0;
            }
            int leftHeight = getHeight(root.left);
            if (leftHeight == -1) {
                return -1;
            }
            int rightHeight = getHeight(root.right);
            if (rightHeight == -1) {
                return -1;
            }
            if (Math.abs(leftHeight - rightHeight) > 1) {
                return -1;
            }
            return Math.max(leftHeight, rightHeight) + 1;
        }
    }

迭代法

  • 该代码通过栈的深度优先遍历和队列的广度优先遍历结合，判断二叉树是否是平衡的。
  • 缺点：每遍历一个节点时，都要计算一次左右子树的高度，导致时间复杂度为O(n^2)，性能较低。如果树的高度较大，这个算法效率不高。
public boolean isBalanced(TreeNode root) {
            // 空树被认为是平衡的
            if(root == null) {
                return true;
            }
            // 使用栈遍历树
            Stack<TreeNode> stack = new Stack<>();
            TreeNode pre = null;
            while(root != null || !stack.isEmpty()) {
                while (root != null) {
                    stack.push(root);
                    root = root.left; // 每次先遍历左子树，直到左子树为空，将所有节点压入栈中。
                }
                // 处理栈顶节点
                TreeNode inNode = stack.peek();
                // 右结点为null或已经遍历过
                if (inNode.right == null || inNode.right == pre) { // 这意味着当前节点的左右子树已经处理完，可以检查当前节点的左右子树高度差是否超过1。如果超过1，返回false，表示树不平衡。否则继续弹出栈顶节点，并标记为已处理。
                    // 比较左右子树的高度差，输出
                    if(Math.abs(getHeight(inNode.left) - getHeight(inNode.right)) > 1) {
                        return false;
                    }
                    stack.pop();
                    pre = inNode;
                    root = null;// 当前结点下，没有要遍历的结点了
                } else {
                    root = inNode.right;// 右结点还没遍历，遍历右结点
                }
            }
            return true; // 结束条件：当栈为空且所有节点都遍历完后，如果没有找到不平衡的情况，返回true，表示树是平衡的。
        }
        /**
         * 层序遍历，求结点的高度
         */
        public int getHeight(TreeNode root) {
            if (root == null) {
                return 0; // 如果树为空，高度为0
            }
            // 使用队列进行层序遍历
            Deque<TreeNode> deque = new LinkedList<>();
            deque.offer(root);
            int depth = 0;
            while (!deque.isEmpty()) {
                int size = deque.size();
                depth++;
                for (int i = 0; i < size; i++) {
                    TreeNode poll = deque.poll();
                    // 对于每一层的每个节点，如果有左右子节点，就将其加入队列继续遍历。
                    if (poll.left != null) {
                        deque.offer(poll.left);
                    }
                    if (poll.right != null) {
                        deque.offer(poll.right);
                    }
                }
            }
            return depth;
        }

优化迭代法

/**
         * 优化迭代法，针对暴力迭代法的getHeight方法做优化，利用TreeNode.val来保存当前结点的高度，这样就不会有重复遍历
         * 获取高度算法时间复杂度可以降到O(1)，总的时间复杂度降为O(n)。
         * 时间复杂度：O(n)
         */
        public boolean isBalanced(TreeNode root) {
            if (root == null){
                return true;
            }
            Stack<TreeNode> stack = new Stack<>();
            TreeNode pre = null;
            while(root != null || !stack.isEmpty()) {
                while(root != null) {
                    stack.push(root);
                    root = root.left;
                }
                TreeNode inNode = stack.peek();
                if (inNode.right == null || inNode.right == pre) {
                    if (Math.abs(getHeight(inNode.left) - getHeight(inNode.right)) > 1) {
                        return false;
                    }
                    stack.pop();
                    pre = inNode;
                    root = null;
                } else {
                    root = inNode.right;
                }
            }
            return true;
        }
        public int getHeight(TreeNode root) {
            if (root == null) {
                return 0;
            }
            int leftHeight = root.left != null ? root.left.val : 0;
            int rightHeight = root.right != null ? root.right.val : 0;
            int height = Math.max(leftHeight, rightHeight) + 1;
            root.val = height; // 用TreeNode.val来保存当前结点的高度
            return height;
        }

257. 二叉树的所有路径

这道题目要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。

递归法

1.递归函数参数以及返回值

要传入根节点，记录每一条路径的path，和存放结果集的result，这里递归不需要返回值，代码如下。

void traversal(TreeNode* cur, vector<int>& path, vector<string>& result)

2.确定递归终止条件

if (cur->left == NULL && cur->right == NULL) {
    终止处理逻辑
}

3.确定单层递归逻辑

因为是前序遍历，需要先处理中间节点，中间节点就是我们要记录路径上的节点，先放进path中。

path.push_back(cur->val);

然后是递归和回溯的过程，上面说过没有判断cur是否为空，那么在这里递归的时候，如果为空就不进行下一层递归了。

所以递归前要加上判断语句，下面要递归的节点是否为空，如下。

if (cur->left) {
    traversal(cur->left, path, result);
}
if (cur->right) {
    traversal(cur->right, path, result);
}

此时还没完，递归完，要做回溯啊，因为path 不能一直加入节点，它还要删节点，然后才能加入新的节点。

if (cur->left) {
    traversal(cur->left, path, result);
    path.pop_back(); // 回溯
}
if (cur->right) {
    traversal(cur->right, path, result);
    path.pop_back(); // 回溯
}

本题整体代码如下：

    class Solution {
        public List<String> binaryTreePaths(TreeNode root) {
            List<String> res = new ArrayList<>(); // 存最终的结果
            if (root == null) {
                return res;
            }
            List<Integer> paths = new ArrayList<>(); // 作为结果中的路径
            traversal(root, paths, res);
            return res;
        }

        private void traversal(TreeNode root, List<Integer> paths, List<String> res) {
            paths.add(root.val); // 前序遍历，中
            // 遇到叶子节点
            if (root.left == null && root.right == null) {
                // 输出
                StringBuilder sb = new StringBuilder(); // StringBuilder用来拼接字符串，速度更快
                for (int i = 0; i < paths.size() - 1; i++) {
                    sb.append(paths.get(i)).append("->");
                }
                sb.append(paths.get(paths.size() - 1));// 记录最后一个节点
                res.add(sb.toString());// 收集一个路径
                return;
            }
            // 递归和回溯是同时进行，所以要放在同一个花括号里
            if (root.left != null) {// 左
                traversal(root.left, paths, res);
                paths.remove(paths.size() - 1);// 回溯
            }
            if (root.right != null) { // 右
                traversal(root.right, paths, res);
                paths.remove(paths.size() - 1);// 回溯
            }
        }
    }

方式二

class Solution {

    List<String> result = new ArrayList<>();

    public List<String> binaryTreePaths(TreeNode root) {
        deal(root, "");
        return result;
    }

    public void deal(TreeNode node, String s) {
        if (node == null)
            return;
        if (node.left == null && node.right == null) {
            result.add(new StringBuilder(s).append(node.val).toString());
            return;
        }
        String tmp = new StringBuilder(s).append(node.val).append("->").toString();
        deal(node.left, tmp);
        deal(node.right, tmp);
    }
}

迭代法

        /**
         * 迭代法
         */
        public List<String> binaryTreePaths(TreeNode root) {
            List<String> result = new ArrayList<>();
            if (root == null) {
                return result;
            }
            Stack<Object> stack = new Stack<>();
            // 节点和路径同时入栈
            stack.push(root);
            stack.push(root.val + "");
            while (!stack.isEmpty()) {
                // 节点和路径同时出栈
                String path = (String) stack.pop();
                TreeNode node = (TreeNode) stack.pop();
                // 若找到叶子节点
                if (node.left == null && node.right == null) {
                    result.add(path);
                }
                //右子节点不为空
                if (node.right != null) {
                    stack.push(node.right);
                    stack.push(path + "->" + node.right.val);
                }
                //左子节点不为空
                if (node.left != null) {
                    stack.push(node.left);
                    stack.push(path + "->" + node.left.val);
                }
            }
            return result;
        }
    }

404.左叶子之和

左叶子：节点A的左孩子不为空，且左孩子的左右孩子都为空（说明是叶子节点），那么A节点的左孩子为左叶子节点。

这道题目要求左叶子之和，其实是比较绕的，因为不能判断本节点是不是左叶子节点。

此时就要通过节点的父节点来判断其左孩子是不是左叶子了。

平时我们解二叉树的题目时，已经习惯了通过节点的左右孩子判断本节点的属性，而本题我们要通过节点的父节点判断本节点的属性。

递归法

递归的遍历顺序为后序遍历（左右中），是因为要通过递归函数的返回值来累加求取左叶子数值之和。

1.确定递归函数的参数和返回值

判断一个树的左叶子节点之和，那么一定要传入树的根节点，递归函数的返回值为数值之和，所以为int使用题目中给出的函数就可以了。

2.确定终止条件

如果遍历到空节点，那么左叶子值一定是0

if (root == NULL) return 0;

只有当前遍历的节点是父节点，才能判断其子节点是不是左叶子。 所以如果当前遍历的节点是叶子节点，那其左叶子也必定是0，那么终止条件为：

if (root == NULL) return 0;
if (root->left == NULL && root->right== NULL) return 0; //其实这个也可以不写，如果不写不影响结果，但就会让递归多进行了一层。

3.确定单层递归的逻辑

当遇到左叶子节点的时候，记录数值，然后通过递归求取左子树左叶子之和，和 右子树左叶子之和，相加便是整个树的左叶子之和。

int leftValue = sumOfLeftLeaves(root->left);    // 左
if (root->left && !root->left->left && !root->left->right) {
    leftValue = root->left->val;
}
int rightValue = sumOfLeftLeaves(root->right);  // 右

int sum = leftValue + rightValue;               // 中
return sum;

整体递归代码如下：

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        // 递归法
        if (root == null) return 0;
        int leftValue = sumOfLeftLeaves(root.left);    // 左
        int rightValue = sumOfLeftLeaves(root.right);  // 右
        int midValue = 0;
        if (root.left != null && root.left.left == null && root.left.right == null) {
            midValue = root.left.val;
        }
        int sum = midValue + leftValue + rightValue;   // 中
        return sum;
    }
}

迭代法

class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        if (root == null) return 0;
        Stack<TreeNode> stack = new Stack<> ();
        stack.add(root);
        int result = 0;
        while (!stack.isEmpty()) {
            TreeNode node = stack.pop();
            if (node.left != null && node.left.left == null && node.left.right == null) {
                result += node.left.val;
            }
            if (node.right != null) stack.add(node.right);
            if (node.left != null) stack.add(node.left);
        }
        return result;
    }
}

层序遍历迭代法

该方法好理解

// 层序遍历迭代法
class Solution {
    public int sumOfLeftLeaves(TreeNode root) {
        int sum = 0;
        if (root == null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size -- > 0) {
                TreeNode node = queue.poll();
                if (node.left != null) { // 左节点不为空
                    queue.offer(node.left);
                    if (node.left.left == null && node.left.right == null){ // 左叶子节点
                        sum += node.left.val;
                    }
                }
                if (node.right != null) queue.offer(node.right);
            }
        }
        return sum;
    }
}

222.完全二叉树的节点个数

完全二叉树的复杂度更优！

这道题还是挺简单的，主要是理解完全二叉树的求法。

普通二叉树的求法

递归法（后序--左右中）

思路：确定单层递归的逻辑：先求它的左子树的节点数量，再求右子树的节点数量，最后取总和再加一 （加1是因为算上当前中间节点）就是目前节点为根节点的节点数量。

int leftNum = getNodesNum(cur->left);      // 左
int rightNum = getNodesNum(cur->right);    // 右
int treeNum = leftNum + rightNum + 1;      // 中
return treeNum;

精简版整体代码如下：

class Solution {
    // 通用递归解法
    public int countNodes(TreeNode root) {
        if(root == null) {
            return 0;
        }
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}
  • 时间复杂度：O(n)
  • 空间复杂度：O(log n)，算上了递归系统栈占用的空间

迭代法

层序遍历，加一个变量result，统计节点数量就可以了。

class Solution {
    // 迭代法
    public int countNodes(TreeNode root) {
        if (root == null) return 0;
        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int result = 0;
        while (!queue.isEmpty()) {
            int size = queue.size();
            while (size -- > 0) {
                TreeNode cur = queue.poll();
                result++;
                if (cur.left != null) queue.offer(cur.left);
                if (cur.right != null) queue.offer(cur.right);
            }
        }
        return result;
    }
}
  • 时间复杂度：O(n)
  • 空间复杂度：O(n)

完全二叉树的求法

完全二叉树只有两种情况，情况一：就是满二叉树，情况二：最后一层叶子节点没有满。

对于情况一，可以直接用 2^树深度 - 1 来计算，注意这里根节点深度为1。

对于情况二，分别递归左孩子，和右孩子，递归到某一深度一定会有左孩子或者右孩子为满二叉树，然后依然可以按照情况1来计算。

可以看出如果整个树不是满二叉树，就递归其左右孩子，直到遇到满二叉树为止，用公式计算这个子树（满二叉树）的节点数量。

这里关键在于如何去判断一个左子树或者右子树是不是满二叉树呢？

在完全二叉树中，如果递归向左遍历的深度等于递归向右遍历的深度，那说明就是满二叉树。如图：

因此递归中的终止条件的写法应该是这样的：

if (root == null) return 0; 
// 开始根据左深度和右深度是否相同来判断该子树是不是满二叉树
TreeNode* left = root->left;
TreeNode* right = root->right;
int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
while (left) {  // 求左子树深度
    left = left->left;
    leftDepth++;
}
while (right) { // 求右子树深度
    right = right->right;
    rightDepth++;
}
if (leftDepth == rightDepth) {
    return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，返回满足满二叉树的子树节点数量
}

单层递归的逻辑：（可以看出使用后序遍历）

int leftTreeNum = countNodes(root->left);       // 左
int rightTreeNum = countNodes(root->right);     // 右
int result = leftTreeNum + rightTreeNum + 1;    // 中
return result;

整体代码如下：

class Solution {
    /**
     * 针对完全二叉树的解法
     *
     * 满二叉树的结点数为：2^depth - 1
     */
    public int countNodes(TreeNode root) {
        if (root == null) return 0;
        TreeNode left = root.left;
        TreeNode right = root.right;
        int leftDepth = 0, rightDepth = 0; // 这里初始为0是有目的的，为了下面求指数方便
        while (left != null) {  // 求左子树深度
            left = left.left;
            leftDepth++;
        }
        while (right != null) { // 求右子树深度
            right = right.right;
            rightDepth++;
        }
        if (leftDepth == rightDepth) {
            return (2 << leftDepth) - 1; // 注意(2<<1) 相当于2^2，所以leftDepth初始为0
        }
        return countNodes(root.left) + countNodes(root.right) + 1;
    }
}
  • 时间复杂度：O(log n × log n)
  • 空间复杂度：O(log n)

第十五天的总算是结束了，直冲Day16！

皎味小行家
关注
洛谷：新二叉树（P1305，二叉树）
速溶咖啡味道很中意丶的博客
07-26 313
输入一串二叉树，输出其前序遍历。 输入格式 第一行为二叉树的节点数 n。(1≤n≤26) 后面 n 行，每一个字母为节点，后两个字母分别为其左右儿子。 空节点用 * 表示 输出格式 二叉树的前序遍历。 输入输出样例 输入 6 abc bdi cj* d** i** j** 输出 abdicj #include<bits/stdc++.h> using namespace std; //本题是一道非常简单的二叉树，要求实现前序遍历（优先遍历顺序->根->左->右） s
代码随想录算法训练营第十七天| ● 110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和
Zhen_JIANG的博客
04-08 388
● 110.平衡二叉树 ● 257. 二叉树的所有路径 ● 404.左叶子之和
15 平衡二叉树（leecode 110）
weixin_42454048的博客
02-08 186
1 问题 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 示例 1: 给定二叉树 [3,9,20,null,null,15,7] 返回 true 。 示例 2: 给定二叉树 [1,2,2,3,3,null,null,4,4] 返回 false 。 2 解法 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。 但leetcode中强调的深度
chapter §15 平衡二叉树（AVL树）
明月如霜，照见人如画
05-04 193
由于二叉排序树主要应用于查找，其时间复杂度不超过O(logn)，为此，当二叉排序树由于插入操作增长过高时，其查找性能将大大降低，甚至复杂度接近O(n)。所以引入平衡二叉树。 AVL树，任意一个结点的左右子树高度之差不超过1。这样就保证了二叉树左右尽可能“平衡”，树的整体高度尽可能小。 所以当出现不平衡时，我们需要将其调整至平衡。 一、LL型调整 假设在某一结点A的左孩子(L)的左子树(L)上插入了新结点,使得A的平衡因子由1增至2,导致以A为根的子树失去平衡,需要一次向右的旋转操作。将A的左孩子B向右.
从零开始的数据结构学习日记（十五）——1.15哈夫曼树（最优二叉树）
sakaili的博客
02-09 186
1.1最优二叉树 1.基本概念 1）路径长度：连接两结点的路径上的分支数。 2）树的路径长度：各结点到根结点的路径长度之和。 3）最优二叉树或哈夫曼树：带权路径长度最小的二叉树。 4）树的带权路径长度：树的所有叶子结点的带权路径长度之和，记为WPL。 2.哈夫曼树的构造 1）由给定的n个权值{w0,w1…wn}，构造具有n棵二叉树的森林F，其中每一棵二叉树T只有一个带有权值w的根结点，其左右子树均...
力扣【104】二叉树的最大深度
qq1922631820的博客
12-11 109
题目： 给定一个二叉树，找出其最大深度。 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。 说明:叶子节点是指没有子节点的节点。 示例： 给定二叉树 [3,9,20,null,null,15,7]， 3 / \ 9 20 / \ 15 7 返回它的最大深度3 。 题解： /** * Definition for a binary tree node. * public class TreeNode { * int val; ...
二叉树模拟器.py二叉树模拟器.py
07-24
二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py二叉树模拟器.py...
python-leetcode面试题解之第257题二叉树的所有路径.zip
最新发布
06-19
在本压缩包中，我们关注的是LeetCode面试题的第257题——"二叉树的所有路径"。这道题目主要考察了Python编程语言以及数据结构中的二叉树概念，特别是遍历二叉树的方法。LeetCode是一个非常流行的在线平台，它提供了...
数据结构实验——二叉树的建立和遍历.zip
12-13
1.采用二叉链表作为存储结构，创建一棵二叉树； 2.用递归及非递归算法对二叉树实现先序遍历； 3.用递归及非递归算法对二叉树实现中序遍历； 4.用递归及非递归算法对二叉树实现后序遍历。 5.用递归遍历算法中的访问...
二叉树-基于C++实现的平衡二叉树.zip
04-26
本压缩包文件“二叉树-基于C++实现的平衡二叉树.zip”包含了一个关于使用C++编程语言实现平衡二叉树的实例，这对于我们理解平衡二叉树的原理和实际操作至关重要。 平衡二叉树（Balanced Binary Tree）是一种特殊的...
leecode刷题-20200528-easy-110.平衡二叉树
一名假人的博客
05-28 172
声明： 作者不是什么大佬，只是想写写算法，提高一下自己的内功。所以代码可能会非常凌乱，（大佬们就当个笑话看就可以了），但我会认真注释。 最后如果有路过的大佬，希望可以留下你们的建议和看法，谢谢！ 110.平衡二叉树 一、原题链接 110.平衡二叉树 二、题目介绍 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 三、测试用例 1.示例 给定二叉树 [3,9,20,null,null,15,7] 输出.
数据结构（十五）二叉树 —— 平衡二叉树
在路上
08-12 1031
在前面的章节已经有总结过，在某些特定的情况下，二叉排序树是有可能退化成单链表的。也就是说，如果一个二叉排序树对已经有序的序列进行排序，那么其中的结构就会退化成单链表，并且元素的查找效率也会明显的下降，那么此时我们需要一些特别的手段保证这个二叉排序树的“平衡”，进而保证查询元素的效率。
【数据结构】查找2——树表的查找——二叉排序树、平衡二叉树
FishC的博客
10-29 652
【数据结构】查找2——树表的查找——二叉排序树、平衡二叉树
平衡二叉树的根
永夜莫明的博客
11-29 942
7-29 平衡二叉树的根 （25 分） 将给定的一系列数字插入初始为空的AVL树，请你输出最后生成的AVL树的根结点的值。 输入格式: 输入的第一行给出一个正整数N（≤20），随后一行给出N个不同的整数，其间以空格分隔。 输出格式: 在一行中输出顺序插入上述整数到一棵初始为空的AVL树后，该树的根结点的值。 输入样例1: 5 88 70 61 96 120 输出样例1: 70 输入样例2: 7 8...
数据结构与算法15—二叉排序(查找)树
weixin_30914981的博客
05-23 1054
目录 1、二叉排序树的定义 2、二叉排序树的查找 3、二叉排序树的插入与删除 4、二叉排序树的构造 5、二叉排序树的删除 定义 二叉排序树（Binary Sort Tree）又称为二叉查找树（Binary Search Tree）、二叉搜索树。 它是特殊的二叉树： 对于二叉树，假设x为二叉树中的任意一个结点，x节点包含关键字key，节点x的key值记为key[x]。 如果...
09.二叉排序树和平衡二叉树
gudongkun1121的博客
01-21 1854
一、二叉排序树 1.什么是二叉排序树 二叉排序树要么是空二叉树 ，要么具有如下特点： 二叉排序树中，如果其根结点有左子树，那么左子树上所有结点的值都小于根结点的值； 二叉排序树中，如果其根结点有右子树，那么右子树上所有结点的值都大于根结点的值； 二叉排序树的左右子树也要求都是二叉排序树； 如下图就是一个二叉排序树： [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-VsGloKcV-1642763317481)(C:\Users\86186\AppData\Roaming\T
平衡二叉树中查找关键字结点
weixin_42044037的博客
08-21 9179
二叉排序树的定义： （1）若它的左子树不为空，则左子树所有结点均小于它的根结点的值； （2）若它的右子树不为空，则右子树所有结点均大于它的根结点的值； （3）它的左右子树都是二叉排序树。 平衡二叉树本质上是二叉排序树。 平衡二叉树的性质： （1）根结点的左子树和右子树的深度最多相差1。 （2）根结点的左子树和右子树叶都是一棵平衡二叉树。 平衡二叉树查找关键字是否存在？ 解析思路：...
平衡二叉树的根（简化版）
ljhsq的博客
04-07 1026
平衡二叉树的根题目答案声明 题目 答案 #include<iostream> #include<malloc.h> using namespace std; typedef struct node* avl; struct node{ int data; avl left,right; }; int GetHeight(avl a)//获取高度 { if(!a) return 0; else { int l=GetHeight(a->left); int
二叉树的创建及遍历实验 matlab,【二叉树的建立和遍历实验报告】 二叉树的遍历实验心得...
05-29
好的，我可以为您提供一些关于二叉树在MATLAB中的创建和遍历的实验报告和心得。 一、二叉树的创建 在MATLAB中，我们可以使用结构体来表示二叉树的节点，节点包含三个属性：value、left和right，分别表示节点的值、左子树和右子树。 创建二叉树的过程可以采用递归的方式实现。具体步骤如下： 1. 定义一个函数，输入为一个数组，输出为二叉树的根节点。 2. 如果数组为空，则返回空节点。 3. 取数组的中间值作为根节点的值。 4. 将数组分为左子数组和右子数组。 5. 递归调用函数，将左子数组传入函数，得到左子树的根节点，将右子数组传入函数，得到右子树的根节点。 6. 将左子树和右子树作为根节点的左右子树。 二、二叉树的遍历 二叉树的遍历分为三种方式：前序遍历、中序遍历和后序遍历。这里我们以前序遍历为例进行讲解。 前序遍历的顺序是：根节点、左子树、右子树。具体步骤如下： 1. 如果当前节点为空，则返回。 2. 输出当前节点的值。 3. 递归调用函数，遍历左子树。 4. 递归调用函数，遍历右子树。 三、实验报告 我们可以编写一个MATLAB程序来创建一个二叉树，并进行前序遍历。程序如下： ```matlab % 定义二叉树节点 Node.value = 0; Node.left = []; Node.right = []; % 创建二叉树 function root = createBinaryTree(array) n = length(array); if n == 0 root = []; else mid = ceil(n/2); root.value = array(mid); leftArray = array(1:mid-1); rightArray = array(mid+1:n); root.left = createBinaryTree(leftArray); root.right = createBinaryTree(rightArray); end end % 前序遍历 function preOrder(root) if isempty(root) return; end disp(root.value); preOrder(root.left); preOrder(root.right); end % 测试程序 array = [1 2 3 4 5]; root = createBinaryTree(array); preOrder(root); ``` 程序输出结果为： ``` 3 1 2 4 5 ``` 四、实验心得 本次实验让我深入学习了二叉树的创建和遍历算法，并在MATLAB中实现了这些算法。通过编写程序，我更加深入地理解了递归算法的实现过程，同时也掌握了MATLAB结构体的使用方法。在实验过程中，我还发现了二叉树遍历算法的时间复杂度是O(n)，这对于程序的性能优化有着重要的意义。通过本次实验，我对算法和数据结构的理解更加深入，也为以后的编程工作打下了坚实的基础。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值