day15【二叉树】 层序遍历 | 226.翻转二叉树 | 101.对称二叉树

最新推荐文章于 2024-07-25 19:28:17 发布
最新推荐文章于 2024-07-25 19:28:17 发布
阅读量41 收藏
点赞数
分类专栏： 【数据结构与算法】秋招必备 文章标签： 数据结构 java 算法 leetcode
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xuwuuu/article/details/130853930
版权

文章目录

1.层序遍历

102.二叉树的层序遍历

  • 102. 二叉树的层序遍历 | 题目链接
  • 思路：队列实现：一层一层的遍历，出队列一个，进它的左右孩子，再出上一层第二个，进第二个的左右孩子。(代码随想录里右很明白的动画演示)
/**
 * 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>> resList = new ArrayList<List<Integer>>();

    //主函数
    public List<List<Integer>> levelOrder(TreeNode root) {
        checkFun(root);
        return resList;
    }

    //传入根节点
    public void checkFun(TreeNode node) {
        //剪枝，如果根节点为空，直接返回结果；
        if(node == null) {
            return;
        }

        //借助队列，遍历二叉树，把元素往队列里放，先放头节点进来
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.add(node);

        //当队列不为空，就要一直循环操作
        while(!queue.isEmpty()) {
            //创建存放每行元素的列表
            List<Integer> itemList = new ArrayList<Integer>();
            //记录当前队列里的元素数量（也就是每一个行的元素个数）
            int len = queue.size();

            //从队列中往外拿出元素，放到每一行的列表中，拿出的个数就是每一行的元素数量
            while(len > 0) {
                //用临时节点保存队列的头
                TreeNode temp = queue.poll();
                //把此时的头加入到行列表中
                itemList.add(temp.val);
                
                //把它的左右孩子加到队列里
                if(temp.left != null) {
                    queue.offer(temp.left);
                }
                if(temp.right != null) {
                    queue.offer(temp.right);
                }
                //从队列里出一个元素len就--，直到为0，说明已经处理完二叉树中的一行元素了
                len--;
            }
            //把处理完的这一行元素的行列表放到结果列表中，这就处理完一行了
            resList.add(itemList);
        }

107.二叉树的层序遍历Ⅱ

/**
 * 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>> resList = new ArrayList<List<Integer>>();
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        rowList(root);
        Collections.reverse(resList);//翻转结果!!
        return resList;
    }

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

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);//试了一下，用add和offer都可以

        while(!queue.isEmpty()) {
            List<Integer> resRow = new ArrayList<>();
            int len = queue.size();

            while(len-- > 0) {
                TreeNode temp = queue.poll();
                resRow.add(temp.val);

                if(temp.left != null) {
                    queue.offer(temp.left);
                }
                if(temp.right != null) {
                    queue.offer(temp.right);
                }
            }
            resList.add(resRow);
        }  
    }
}

199.二叉树的右视图

  • 199.二叉树的右视图 | 题目链接
  • 代码随想录 | 题目讲解
  • 题意：给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
    在这里插入图片描述
  • 思路：同一套代码，把每一行列表的最后一个元素拿出来放到一个新列表里，这个新列表就是返回的结果列表即可。
/**
 * 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> rightSideView(TreeNode root) {
        List<Integer> resList = new ArrayList<>();
        if(root == null) {
            return resList;
        }

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()) {
            List<Integer> row  = new ArrayList<>();
            int len = queue.size();

            while(len-- > 0) {
                TreeNode temp = queue.poll();
                row.add(temp.val);

                if(temp.left != null) {
                    queue.offer(temp.left);
                }
                if(temp.right != null) {
                    queue.offer(temp.right);
                }
            }
            resList.add(row.get(row.size() - 1));//往结果列表里添加行列表的最后一个元素
        }
        return resList;
    }
}

637.二叉树的层平均值

  • 637.二叉树的层平均值 | 题目链接
  • 题意：给定一个非空二叉树, 返回一个由每层节点平均值组成的数组。
  • 思路：求平均值，就不新建行列表了，直接新建一个doule值，把每次遍历的元素加到行和中。注意，循环不能用while了，因为while是用len控制的，len需要一直–，此时应该用for循环，len不变，最后行和/len就是此层的平均值。
/**
 * 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<Double> averageOfLevels(TreeNode root) {
        List<Double> resList = new ArrayList<>();

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

        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while(!queue.isEmpty()) {

            int len = queue.size();
            double rowSum = 0;

            for(int i = 0; i < len; i++) { //不能用while，要保持len不能改变
                TreeNode temp = queue.poll();
                rowSum += temp.val;//把遍历元素的值加到rowSum层和中

                if(temp.left != null) {
                    queue.offer(temp.left);
                }
                if(temp.right != null) {
                    queue.offer(temp.right);
                }
            }
            resList.add(rowSum / len);结果列表里放层平均值
        }
        return resList;
    }
}

429.N叉树的层序遍历

  • 429.N叉树的层序遍历 | 题目链接
  • 题意：给定一个 N 叉树，返回其节点值的层序遍历。 (即从左到右，逐层遍历)。
    在这里插入图片描述
  • 思路：和最开始的是一样的，只不过没有左右孩子，孩子被统一放在Node这个列表里，直接循环遍历就行。注意for循环的一种写法：for (循环变量类型 循环变量名称 : 要被遍历的对象) 循环体
/*
// Definition for a Node.
class Node {
    public int val;
    public List<Node> children;

    public Node() {}

    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, List<Node> _children) {
        val = _val;
        children = _children;
    }
};
*/

