二叉树基础（二）

最新推荐文章于 2024-09-14 15:47:59 发布
最新推荐文章于 2024-09-14 15:47:59 发布
阅读量45 收藏
点赞数
分类专栏： 算法 Java 文章标签： 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qa18252714222/article/details/133282608
版权
算法 同时被 2 个专栏收录
11 篇文章 0 订阅
订阅专栏
Java
11 篇文章 0 订阅
订阅专栏

101. 对称二叉树

题意：给定一个二叉树，检查它是否是镜像对称的。

image-20220530202759480

1、思路：递归法

  • 判断对称二叉树要比较的是哪两个节点，要比较的可不是左右节点！

  • 本题遍历只能是“后序遍历”，因为我们要通过递归函数的返回值来判断两个子树的**内侧节点和外侧节点**是否相等。

  • 因为要遍历两棵树而且要比较内侧和外侧节点，所以准确的来说是一个树的遍历顺序是左右中，一个树的遍历顺序是右左中

  • 既然确定了本次采用后续遍历，且一个树采用左右中，另一个树采用右左中

    • 确定递归函数的参数和返回值
      因为我们需要判断根节点的两个子树是否可以翻转，所以参数为根节点的左子树和右子树boolean isSymmetric(TreeNode left, TreeNode right)

    • 确定终止条件

      • 如果左节点为空，右节点不为空，则直接返回false
      • 如果右节点为空，左节点不为空，则直接返回false
      • 如果左右节点都为空，则直接返回true
      • 如果左右节点都不为空，且左右节点值不相等，则直接返回false
      • 如果左右节点都不为空，且左右节点值都相等，则继续向下执行，注意左右节点都为空，则直接返回true

      image-20220530204357713

    • 确定单次循环逻辑

      • 比较外侧是否对称，即左子树的左节点，右子树的右节点
      • 比较内测是否对称，即左子树的右节点，右子树的左节点
      • 内外侧都对称，则返回true
package com.yzu.lee.treenode;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @ClassName: IsSymmetric
 * @Description:
 * @author: Leekuangyew
 * @date: 2022/5/27 9:51
 */
public class IsSymmetric {
    public boolean isSymmetric(TreeNode root) {
        //递归法
        if (root == null) return false;
        return isSymmetric(root.left, root.right);
    }

    private boolean isSymmetric(TreeNode left, TreeNode right) {
        if (left == null && right != null) {
            return false;
        }
       if (right == null && left != null) {
            return false;
        }
        if (left == null && right == null) {
            return true;
        }
        if (left.val != right.val) {
            return false;
        }
        //为什么left和right都不为空，并且left和right的值相等，不直接相反 ，因为需要继续往下递归
        boolean outer = isSymmetric(left.left, right.right); //左子树：左、 右子树：右
        boolean inner = isSymmetric(left.right, right.left);//左子树：右、右子树：左
        return outer && inner;
    }

}

2、思路：迭代法

  • 用队列实现层次遍历
    • 创建一个队列，并将根节点的左节点和右节点分别加入队列中
    • 循环判断队列是否为空
      • 从队列中头部取出两个节点，分别赋值给左节点leftNode和右节点rightNode
      • 对左右节点进行判断
        • 如果左节点为空，右节点不为空，则直接返回false
        • 如果右节点为空，左节点不为空，则直接返回false
        • 如果左右节点都为空，则跳出本次循环，继续下次循环
        • 如果左右节点都不为空，且左右节点值不相等，则直接返回false
      • 接下来向队列中添加节点，注意顺序
        • 添加左子树的左节点，添加右子树的右节点
        • 添加左子树的右节点，添加右子树的左节点
    • 最终返回true
public boolean isSymmetric(TreeNode root) {
    //迭代法
    if (root == null) return false;
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root.left);
    queue.offer(root.right);

    while (!queue.isEmpty()) {

        TreeNode leftNode = queue.poll();
        TreeNode rightNode = queue.poll();

        if (leftNode == null && rightNode != null) {
            return false;
        }
        if (rightNode == null && leftNode != null) {
            return false;
        }
        if (rightNode == null && leftNode == null) {
            continue;
        }
        if (rightNode.val != leftNode.val) {
            return false;
        }

        queue.offer(leftNode.left);
        queue.offer(rightNode.right);
        queue.offer(leftNode.right);
        queue.offer(rightNode.left);
            }
    	return true;
}

