树

最新推荐文章于 2023-04-24 20:02:17 发布
最新推荐文章于 2023-04-24 20:02:17 发布
阅读量172 收藏
点赞数 1
分类专栏： LeetCode 文章标签： java leetcode 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_43826142/article/details/114807267
版权

2021.03.14

94.二叉树的中序遍历

在这里插入图片描述

    /**
     * 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) {
            List<Integer> list = new LinkedList<>();
            inorder(root, list);
            return list;
        }

        void inorder(TreeNode root, List<Integer> res) {
            if (root == null) {
                return;
            }
            inorder(root.left, res);
            res.add(root.val);
            inorder(root.right, res);
        }
    }

95.不同的二叉搜索树Ⅱ

在这里插入图片描述

    /**
     * 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<TreeNode> generateTrees(int n) {
            if (n == 0) {
                return new LinkedList<>();
            }
            return generateTrees(1,n);
        }
        List<TreeNode> generateTrees(int start, int end){
            List<TreeNode> allTrees = new LinkedList<>();
            if(start > end){
                allTrees.add(null);
                return allTrees;
            }

            for (int index = start; index <= end ; index++) {
                List<TreeNode> leftTrees=generateTrees(start,index-1);
                List<TreeNode> rightTrees = generateTrees(index+1,end);
                for (TreeNode left : leftTrees) {
                    for (TreeNode right : rightTrees) {
                        TreeNode currTree = new TreeNode(index);
                        currTree.left=left;
                        currTree.right = right;
                        allTrees.add(currTree);
                    }
                }
            }

            return allTrees;

        }

    }

96.不同的二叉搜索树

在这里插入图片描述

    class Solution {
        public int numTrees(int n) {
            long C = 1;
            for (int i = 1; i <= n; i++) {
                C = C*(4*i - 2) / (i+1);
            }
            return (int)C;
        }
    }

98.验证二叉搜索树

在这里插入图片描述


    /**
     * 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 isValidBST(TreeNode root) {
            return isValidBST(root, null, null);
        }

        boolean isValidBST(TreeNode root, TreeNode min, TreeNode max) {
            //base case
            if (root == null){
                return true;
            }
            if (min != null && root.val <= min.val){
                return false;
            }
            if( max != null && root.val >= max.val){
                return false;
            }
            return isValidBST(root.left,min,root) && isValidBST(root.right,root,max);

        }

    }

99.恢复二叉搜索树

在这里插入图片描述

/**
 * 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 TreeNode prev = null;
    private TreeNode s = null;
    private TreeNode t = null;
    public void recoverTree(TreeNode root) {
        traverse(root);
        s.val ^= t.val;
        t.val ^= s.val;
        s.val ^= t.val;
    }
    void traverse(TreeNode node){
        if(node==null) return;
        traverse(node.left);
        if(prev!=null && node.val < prev.val){
            s = (s == null) ? prev : s;
            t = node;
        }

        prev = node;
        traverse(node.right);
    }
}

100.相同的树

在这里插入图片描述


    /**
     * 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) {
            //base case-1
            if (p == null && q == null){
                return true;
            }

            //base case-2
            if (p == null || q == null){
                return false;
            }

            //base case-3
            if (p.val != q.val){
                return false;
            }
            return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
        }
    }

101.对称二叉树

在这里插入图片描述

/**
 * 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 check(root,root);
    }
    public boolean check(TreeNode p,TreeNode q){
        if (p == null && q == null){
            return true;
        }
        if (p ==null || q == null){
            return false;
        }
        return p.val == q.val && check(p.left,q.right) && check(p.right, q.left);
    }

}

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>> levelOrder(TreeNode root) {
        List<List<Integer>> res = new LinkedList<>();
        if (root == null){
            return res;
        }
        Queue<TreeNode> q = new LinkedList<>();
        q.offer(root);

        while (!q.isEmpty()){

            List<Integer> level = new ArrayList<>();
            int currentLevelSize = q.size();
            for (int i = 0; i < currentLevelSize; i++) {
                TreeNode cur = q.poll();
                level.add(cur.val);

                if(cur.left != null){
                    q.offer(cur.left);
                }
                if (cur.right != null){
                    q.offer(cur.right);
                }
            }
            res.add(level);
        }

        return res;
    }
}

2021.03.15

103. 二叉树的锯齿形层序遍历

在这里插入图片描述

    /**
     * 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>> zigzagLevelOrder(TreeNode root) {
            List<List<Integer>> res = new LinkedList<>();
            if (root == null){
                return res;
            }

            Queue<TreeNode> q = new LinkedList<>();
            q.offer(root);
            int count = 0;
            while (!q.isEmpty()){
                LinkedList<Integer> level = new LinkedList<>();
                int currentLevelSize = q.size();

                for (int i = 0; i < currentLevelSize; i++) {
                    TreeNode cur = q.poll();

                    if (count % 2 ==0){
                        level.addLast(cur.val);
                    }else{
                        level.addFirst(cur.val);
                    }

                    if (cur.left != null){
                        q.offer(cur.left);
                    }
                    if(cur.right != null){
                        q.offer(cur.right);
                    }
                }
                count++;
                res.add(level);
            }
            return res;
        }
    }

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;
        }
        return Math.max(maxDepth(root.left),maxDepth(root.right)) + 1;
    }
}

105. 从前序与中序遍历序列构造二叉树

在这里插入图片描述


    /**
     * 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 buildTree(int[] preorder, int[] inorder) {
            int n = preorder.length;
            // 构造哈希映射，帮助我们快速定位根节点
            Map<Integer, Integer> inMap = new HashMap<Integer, Integer>();
            for (int i = 0; i < n; i++) {
                inMap.put(inorder[i], i);
            }
            return buildTree(preorder, 0, n - 1, inorder, 0, n - 1, inMap);
        }

        TreeNode buildTree(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd, Map<Integer, Integer> inMap) {
            if (preStart > preEnd || inStart > inEnd) return null;

            TreeNode root = new TreeNode(preorder[preStart]);
            int inRoot = inMap.get(root.val);
            int numsLeft = inRoot - inStart;
            root.left = buildTree(preorder, preStart + 1, preStart + numsLeft, inorder, inStart, inRoot - 1, inMap);
            root.right = buildTree(preorder, preStart + numsLeft + 1, preEnd, inorder, inRoot + 1, inEnd, inMap);
            return root;
        }

    }

106. 从中序与后序遍历序列构造二叉树

在这里插入图片描述


    /**
     * 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 {
        Map<Integer, Integer> inMap;
        public TreeNode buildTree(int[] inorder, int[] postorder) {
            int n = postorder.length;
            inMap = new HashMap<>();
            for (int i = 0; i < n; i++) {
                inMap.put(inorder[i], i);
            }
            return buildTree(inorder, 0, n - 1,
                    postorder, 0, n - 1);
        }

        public TreeNode buildTree(int[] inorder, int inStart, int inEnd,
                                  int[] postorder, int postStart, int postEnd) {
            if (inStart > inEnd || postStart > postEnd) {
                return null;
            }
            TreeNode root = new TreeNode(postorder[postEnd]);
            int inRoot = inMap.get(root.val);
            int leftSize = inRoot - inStart;
            root.left = buildTree(inorder, inStart, inRoot - 1,
                    postorder, postStart, postStart + leftSize - 1);
            root.right = buildTree(inorder, inRoot + 1, inEnd,
                    postorder, postStart + leftSize, postEnd - 1);
            return root;
        }
    }

107. 二叉树的层序遍历 II

在这里插入图片描述

/**
 * 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>> levelOrderBottom(TreeNode root) {
        LinkedList<List<Integer>> res = new LinkedList<>();
        if (root == null){
            return res;
        }
        Queue<TreeNode> q = new LinkedList<>();

        q.offer(root);
        while (!q.isEmpty()){
            int currentLevelSize = q.size();
            LinkedList<Integer> level = new LinkedList<>();
            for (int i = 0; i < currentLevelSize; i++) {
                TreeNode cur = q.poll();
                level.add(cur.val);
                if (cur.left != null){
                    q.offer(cur.left);
                }

                if (cur.right != null){
                    q.offer(cur.right);
                }
            }
            res.addFirst(level);
        }
        return res;
    }
}

2021.3.19

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 null;
            }
            connectTwoNode(root.left, root.right);
            return root;
        }

        void connectTwoNode(Node leftNode, Node rightNode) {
            if (leftNode == null || rightNode == null) {
                return;
            }
            leftNode.next = rightNode;

            connectTwoNode(leftNode.left, leftNode.right);
            connectTwoNode(rightNode.left, rightNode.right);
            connectTwoNode(leftNode.right, rightNode.left);
        }
    }

114. 二叉树展开为链表

在这里插入图片描述


    /**
     * 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 void flatten(TreeNode root) {
            if (root == null) {
                return;
            }
            flatten(root.left);
            flatten(root.right);

            TreeNode left = root.left;
            TreeNode right = root.right;
            root.left = null;
            root.right = left;

            TreeNode p = root;
            while (p.right != null) {
                p = p.right;
            }
            p.right = right;
        }
    }

226. 翻转二叉树

在这里插入图片描述


    /**
     * 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) {
            //base case
            if (root == null){
                return null;
            }

            TreeNode tmp = root.left;
            root.left = root.right;
            root.right = tmp;

            invertTree(root.left);
            invertTree(root.right);

            return root;
        }
    }

654. 最大二叉树

在这里插入图片描述在这里插入图片描述


    /**
     * 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 constructMaximumBinaryTree(int[] nums) {
            return build(nums, 0, nums.length - 1);
        }

        TreeNode build(int[] nums, int left, int right) {
            if (left > right) {
                return null;
            }

            int index = -1, max = Integer.MIN_VALUE;
            for (int i = left; i <= right; i++) {
                if (max < nums[i]) {
                    index = i;
                    max = nums[i];
                }
            }

            TreeNode root = new TreeNode(max);
            root.left = build(nums, left, index - 1);
            root.right = build(nums, index + 1, right);
            return root;
        }
    }

652. 寻找重复的子树

在这里插入图片描述


    /**
     * 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 {
        HashMap<String, Integer> memo = new HashMap<>();
        LinkedList<TreeNode> res = new LinkedList<>();

        public List<TreeNode> findDuplicateSubtrees(TreeNode root) {
            traverse(root);
            return res;
        }

        String traverse(TreeNode root) {
            if (root == null) {
                return "#";
            }
            String left = traverse(root.left);
            String right = traverse(root.right);

            String subTree = left + "," + right + "," + root.val;
            int freq = memo.getOrDefault(subTree, 0);
            if (freq == 1) {
                res.add(root);
            }
            memo.put(subTree, freq + 1);
            return subTree;
        }
    }

297. 二叉树的序列化与反序列化

在这里插入图片描述在这里插入图片描述


    /**
     * Definition for a binary tree node.
     * public class TreeNode {
     * int val;
     * TreeNode left;
     * TreeNode right;
     * TreeNode(int x) { val = x; }
     * }
     */
    public class Codec {
        String SEP = ",";
        String NULL = "#";

        // Encodes a tree to a single string.
        public String serialize(TreeNode root) {
            StringBuilder sb = new StringBuilder();
            serialize(root, sb);
            return sb.toString();
        }

        void serialize(TreeNode root, StringBuilder sb) {
            if (root == null) {
                sb.append(NULL).append(SEP);
                return;
            }
            sb.append(root.val).append(SEP);

            serialize(root.left, sb);
            serialize(root.right, sb);
        }

        // Decodes your encoded data to tree.
        public TreeNode deserialize(String data) {
            LinkedList<String> nodes = new LinkedList<>();
            for (String s : data.split(SEP)) {
                nodes.addLast(s);
            }
            return deserialize(nodes);
        }

        TreeNode deserialize(LinkedList<String> nodes) {
            if (nodes.isEmpty()) {
                return null;
            }

            String first = nodes.removeFirst();
            if (first.equals(NULL)) {
                return null;
            }
            TreeNode root = new TreeNode(Integer.parseInt(first));

            root.left = deserialize(nodes);
            root.right = deserialize(nodes);
            return root;
        }
    }