class Solution {
    public List<List<Integer>> levelOrder(Node root) {
        List<List<Integer>> resList = new LinkedList<List<Integer>>();

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

        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()) {
            List<Integer> row = new ArrayList<>();
            int len = queue.size();

            for(int i = 0; i < len; i++) {
                Node temp = queue.poll();
                row.add(temp.val);

                List<Node> children = temp.children;

                if(children == null || children.size() == 0) {
                    continue;
                } else {
                    //for (循环变量类型 循环变量名称 : 要被遍历的对象) 循环体
                    for(Node child : children) {
                        if(child != null) {
                            queue.offer(child);
                        }
                    }
                }
            }
            resList.add(row);
        }
        return resList;
    }
}

515. 在每个树行中找最大值

/**
 * 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> largestValues(TreeNode root) {
        List<Integer> resList = new ArrayList<>();

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

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

        while(!queue.isEmpty()) {
            List<Integer> row = new ArrayList<>();
            int len = queue.size();

            for(int i = 0; i <  len; i++) {
                TreeNode temp = queue.poll();
                row.add(temp.val);

                if(temp.left != null) {
                    queue.offer(temp.left);
                }
                if(temp.right != null) {
                    queue.offer(temp.right);
                }
            }
            resList.add(Collections.max(row)); //把每一行的最大值取出
        }
        return resList;
    }
}

116.填充每个节点的下一个右侧节点指针

  • 116.填充每个节点的下一个右侧节点指针 | 题目链接

  • 题意：给定一个完美二叉树，其所有叶子节点都在同一层，每个父节点都有两个子节点。二叉树定义如下：
    在这里插入图片描述

    填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。初始状态下，所有 next 指针都被设置为 NULL。
    在这里插入图片描述

  • 思路：层序遍历，每一行遍历的时候多加几行指向的代码，让temp.next指向队列的头节点

/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if(root == null) {
            return root;
        }

        Queue<Node> queue = new LinkedList<Node>();
        queue.offer(root);


        while(!queue.isEmpty()) {
            int len = queue.size();

            for(int i = 0; i < len; i++) {
                //取出队首元素
                Node temp = queue.poll();

                //链接，指定取出的元素指向当前队列中的头
                if(i < len - 1) {
                    temp.next = queue.peek();
                }

                if(temp.left != null) {
                    queue.offer(temp.left);
                }
                if(temp.right != null) {
                    queue.offer(temp.right);
                }
            }
        }
        return root;
    }
}

117.填充每个节点的下一个右侧节点指针Ⅱ

  • 117.填充每个节点的下一个右侧节点指针Ⅱ | 题目链接
  • 题目描述：填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL 。
    这道题目说是二叉树，但116题目说是完整二叉树，其实没有任何差别，一样的代码一样的逻辑一样的味道
/*
// Definition for a Node.
class Node {
    public int val;
    public Node left;
    public Node right;
    public Node next;

    public Node() {}
    
    public Node(int _val) {
        val = _val;
    }

    public Node(int _val, Node _left, Node _right, Node _next) {
        val = _val;
        left = _left;
        right = _right;
        next = _next;
    }
};
*/