100.相同的树

题意：给你两棵二叉树的根节点 p 和 q ，编写一个函数来检验这两棵树是否相同。

如果两个树在结构上相同，并且节点具有相同的值，则认为它们是相同的。

image-20220601194832663

1、思路：递归法

  • 本题与对称二叉树的方法基本相同
  • 采用后续遍历，遍历两个树的遍历顺序是左右中
    • 确定递归函数的参数和返回值，boolean isSameTree(TreeNode p, TreeNode q),参数传入两个树的根节点
    • 确定终止条件
      • 如果左树节点为空，右树节点不为空，则直接返回false
      • 如果右树节点为空，左树节点不为空，则直接返回false
      • 如果左树节点和右树节点都为空，则直接返回true
      • 如果左树节点和右树节点的值不想等，则直接返回false
    • 确定单次循环逻辑
      • 比较两棵树的左子树是否相等
      • 比较两棵树的右子树是否相等
      • 左右子树都相等，则返回true
public boolean isSameTree(TreeNode p, TreeNode q) {
        //递归法
        if (p == null && q != null) {
            return false;
        }
        if (q == null && p != null) {
            return false;
        }
        if (q == null && p == null) {
            return true;
        }
        if (q.val != p.val) {
            return false;
        }

        boolean leftNode = isSameTree(p.left, q.left);
        boolean rightNode = isSameTree(p.right, q.right);
        return leftNode && rightNode;
    }

2、思路：迭代法

  • 利用队列层序遍历
  • 一开始将左树根节点和右树根节点添加到队列中
  • 当队列不为空时，就一直循环
    • 从队列中取出两个节点，分别赋值为leftNode和rightNode
    • 当左节点和右节点都为空，则跳出循环，并继续下次循环
    • 当左节点为空或者右节点为空或者左节点与右节点值不想等，直接返回false
    • 然后依次将左树和右树的左节点，左树和右树的右节点添加入队列中
public boolean isSameTree(TreeNode p, TreeNode q) {
    //迭代法
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(p);
    queue.offer(q);

    while (!queue.isEmpty()) {
        TreeNode leftNode = queue.poll();
        TreeNode rightNode = queue.poll();

        if (leftNode == null && rightNode == null) {
            continue;
        }

        if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
            return false;
        }

        queue.offer(leftNode.left);
        queue.offer(rightNode.left);
        queue.offer(leftNode.right);
        queue.offer(rightNode.right);
    }
    return true;
}

572.另一个树的子树

题意：给你两棵二叉树 root 和 subRoot 。检验 root 中是否包含和 subRoot 具有相同结构和节点值的子树。如果存在，返回 true ；否则，返回 false 。

二叉树 tree 的一棵子树包括 tree 的某个节点和这个节点的所有后代节点。tree 也可以看做它自身的一棵子树。

image-20220601201312286

1、思路：递归法

  • 按照后序进行遍历，两个后序遍历
    • 确定递归函数的参数和返回值，boolean isSubtree(TreeNode root, TreeNode subRoot),参数是树的根节点和子树的根节点
    • 确定终止条件，当传入的节点为空时，直接返回false
    • 确定单次递归逻辑
      • 判断传入的树节点与子树是否相等，如果相等就直接返回true，if (sameTree(root, subRoot))
      • 判断两个树是否相等的方法在上一题中已经讲解
      • 分别遍历左子树与右子树是否与子树相等，最终返回left || right
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
        //递归法
        if (root == null) {
            return false;
        }
        if (sameTree(root, subRoot)) {
            return true;
        }
        boolean left = isSubtree(root.left, subRoot);
        boolean right = isSubtree(root.right, subRoot);
        return left || right;
}