// Your Codec object will be instantiated and called as such:
// Codec ser = new Codec();
// Codec deser = new Codec();
// TreeNode ans = deser.deserialize(ser.serialize(root));

230. 二叉搜索树中第K小的元素

在这里插入图片描述


    /**
     * 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 {
        int res = 0;
        int rank = 0;

        public int kthSmallest(TreeNode root, int k) {
            traverse(root, k);
            return res;
        }

        void traverse(TreeNode root, int k) {
            if (root == null) {
                return;
            }
            traverse(root.left, k);
            rank++;
            if (k == rank) {
                res = root.val;
                return;
            }
            traverse(root.right, k);
        }
    }

538. 把二叉搜索树转换为累加树

在这里插入图片描述


    /**
     * 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 convertBST(TreeNode root) {
            traverse(root);
            return root;
        }
        int sum = 0;
        void traverse(TreeNode root){
            if (root == null){
                return;
            }
            traverse(root.right);
            sum += root.val;
            root.val = sum;
            traverse(root.left);
        }
    }

450. 删除二叉搜索树中的节点

在这里插入图片描述


    /**
     * 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 deleteNode(TreeNode root, int key) {
            if (root == null){
                return null;
            }
            if (root.val == key){
                if (root.left == null){
                    return root.right;
                }
                if (root.right == null){
                    return root.left;
                }
                TreeNode minNode = getMin(root.right);
                root.val = minNode.val;
                root.right = deleteNode(root.right,minNode.val);
            }else if(root.val > key){
                root.left = deleteNode(root.left,key);
            }else if (root.val <key){
                root.right = deleteNode(root.right,key);
            }
            return root;
        }

        TreeNode getMin(TreeNode root){
            while (root.left != null){
                root = root.left;
            }
            return root;
        }
    }

701. 二叉搜索树中的插入操作

在这里插入图片描述


    /**
     * 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 insertIntoBST(TreeNode root, int val) {
            if (root == null) {
                return new TreeNode(val);
            }
            if (root.val < val) {
                root.right = insertIntoBST(root.right, val);
            }
            if (root.val > val) {
                root.left = insertIntoBST(root.left, val);
            }
            return root;
        }
    }

700. 二叉搜索树中的搜索

在这里插入图片描述


    /**
     * 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 searchBST(TreeNode root, int val) {
            if (root == null || root.val == val) {
                return root;
            }
            if (root.val < val) {
                return searchBST(root.right, val);
            }
            if (root.val > val) {
                return searchBST(root.left, val);
            }
            return null;
        }
    }
weixin_43826142
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 4
    评论
专栏目录
python决策树代码
10-12
决策树(Decision Tree）是在已知各种情况发生概率的基础上，通过构成决策树来求取净现值的期望值大于等于零的概率，评价项目风险，判断其可行性的决策分析方法，是直观运用概率分析的一种图解法。由于这种决策分支画...
【数据结构】史上最好理解的红黑树讲解，让你彻底搞懂红黑树
小七的博客
01-18 18万+
狂肝半个月的学习笔记，最通俗易懂的红黑树讲解。带你快速掌握红黑树~
Python樱花树
最新发布
兔子王
04-24 6万+
Python樱花树以及樱花林代码。
数据结构：树(Tree)【详解】
UniqueUnit的博客
02-26 15万+
树 一、知识框架 二、考纲内容 树的基本概念 二叉树 二叉树的定义及其主要特征；二叉树的顺序存储结构和链式存储结构；二叉树的遍历；线索二叉树的基本概念和构造 树、森林 树的存储结构；森林与二叉树的转换；树和森林的遍历 树与二叉树的应用 二叉排序树；平衡二叉树；哈夫曼树和哈弗编码 三、树的基本概念 1、树的定义 树是n（n>=0）个结点的有限集。当n = 0时，称为空树。在任意一棵非空树中应满足： 有且仅有一个特定的称为根的结点。 当n>1时，其余节点可分为m（m>
【机器学习实战】3、决策树
呆呆的猫的博客
03-13 36万+
(声明：本文内容来自机器学习实战和统计学习方法，是两者的整合，并非来自单个书籍）决策树（decision tree）：是一种基本的分类与回归方法，此处主要讨论分类的决策树。在分类问题中，表示基于特征对实例进行分类的过程，可以认为是if-then的集合，也可以认为是定义在特征空间与类空间上的条件概率分布。决策树通常有三个步骤：特征选择、决策树的生成、决策树的修剪。用决策树分类：从根节点开始，对实例的某一特征进行测试，根据测试结果将实例分配到其子节点，此时每个子节点对应着该特征的一个取值，如此递归的对实例进行测
对红黑树的认识总结
热门推荐
张彦峰的博客
05-12 170万+
当在红黑树中执行插入操作时，需要考虑两个主要方面：保持二叉搜索树性质和保持红黑性质。以下是插入操作的详细步骤，包括可能的旋转操作和颜色调整。插入操作的基本步骤：首先，将新节点插入到红黑树中，就像在普通的二叉搜索树中一样。新节点会被标记为红色，因为它可能会破坏红黑性质的第一个性质（根节点必须是黑色）。插入新节点后，可能会破坏红黑性质。需要通过一系列的操作来调整以确保所有的红黑性质得到满足。在进行旋转操作之前，需要进行颜色调整以满足红黑性质。
哈夫曼树（C语言实现）
2021dragon的博客
06-18 9万+
文章目录哈夫曼树的基本概念哈夫曼树的构建构建思路代码实现哈夫曼编码的生成编码生成思路代码实现完整代码展示以及代码测试 哈夫曼树的基本概念 在认识哈夫曼树之前，你必须知道以下几个基本术语： 1、什么是路径？  给定N个权值作为N个结点，构造一棵二叉树，若该树的带权路径长度达到最小，则称该二叉树为哈夫曼树，也被称为最优二叉树。 哈夫曼树的构建 构建思路 代码实现 哈夫曼编码的生成 编码生成思路 代码实现 完整代码展示以及代码测试 ...
哈夫曼树原理解析，构造方法，意义和作用。
Anakki的博客
08-05 29万+
哈夫曼树（最优二叉树） 百度百科：https://baike.baidu.com/item/%E5%93%88%E5%A4%AB%E6%9B%BC%E6%A0%91/2305769?fr=aladdin 一. 目的： 找出存放一串字符所需的最少的二进制编码 二. 构造方法： 首先统计出每种字符出现的频率！（也可以是概率）//权值 ----------------------------...
红黑树详解
lucyLee的博客
09-12 10万+
1. 概述 1.1 红黑树的引入 有了二叉搜索树，为什么还需要平衡二叉树？ 在学习二叉搜索树、平衡二叉树时，我们不止一次提到，二叉搜索树容易退化成一条链 这时，查找的时间复杂度从O(log2N)O(log_2N)O(log2​N)也将退化成O(N)O(N)O(N) 引入对左右子树高度差有限制的平衡二叉树，保证查找操作的最坏时间复杂度也为O(log2N)O(log_2N)O(log2​N) 有了平衡二叉树，为什么还需要红黑树？ AVL的左右子树高度差不能超过1，每次进行插入/删除操作时，几乎都需要通过旋
LSM树
艾斯-李的博客
06-26 3万+
关于LSM树 LSM树，即日志结构合并树(Log-Structured Merge-Tree)。其实它并不属于一个具体的数据结构，它更多是一种数据结构的设计思想。大多NoSQL数据库核心思想都是基于LSM来做的，只是具体的实现不同。所以本来不打算列入该系列，但是有朋友留言了好几次让我讲LSM树，那么就说一下LSM树。 LSM树诞生背景 传统关系型数据库使用btree或一些变体作为存储结构，能...
b+树详解
qq_45814695的博客
05-22 5万+
B树 与 B+树 我们今天要介绍的是工作开发中最常接触到的 InnoDB 存储引擎中的 B+ 树索引。要介绍 B+ 树索引，就不得不提二叉查找树，平衡二叉树和 B 树这三种数据结构。B+ 树就是从他们仨演化来的。 二叉查找树 首先，让我们先看一张图： 从图中可以看到，我们为 user 表（用户信息表）建立了一个二叉查找树的索引。 图中的圆为二叉查找树的节点，节点中存储了键（key）和数据（data）。键对应 user 表中的 id，数据对应 user 表中的行数据。 二叉查找树的特点就是任何节点的左子节点
B树和B+树
12-14
所有的值都是按照顺序存储，没有重复的元素，并且每个叶子节点到根节点的距离相同，B树的中间节点会存储数据指针信息，B树索引能够加快访问速度，是因为存储引擎不再需要全表扫描来获取数据。 B+树 B+树有重复的...
LabVIEW的树形
01-19
树形控件用于向用户提供一个可供选择的层次化列表。用户将输入树形控件的项组织为若干组项或若干组节点，单击节点旁边的展开符号可展开节点，显示该节点中的所有项。单击节点旁的符号还可折叠节点。树形控件为目录状...
多叉树的树形显示
04-09
多叉树，作为数据结构的一种，是树形结构的扩展，它允许每个节点有超过两个子节点，与二叉树（每个节点最多两个子节点）形成对比。本文将深入探讨多叉树的定义、特性、应用以及如何实现其树形显示。 首先，理解多叉...
unity植物树木模型资源
08-22
1.内含大量树木 , 植物模型,还有LOD模型 2.unity植物树木模型资源，可导入直接使用，本博客所分享的资源，仅供学习使用，请勿商用！！！谢谢
八叉树Demo - Unity下
06-24
在Unity游戏引擎中，开发大型复杂场景时，为了提高场景管理效率和性能，常常会用到空间分割技术，如八叉树（Octree）就是其中一种。八叉树是一种数据结构，它将三维空间分成八个子空间，每个子空间又可以进一步划分...
超火的圣诞树代码html源码分享
02-24
超火的圣诞树代码html源码分享超火的圣诞树代码html源码分享超火的圣诞树代码html源码分享超火的圣诞树代码html源码分享超火的圣诞树代码html源码分享超火的圣诞树代码html源码分享超火的圣诞树代码html源码分享超火...
平衡搜索树详解：从二叉搜索树到红黑树
"这篇文档由小组成员张晓丹、徐兵兵、马喜刚和张稳龙共同讨论，主要介绍了平衡搜索树的概念，包括平衡二叉搜索树（AVL树）和红黑树，旨在解决二叉搜索树查找效率低下的问题。" 平衡搜索树是一种特殊的二叉树数据...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值