class Solution {
    public Node connect(Node root) {
        if(root == null) {
            return root;
        }

        Queue<Node> queue = new LinkedList<>();
        queue.offer(root);

        while(!queue.isEmpty()) {
            int len = queue.size();
            Node pre = null;

            for(int i = 0; i < len; i++) {
                Node temp = queue.poll();

                //pre为空就表示temp节点是这行的第一个，没有前一个节点指向temp
                //pre不为空，就让前一个节点指向temp
                if(pre != null) {
                    pre.next = temp;
                }
                //让当前节点变成前一个节点
                pre = temp;

                if(temp.left != null) {
                    queue.offer(temp.left);
                }
                if(temp.right != null) {
                    queue.offer(temp.right);
                }
            }
        }
        return root;
    }
}

104.二叉树的最大深度

  • 104.二叉树的最大深度 | 题目链接

  • 题意：给定一个二叉树，找出其最大深度。

    二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。

    说明: 叶子节点是指没有子节点的节点。
    在这里插入图片描述

  • 思路：套用模板

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

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        int res = 0; //while是按层遍历的，while执行过几次就有几层

        while(!queue.isEmpty()) {
            int len = queue.size();

            for(int i = 0; i < len; i++) {
                TreeNode temp = queue.poll();
                if(temp.left != null) {
                    queue.offer(temp.left);
                }
                if(temp.right != null) {
                    queue.offer(temp.right);
                }
            } 
            res++;
        }
        return res;
    }
}

111.二叉树的最小深度

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

        Queue<TreeNode> queue = new LinkedList<>();
        queue.offer(root);
        //记录结果行数
        int res = 0;
        while(!queue.isEmpty()) {
            //走一遍while就多遍历一行，res就++
            res++;
            int len = queue.size();
            for(int i = 0; i < len; i++) {
                TreeNode temp = queue.poll();
                //当一个节点没有左右子节点时，直接返回结果，结束循环即可。
                if(temp.left ==  null && temp.right == null) {
                    return res;
                }
                if(temp.left != null) {
                    queue.offer(temp.left);
                }
                if(temp.right != null) {
                    queue.offer(temp.right);
                }
            }
        }
        return res;
    }
}

226. 翻转二叉树

  • 226. 翻转二叉树 | 题目链接
  • 代码随想录 | 讲解链接
  • 题意：给你一棵二叉树的根节点 root ，翻转这棵二叉树，并返回其根节点。
    在这里插入图片描述
  • 思路：递归三部曲
    1. 确定递归函数的参数（root）和返回值（TreeNode）
    2. 确定终止条件：当前节点为null时就返回
    3. 确定单层递归的逻辑
      前序或后序遍历，中左右 / 左右中