private boolean sameTree(TreeNode p, TreeNode q) {
        if (p == null && q != null) {
            return false;
        }
        if (q == null && p != null) {
            return false;
        }
        if (q == null && p == null) {
            return true;
        }
        if (q.val != p.val) {
            return false;
        }
        boolean leftNode = sameTree(p.left, q.left);
        boolean rightNode = sameTree(p.right, q.right);
        return leftNode && rightNode;
}

2、思路：迭代法

  • 迭代法与递归法思路完全一样
public boolean isSubtree(TreeNode root, TreeNode subRoot) {
    //迭代法
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(root);

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

        while (size-- > 0) {
            TreeNode node = queue.poll();
            if (sameTree(node, subRoot)) {
                return true;
            }
            if (node.left != null) queue.offer(node.left);
            if (node.right != null) queue.offer(node.right);
        }
    }
    return false;
}

public boolean sameTree(TreeNode p, TreeNode q) {
    //迭代法
    Queue<TreeNode> queue = new LinkedList<>();
    queue.offer(p);
    queue.offer(q);

    while (!queue.isEmpty()) {
        TreeNode leftNode = queue.poll();
        TreeNode rightNode = queue.poll();

        if (leftNode == null && rightNode == null) {
            continue;
        }

        if (leftNode == null || rightNode == null || leftNode.val != rightNode.val) {
            return false;
        }

        queue.offer(leftNode.left);
        queue.offer(rightNode.left);
        queue.offer(leftNode.right);
        queue.offer(rightNode.right);
    }
    return true;
}

104.二叉树的最大深度

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

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

说明: 叶子节点是指没有子节点的节点。

image-20220530205800562

1、思路：递归法

  • 本题可以使用前序（中左右），也可以使用后序遍历（左右中），使用前序求的就是深度，使用后序求的是高度。而根节点的高度就是二叉树的最大深度，所以本题中我们通过后序求的根节点高度来求的二叉树最大深度。
    • 确定递归函数的参数和返回值：int maxDepth(TreeNode root),参数是传入树的根节点，返回这棵树的深度
    • 确定终止条件：如果为空节点的话，就返回0，表示高度为0。if (root == null) return 0;
    • 确定单层递归的逻辑:先求出左子树的深度，然后求出右子树的深度，最终返回左子树深度和右子树深度的较大值+1；
public int maxDepth(TreeNode root) {
        //DFS 递归
        if (root == null) return 0;
        else {
            int leftHeight = maxDepth(root.left);
            int rightHeight = maxDepth(root.right);
            return Math.max(leftHeight, rightHeight) + 1;
        }

    }

2、思路：迭代法

  • 使用迭代法的话，层序遍历最好，因为最大深度就是二叉树的层数
    • 利用队列来模拟层序遍历
    • 当队列不为空时，一直循环，每次循环深度加1
    • 最后返回深度
    /**
     * 迭代法，使用层序遍历
     */
    public int maxdepth(treenode root) {
        if(root == null) {
            return 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;
    }

559.n叉树的最大深度

题意：给定一个 n 叉树，找到其最大深度。

最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。

image-20220531152447722

1、思路：递归法

  • 确定递归函数的参数和返回值：int maxDepth(TreeNode root),参数是传入树的根节点，返回这棵树的深度
  • 确定终止条件：如果为空节点的话，就返回0，表示高度为0。if (root == null) return 0;
  • 确定单层递归的逻辑:循环遍历每一个子树，然后求出每一子树的深度，并进行比较，最终返回最大的子树深度+1；
package com.yzu.lee.treenode;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @ClassName: MaxDepthN
 * @Description:给定一个 N 叉树，找到其最大深度。
 * 最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
 * @author: Leekuangyew
 * @date: 2022/5/27  12:01
 */
public class MaxDepthN {
    public int maxDepth(Node root) {
        //递归法
        if (root == null) return 0;

        int depth = 0;
        for (Node child : root.children) {
            depth = Math.max(maxDepth(child), depth);
        }
        return depth + 1;
    }
}

2、思路：迭代法

  • 依然是层序遍历
public int maxDepth(Node root) {
    //迭代法
    if (root == null) return 0;
    int depth = 0;
    Queue<Node> queue = new LinkedList<>();
    queue.offer(root);

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

        while (size-- > 0) {
            Node node = queue.poll();

            if (node.children != null) {
                for (Node child : node.children) {
                    queue.offer(child);
                }
            }
        }
        depth++;
    }
    return depth;
}

111.二叉树的最小深度

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

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。

说明: 叶子节点是指没有子节点的节点。

image-20220531153205677

思路：

直觉上好像和求最大深度差不多，其实还是差不少的。

遍历顺序上依然是**后序遍历（因为要比较递归返回之后的结果），但在处理中间节点的逻辑上，最大深度很容易理解**，最小深度可有一个误区，如图：

image-20220531153403115

最小深度是从根节点到最近叶子节点的最短路径上的节点数量。，注意是叶子节点。

1、思路：递归法

  • 遍历顺序上依然是**后序遍历（因为要比较递归返回之后的结果）**
    • 确定递归函数的参数和返回值int minDepth(TreeNode root)，参数为树的根节点，返回最小深度
    • 确定终止条件if (node == NULL) return 0;终止条件也是遇到空节点返回0，表示当前节点的高度为0。
    • 确定单层递归的逻辑
      • 如果当前节点的左子树为空，右子树不为空，则返回右子树的深度+1；
      • 如果当前节点的右子树为空，左子树不为空，则返回左子树的深度+1；
      • 如果左右子树都不为空，则返回左右子树的最小深度+1；
package com.yzu.lee.treenode;

import java.time.OffsetDateTime;

/**
 * @ClassName: MinDepth
 * @Description:给定一个二叉树，找出其最小深度。 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
 * @author: Leekuangyew
 * @date: 2022/5/25  22:09
 */
public class MinDepth {
    /**
     * 递归法，相比求MaxDepth要复杂点
     * 因为最小深度是从根节点到最近**叶子节点**的最短路径上的节点数量
     */
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftDepth = minDepth(root.left);
        int rightDepth = minDepth(root.right);
        if (root.left == null) {
            return rightDepth + 1;
        }
        if (root.right == null) {
            return leftDepth + 1;
        }
        // 左右结点都不为null
        return Math.min(leftDepth, rightDepth) + 1;
    }
}

2、思路：迭代法

  • 同样采用层序遍历
    • 创建一个队列，并放入根节点
    • 当队列不为空时，则一直循环，每次循环深度+1；
    • 当某一个节点的左右子树都为空，则为叶子节点，直接返回深度
/**
     * 迭代法，层序遍历
     */
    public int minDepth(TreeNode root) {
        if (root == null) {
            return 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 && poll.right == null) {
                    // 是叶子结点，直接返回depth，因为从上往下遍历，所以该值就是最小值
                    return depth;
                }
                if (poll.left != null) {
                    deque.offer(poll.left);
                }
                if (poll.right != null) {
                    deque.offer(poll.right);
                }
            }
        }
        return depth;
    }

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

题意：给出一个完全二叉树，求出该树的节点个数。

示例 1：

  • 输入：root = [1,2,3,4,5,6]
  • 输出：6

image-20220531155826023

1、思路：递归法（普通二叉树）

  • 递归遍历的顺序依然是后序（左右中）
    • 确定递归函数的参数和返回值int countNodes(TreeNode root),参数传入根节点，返回节点数
    • 确定终止条件：if (root == null) return 0;
    • 确定单次递归逻辑：先求左子树的节点数量，再求右子树的节点数量，最终取总和再加1
    public int countNodes(TreeNode root) {
        //普通递归法
        if (root == null) return 0;

        int left = countNodes(root.left);
        int right = countNodes(root.right);
        return left + right + 1;
}

2、思路：迭代法（普通二叉树）

  • 层序遍历
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 node = queue.poll();

                if (node.left != null) queue.offer(node.left);
                if (node.right != null) queue.offer(node.right);
                result++;
            }
        }
        return result;
    }

3、思路：递归法（完全二叉树）