/**
 * 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 TreeNode invertTree(TreeNode root) {
        if(root == null) {
            return null;
        }
        //后序遍历
        invertTree(root.left);
        invertTree(root.right);
        swap(root);
        return root;
    }
    //交换左右孩子
    public void swap(TreeNode root) {
        TreeNode temp = root.left;
        root.left = root.right;
        root.right = temp;
    }
}

101.对称二叉树

  • 101.对称二叉树 | 题目链接
  • 代码随想录 | 讲解链接
  • 题意：给你一个二叉树的根节点 root ， 检查它是否轴对称。
  • 思路：
    1. 判断根节点的左右子树是否对称，参数就是左子树节点和右子树节点。返回值布尔类型
    2. 确定终止条件：比较两个节点的数值是否相同，先判断两个节点空的情况。
      左为空，右不为空，不对称
      左不为空，右为空，不对称
      左右都为空，对称
      左右都不为空，比较节点的数值，不相同就false；
    3. 剩下的最后一种情况就是，左右都不为空，且左右节点的数值相同，此时处理逻辑
    4. 处理单层递归的逻辑
      比较二叉树外侧是否对称，判断左节点左孩子，右节点的右孩子
      比较内测是否对称，判断左节点的右孩子，右节点的左孩子
      如果左右都对称，那就返回true。
/**
 * 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) {
    	//直接传入根节点的左右孩子，判断左右两棵树是否对称
        return leftrightIsSample(root.left, root.right);
    }
	
    public boolean leftrightIsSample(TreeNode left, TreeNode right) {
    	//排除空节点的情况
        if(left == null && right == null) {
            return true;
        } else if(left == null && right != null) {
            return false;
        } else if(left != null && right == null) {
            return false;
            //排除了空节点，再排除数值不相同的情况
        } else if(left.val != right.val) {
            return false;
        } 
        //此时是，左右节点都不为空，且数值相同的情况
        //此时才递归，做下一层的判断
        //左子树：左，右子树：右
        boolean compareOutside = leftrightIsSample(left.left, right.right);
        //左子树：右，右子树：左
        boolean compareInside = leftrightIsSample(left.right, right.left);
        //左子树：中，右子树：中，处理逻辑。左右都相等了，中间节点下的左右子树就是对称的
        return compareOutside && compareInside;
    }
}
xuwuuu
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
20230622 | 102. 二叉树的层序遍历、226. 翻转二叉树、101.对称二叉树
qq_45885369的博客
06-22 83
给你二叉树的根节点 root ，返回其节点值的 层序遍历。（即逐层地，从左到右访问所有节点）。示例 1：输入：root = [3,9,20,null,null,15,7]输出：[[3],[9,20],[15,7]]示例 2：输入：root = [1]输出：[[1]]示例 3：输入：root = []输出：[]
代码随想录算法训练营第15天 | LeetCode 102. 二叉树的层序遍历，226.翻转二叉树，101.对称二叉树
a976903676的博客
11-09 201
LeetCode 102. 二叉树的层序遍历，226.翻转二叉树，101.对称二叉树
day15二叉树part02 | 层序遍历 10 226.翻转二叉树 101.对称二叉树 2
C_huamao的博客
05-26 441
给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历。（即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）给定一个二叉树的 根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。与实际答案相差 10-5 以内的答案可以被接受。给定一个 N 叉树，返回其节点值的层序遍历。（即从左到右，逐层遍历）。树的序列化输入是用层序遍历，每组子节点都由 null 值分隔（参见示例）。
DAY15 层序遍历 ● 226.翻转二叉树 ● 101.对称二叉树
m0_58298553的博客
01-12 371
层序遍历 10226.翻转二叉树101.对称二叉树。
Day 14 | 层序遍历、226.翻转二叉树、101.对称二叉树
baidu_41638844的博客
10-06 87
理解这一点就知道了其实我们要比较的是两个树（这两个树是根节点的左右子树），所以在递归遍历的过程中，也是要同时遍历两棵树。，出队 len 个元素，即该层元素遍历完毕，遍历过程中将下一层节点全部入队。首先想清楚，判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！比较的是两个子树的里侧和外侧的元素是否相等。采用的递归的思路，依次翻转每个节点的左右孩子。翻转二叉树，即需要交换每个节点的左右孩子。遍历树，将一层节点全部入队后，对于二叉树是否对称，
二叉树的遍历以及创建.zip
04-30
二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的遍历以及创建.zip二叉树的...
基于Java的二叉树层序遍历打印实现.docx
06-27
本篇主要讨论基于Java的二叉树层序遍历的实现，分为三种情况： 1. **基本层序遍历（剑指offer32-Ⅰ）**： 这种遍历方法将二叉树的节点值按层顺序存储到一个一维整数数组`int[] res`中。核心思想是利用队列（这里...
二叉树的遍历的介绍.docx
04-30
常见的二叉树遍历方式有四种：前序遍历（Pre-order Traversal）、中序遍历（In-order Traversal）、后序遍历（Post-order Traversal）和层序遍历（Level-order Traversal）。 前序遍历（Pre-order Traversal）： ...
算法笔记，二叉树的层序遍历||
03-19
二叉树的层序遍历，也称为宽度优先搜索（BFS），是一种遍历或搜索二叉树的算法，它按照从左到右、从上到下的顺序访问每一层的节点。层序遍历通常使用队列数据结构来实现。以下是详细的解释： 首先，我们来看如何...
c语言（7.23）
fhgfyrsg的博客
07-23 418
【代码】c语言（7.23）
重生之“我打数据结构，真的假的？”--3.栈和队列
2301_80374809的博客
07-21 773
栈：一种特殊的线性表，其只允许在进行插入和删除元素操作。进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵守LIFO（Last In First Out）的原则。
数据结构之判断完全二叉树详解与示例（C，C++）
qq_35320456的博客
07-23 389
通过上述C和C++的实现示例，我们可以看到判断一个二叉树是否为完全二叉树的基本方法是使用层序遍历。在遍历过程中，我们通过设置一个标记来区分节点是否应该为叶子节点，从而判断二叉树是否满足完全二叉树的条件。这种方法的时间复杂度为O(n)，其中n是二叉树中节点的数量，因为每个节点最多只会被访问一次。在实际应用中，完全二叉树由于其特殊的结构，常用于堆的实现，因为它可以在数组中有效地表示，同时保持堆的操作效率。理解并掌握判断完全二叉树的方法，对于深入理解二叉树结构和相关算法有重要意义。
数据结构（特殊二叉树－线索二叉树）
weixin_65029285的博客
07-22 361
链式二叉树中有很多的空指针，可以让这些空指针指向前一个节点\后一个节点，从而在有序遍历（中序遍历）二叉树时，不需要使用递归而通过循环即可以完成，并且效率要比递归快得多。首先需要有一颗搜索二叉树，然后通过中序遍历并生成线索，通过检查右子树是否为空来决定是否生成线索，让右子树指向下一个节点。bool lflag;// 左子树是否是线索 为真时，左子树是线索 指向前一个节点。bool rflag;// 右子树是否是线索 为真时，右子树是线索 指向下一个节点。
数据结构——单链表OJ题（下）
最新发布
2301_81888634的博客
07-25 587
链表既然包括单链表，就还有其他种类啦~敬请期待“双向链表”~
数据结构（特殊二叉树-平衡二叉树）
weixin_65029285的博客
07-23 951
待删除节点左右子树非空，则根据左右子树的高度，选择高的一边子树，如果是左子树高，选择左子树中的最大节点赋值给待删除节点，然后再左子树中继续删除该最大节点，相当于继续处理情况1或情况2；由于节点的位置要受到相互之间值的影响，并且在往平衡二叉树中添加节点或者删除节点前，二叉树本身是平衡的，所以只可能在最后操作的节点附近不满足平衡条件，因此需要在该过程中对该节点进行判断并调整。如果一个搜索二叉树呈现或接近单支状，它的查找效率很低，很接近链表，因此如果能让它平衡时，查找效率最高。待删除的节点是叶子节点，直接删除。
华清数据结构day5 24-7-22
m0_62859255的博客
07-22 393
【代码】华清数据结构day5 24-7-22。
【数据结构】AVL树(平衡二叉搜索树)
weixin_69380220的博客
07-24 1073
AVL树的相关操作
数据结构——二叉树定义
鲸落博客
07-23 400
二叉树是一种树形数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。每个子节点本身又可以是一个二叉树。二叉树在计算机科学中有着广泛的应用，例如在搜索算法、排序算法等领域二叉树(Binary Tree)是n(n≥0)个结点的有限集合，该集合 或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交 的、分别称为根结点的左子树和右子树的二叉树组成。
学习记录——day17 数据结构 队列 链式队列
weixin_64918301的博客
07-23 441
1、队列也是操作受限的线性表:所有操作只能在端点处进行，其删除和插入必须在不同端进行2、允许插入操作的一端称为队尾，允许删除操作的一端称为队头3、特点:先进先出(FIFO)4、分类：顺序存储的栈称为顺序栈链式存储的队列，称为链式队列。
代码随想录刷题训练营DAY 15 二叉树 Part 02 | 102. 二叉树的层序遍历 107. 二叉树的层序遍历 Ⅱ 226. 反转二叉树 101. 对称二叉树---火腿
09-23
引中提到，二叉树的层序遍历可以通过DFS或BFS来实现。其中，BFS是利用队列的先进先出特性来实现的，每一层的节点被...综上所述，参考这些引用，可以通过BFS来实现二叉树的层序遍历，并通过递归法或迭代法来翻转二叉树。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

xuwuuu

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

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

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

打赏作者

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

抵扣说明：

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

余额充值