/**
 * 针对完全二叉树的解法
 * 满二叉树的结点数为：2^depth - 1
 */
public int countNodes(TreeNode root) {
    if (root == null) {
        return 0;
    }
    int leftDepth = getDepth(root.left);
    int rightDepth = getDepth(root.right);
    if (leftDepth == rightDepth) {// 左子树是满二叉树
        // 2^leftDepth其实是 （2^leftDepth - 1） + 1 ，左子树 + 根结点
        return (1 << leftDepth) + countNodes(root.right);
    } else {// 右子树是满二叉树
        return (1 << rightDepth) + countNodes(root.left);
    }
}

private int getDepth(TreeNode root) {
    int depth = 0;
    while (root != null) {
        root = root.left;
        depth++;
    }
    return depth;
}

110.平衡二叉树

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

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

image-20220531201209599

1、思路：递归法

  • 看这道题目和104.二叉树的最大深度很像，其实有很大区别。

  • 这里强调一波概念：

    • 二叉树节点的深度：指从根节点到该节点的最长简单路径边的条数。
    • 二叉树节点的高度：指从该节点到叶子节点的最长简单路径边的条数。

    但leetcode中强调的深度和高度很明显是按照节点来计算的，如图：

    ==image-20220531201613688==

    因为求深度可以从上到下去查 所以需要前序遍历（中左右），而高度只能从下到上去查，所以只能后序遍历（左右中）

    为什么104.二叉树的最大深度 (opens new window)中求的是二叉树的最大深度，也用的是后序遍历。

    那是因为代码的逻辑其实是求的根节点的高度，而根节点的高度就是这棵树的最大深度，所以才可以使用后序遍历。

  • 所以这道题使用后序递归

    • 明确递归函数的参数和返回值int getHeight(TreeNode root) ,参数是传入节点，返回当前节点的高度
    • 明确终止条件if (root == null) return 0;递归过程中遇到空节点，则返回0
    • 确定单次递归的逻辑，分别求出左子树和右子树的高度，如果他们的差值小于等于1，则返回当前二叉树的高度，否则返回-1，已经不是平衡二叉树了
package com.yzu.lee.treenode;

import java.util.LinkedList;
import java.util.Queue;

/**
 * @ClassName: IsBalanced
 * @Description:给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为：一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。
 * @author: Leekuangyew
 * @date: 2022/5/27  18:00
 */
public class IsBalanced {
    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(rightHeight - leftHeight) > 1) {
            return -1;
        }
        return Math.max(rightHeight, leftHeight) + 1;
    }
}

257. 二叉树的所有路径

题意：给定一个二叉树，返回所有从根节点到叶子节点的路径。

说明: 叶子节点是指没有子节点的节点。

image-20220601001518580

1、思路：递归法

  • 要求从根节点到叶子的路径，所以需要前序遍历，这样才方便让父节点指向孩子节点，找到对应的路径。
  • 在这道题目中将第一次涉及到回溯，因为我们要把路径记录下来，需要回溯来回退一一个路径在进入另一个路径。
  • 前序遍历以及回溯的过程如图：

image-20220601001741343

  • 递归函数函数参数以及返回值：void traversal(TreeNode root, List<Integer> paths, List<String> result),参数需要传入根节点，记录每一条路径，以及存放结果集的result

  • 确定递归终止条件

    • 本题需要判断当前节点是否为叶子节点，如果是则停止，即**当 cur不为空，其左右孩子都为空的时候，就找到叶子节点。**

      if (root.left == null && root.right == null) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < paths.size() - 1; i++) {
        sb.append(paths.get(i) + "->");
    }
    sb.append(paths.get(paths.size() - 1));
    result.add(sb.toString());
    return;
}

    • 确定单层递归逻辑

      • 在递归一开始，需要把当前节点放入到Paths集合中
      • 如果当前节点 的左节点不为空，则递归，递归完之后需要进行回溯，回溯和递归是一一对应的，有一个递归，就要有一个回溯
      • 如果当前节点 的右节点不为空，则递归，递归完之后需要进行回溯，回溯和递归是一一对应的，有一个递归，就要有一个回溯
package com.yzu.lee.treenode;

import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: BinaryTreePaths
 * @Description:
 * @author: Leekuangyew
 * @date: 2022/5/27  18:30
 */
public class BinaryTreePaths {
    public List<String> binaryTreePaths(TreeNode root) {
        List<String> result = new ArrayList<>();
        //递归＋回溯
        if (root == null) return result;
        List<Integer> paths = new ArrayList<>();


        traversal(root, paths, result);
        return result;
    }

    private void traversal(TreeNode root, List<Integer> paths, List<String> result) {
        //中
        paths.add(root.val);
        if (root.left == null && root.right == null) {
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < paths.size() - 1; i++) {
                sb.append(paths.get(i) + "->");
            }
            sb.append(paths.get(paths.size() - 1));
            result.add(sb.toString());
            return;
        }

        //左
        if (root.left != null) {
            traversal(root.left, paths, result);
            paths.remove(paths.size() - 1);
        }
        //右
        if (root.right != null) {
            traversal(root.right, paths, result);
            paths.remove(paths.size() - 1);
        }
        return;
    }
}
Leekuangyee
关注
专栏目录
二叉树 基础
03-08
二叉树的每个结点至多只有二棵子树(不存在度大于2的结点)，二叉树的子树有左右之分，次序不能颠倒。二叉树的第i层至多有2^{i-1}个结点；深度为k的二叉树至多有2^k-1个结点；对任何一棵二叉树T，如果其终端结点数为n_...
数据结构-二叉树基础.pdf
04-15
### 数据结构之二叉树基础知识点详解 #### 一、二叉树基本概念 **二叉树**是一种特殊的树形结构，在计算机科学中被广泛应用于数据存储和检索中。二叉树具有以下特点： 1. **节点（Node）**：二叉树中的每一个元素...
二叉树基础
七秒钟的记忆
02-24 875
简单介绍二叉树必会的基础知识
二叉树基础总结
2301_80841939的博客
02-14 2616
树（层级结构）是一种重要的非线性数据结构（递归的数据结构），它由n（n≥0）个有限节点组成一个具有层次关系的集合。这些节点具有如下特性：（在一个有效的树中，如果有n个节点，就会有n-1条边。每个节点有零个或多个子节点。没有父节点的节点称为根节点。根：树的最顶部的节点，唯一没有双亲的节点。每一个非根节点有且只有一个父节点。除了根节点外，每个子节点可以分为多个不相交的子树。树的术语结点：使用树结构存储的每一个数据元素都被称为“结点”。森林：多棵互不相交的树的集合称为森林。
二叉树基础知识
yyhgo_的博客
10-28 1672
二叉树基础知识
二叉树基础详解
qq_56999918的博客
11-21 5283
1.树的定义和基本性质 树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。有一个特殊的结点，称为根结点，根节点没有前驱结点除根节点外，其余结点被分成M(M>0)个互不相交的集合T1、T2、……、Tm，其中每一个集合Ti(1<= i <= m)又是一棵结构与树类似的子树。每棵子树的根结点有且只有一个前驱，可以有0个或多个后继因此，树是递归定义的。 ...
二叉树基础运算
CRH1129的博客
01-07 657
实验目的： 设计一个二叉链表的程序，实现二叉链表存储的二叉树的数据结构，并完成二叉树的基础运算。 实验要求： 1、二叉链表的结点数据结构为 typedef char datatype; typedef struct node * pointer; struct node { datatype data; pointer lchild,rchild; }; typedef pointer bitree; //二叉树根节点 2、初始化二叉树init(BT)：置BT为空树 3、求双亲parent(BT, x)：求
二叉树基础知识和遍历算法等
04-24
### 二叉树基础知识与遍历算法详解 #### 一、二叉树基本概念 **二叉树**是一种特殊的树形结构，在计算机科学领域极为常见。它是一种数据结构，其中每个节点最多有两个子节点，通常被称为左子节点和右子节点。 ###...
python二叉树基础算法实现.pdf
05-07
### Python二叉树基础算法实现详解 #### 一、引言 在计算机科学领域，二叉树是一种重要的数据结构，广泛应用于多种算法和技术之中。它不仅有助于数据的组织与存储，还能有效地支持诸如查找、排序等功能。Python作为...
21_动态规划与数据结构结合
刘炫320的博客
09-11 475
老鸟：假设你有一个数组arr，你需要多次查询某个子数组arr[i:j]的和。直接计算会很慢，我们可以用动态规划预处理，再用一种数据结构来快速查询。菜鸟：听起来不错，但具体怎么做呢？老鸟：我们可以先构建一个数组prefixSum，其中表示数组arr从起始位置到i的和。这样每次查询arr[i:j]的和时，可以用来快速计算。菜鸟：这样确实能减少计算量，但构建prefixSum数组需要什么操作呢？老鸟：好问题。我们来看看代码示例。老鸟：今天我们讨论了动态规划与数据结构结合的应用，通过prefixSum。
C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储
BamBoo_Bean的博客
09-10 659
C语言-数据结构 无向图迪杰斯特拉算法(Dijkstra)邻接矩阵存储
数据结构——线性表（顺序存储结构和单链表结构）
weixin_74209413的博客
09-08 894
线性表（List）：由零个或多个数据元素组成的有限序列。（1）它是一个序列，也就是元素之间有个先来后到的；（2）若元素有多个，则第一个元素无前驱，最后一个无后继；（3）线性表是有限的；原子类型：不可以再分解的基本类型，例如整形、浮点型、字符型等结构类型：由若干个类型组合而成，是可以再分解的，例如整形数组是由若干个整形数据组成的。抽象数据类型抽象数据类型是指一个数学模型及定义在该模型上的一组操作；抽象数据类型的定义仅取决于它的一组逻辑特性，而与其在计算机内部如何表示和实现无关。
数据结构 1
2401_83575662的博客
09-14 338
算法（Algorithm）就是定义良好的计算过程，他取一个或一组的值为输入，并产生出一个或一组值作为 输出。简单来说算法就是一系列的计算步骤，用来将输入数据转化成输出结果。3.数据结构和算法的书籍资料学习完数据结构知识，可以去看《剑指offer》和《程序员代码面试指南》。4.算法的效率衡量一个算法的好坏，要从它的程序的时间复杂度和空间复杂度两方面来分析。时间复杂度主要衡量一个算法的运行快慢，而空间复杂度主要衡量一个算法运行所需要的额外空间。5.时间复杂度。
【JavaScript】数据结构之字典 & 哈希表
最新发布
票票的博客
09-14 410
数据结构之字典和哈希表
数据结构 - 链表
kaneki_lh的博客
09-11 414
listnode;/* 双向链表结构体 */}dlinklist;
数据结构————栈的讲解(超详细！！！)
braveact的博客
09-11 899
栈是一种特殊的线性表，其只允许在固定的一端进行插入和删除元素操作，进行数据插入和删除操作的一端称为栈顶，另一端称为栈底。栈中的数据元素遵循后进先出（先进后出）原则。特性与栈的结构有关。
数据结构(7.3_1)——二叉排序树
m0_65240792的博客
09-14 374
又称左子树结点值<根结点值<右子树结点值进行中序遍历，可以得到一个递增的有序序列二叉排序树可用于元素的有序组织，搜索。
从0开始的算法（数据结构和算法）基础（十）
Solidao的博客
09-12 833
分治的字面意思是分而治之，将问题进行分化，从而进行处理，最后将结果进行合并。尽量的将问题分的不可以再分，分到和操作系统里面的原语是一样的，用较为多空间进行多线程的并行，节省时间运行。递归调用可能会导致较大的递归开销，特别是在递归深度较大的情况下，可能会导致栈溢出。在某些情况下，分治方法可能会导致对同一子问题的重复计算，从而降低效率。例如，在动态规划问题中，使用简单的分治方法可能会导致大量重复计算。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Leekuangyee

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

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

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

打赏作者

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

抵扣说明：

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

余额充值