【JavaScript版数据结构与算法面向大厂面试】第八章 树

已于 2023-03-08 00:04:03 修改
阅读量169 收藏
点赞数
分类专栏： JavaScript版数据结构与算法 解决前端算法面试 文章标签： javascript 面试 深度优先
于 2023-03-04 15:53:53 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qiqizgl777/article/details/129152494
版权

目录

第八章 树

8.1 树简介

  1. 树：一种分层数据的抽象类型。
  2. 前端工作中常见的树：DOM、树、级联选择、树形控件…
  3. JS中没有树，但是可以用Object和Array构建树
  4. 树的常用操作：深度/广度优先遍历、先中后序遍历

8.2 深度与广度优先遍历

1.深度优先遍历：先访问一个节点下的深层次的节点（即尽可能深的搜索树的分支）

在这里插入图片描述

2.广度优先遍历：先横向遍历同级节点，再遍历下级的同级节点（即先访问离根节点最近的节点）

在这里插入图片描述

  1. 深度优先遍历（其实就是一个递归)

在这里插入图片描述

算法思想：
1.访问根节点
2.对根节点的children 挨个进行深度优先遍历

// 用Object声明一颗树,新建一颗树 
//var tree = {val:值,child[],...}
const tree = {
    val: 'a',//有一个val节点
    children: [
        {
            val: 'b',//有一个val节点
            children: [
                {
                    val: 'd',//有一个val节点
                    children: [],//有一个children数组
                },
                {
                    val: 'e',//有一个val节点

                    children: [],//有一个children数组
                }

            ],//有一个children数组
        },
        {
            val: 'c',//有一个val节点
            children: [
                {   > val: 'f',//有一个val节点
                children: [],//有一个children数组
              },
        {
            val: 'g',//有一个val节点
            children: [],//有一个children数组
        }
    ],//有一个children数组
}
  ],//有一个children数组
    }

const dfs = (root) => {// 新建一个函数，让这个函数接收这个root的根节点
    console.log(root.val); //访问这个根节点
    // root.children.forEach((child) => { //对这个根节点的children挨个进行深度优先遍历
    //     dfs(child)
    // });
    root.children.forEach(dfs);//对这个根节点的children挨个进行深度优先遍历
};

dfs(tree); //把整颗树传进去

4. 广度优先遍历：

在这里插入图片描述

  1. 新建一个队列，把根节点入队
  2. 把队头出队并访问
  3. 把队头的 children 挨个入队
  4. 重复第二、第三步，直到队列为空
// 用Object声明一颗树,新建一颗树 
const tree = {
    val: 'a',//有一个val节点
    children: [
        {
            val: 'b',//有一个val节点
            children: [
                {
                    val: 'd',//有一个val节点
                    children: [],//有一个children数组
                },
                {
                    val: 'e',//有一个val节点
                    children: [],//有一个children数组
                }
            ],//有一个children数组
        },
        {
            val: 'c',//有一个val节点
            children: [
                {
                    val: 'f',//有一个val节点
                    children: [],//有一个children数组
                },
                {
                    val: 'g',//有一个val节点
                    children: [],//有一个children数组
                }
            ],//有一个children数组
        }
    ],//有一个children数组
}
const bfs = (root) => {
    const q = [root];  //新建一个队列Q，并把根节点入队
    while (q.length > 0) { // 在队列不为空的情况下，不断地循环第二、三步
        const n = q.shift();//队头出队
        console.log(n.val);  //访问这个队头   
        n.children.forEach(child => { // 把对头的child挨个入队
            q.push(child);//把child加入队列中
        });// 把队头的child挨个入队 
    }
}
bfs(tree); //把整颗树传进去

8.3 二叉树的先中后序遍历

  1. 树的类型：
    1. 多叉树：树中每个节点有多个子节点
    2. 二叉树：树中每个节点最多只能有两个子节点
  2. 二叉树遍历方式
    1. 先序遍历算法口诀（根左右）
      1. 访问根节点
      2. 对根节点的左子树进行先序遍历
      3. 对根节点的右子树进行先序遍历
    2. 中序遍历算法口诀（左根右）
      1. 对根节点的左子树进行中序遍历
      2. 访问根节点
      3. 对根节点的右子树进行中序遍历
    3. 后序遍历算法口诀（左右根）
      1. 对根节点的左子树进行后序遍历
      2. 对根节点的右子树进行后序遍历
      3. 访问根节点

建二叉树存于文件bt.js中

// 用Object声明一颗树,新建一颗树 
const tree = {
    val: 'a',//有一个val节点
    children: [
        {
            val: 'b',//有一个val节点
            children: [
                {
                    val: 'd',//有一个val节点
                    children: [],//有一个children数组
                },
                {
                    val: 'e',//有一个val节点
                    children: [],//有一个children数组
                }
            ],//有一个children数组
        },
        {
            val: 'c',//有一个val节点
            children: [
                {
                    val: 'f',//有一个val节点
                    children: [],//有一个children数组
                },
                {
                    val: 'g',//有一个val节点
                    children: [],//有一个children数组
                }
            ],//有一个children数组
        }
    ],//有一个children数组
}
const bfs = (root) => {
    const q = [root];  //新建一个队列Q，并把根节点入队
    while (q.length > 0) { // 在队列不为空的情况下，不断地循环第二、三步
        const n = q.shift();//队头出队
        console.log(n.val);  //访问这个队头   
        n.children.forEach(child => { // 把对头的child挨个入队
            q.push(child);//把child加入队列中
        });// 把队头的child挨个入队 
    }
}
bfs(tree); //把整颗树传进去

先序遍历算法实现（递归版）

const bt = require('./bt');  //利用require语法导入构建二叉树的JS文件
//写一个先序遍历的方法
const preorder = (root) => {
    if (!root) {return;}// 如果为空则不要了
    console.log(root.val); //访问根节点
    preorder(root.left); //递归访问左子树
    preorder(root.right); //递归访问右子树
};

preorder(bt);  //调用先序遍历的方法，把二叉树丢进去

中序遍历算法实现（递归版）

const bt = require('./bt');  //利用require语法导入二叉树文件
const inorder = (root) => {//写一个中序遍历的方法，参数为root
    if (!root) {// 如果为空则不要了
        return;
    }
    preorder(root.left); //递归访问左子树
    console.log(root.val); //访问根节点
    preorder(root.right); //递归访问右子树
};

inorder(bt); //调用中序遍历的方法，把二叉树丢进去

后序遍历算法实现（递归版）

const bt = require('./bt');  //利用require语法导入二叉树文件
//写一个后序遍历的方法，参数为root
const postorder = (root) => {
    if (!root) { // 根节点如果为空则不要了
        return;
    }
    preorder(root.left); //递归访问左子树
    preorder(root.right); //递归访问右子树
    console.log(root.val); //访问根节点
};

postorder(bt); //调用后序遍历的方法，把二叉树丢进去

8.4 二叉树的先中后序遍历（非递归版）

1. 先序遍历

const bt = require('./bt');  //利用require语法导入二叉树文件

const preorder = (root) => {//写一个先序遍历的方法，参数为root
    if (!root) {// 根节点如果为空则不要了
        return;
    }
    const stack = [root];// 新建一个stack来模拟函数调用堆栈。把root传进栈，代表当前访问的这个节点是根节点

    // 我们知道如果在函数里面调用另外一个函数，则我们要往栈里面再推入一个函数
    // 用一个while循环来
    while (stack.length) {//当stack有值的时候跑起来
        const n = stack.pop(); //把根节点的值弹出来，下面再访问它
        console.log(n.val); //直接访问它
        // 如果根节点存在的话，我们就把它推入函数的调用堆栈中
        //根据栈的后进先出的特性，right要比left先进入栈
        if (n.right) {
            stack.push(n.right);//right进栈
        }
        if (n.left) {
            stack.push(n.left);//left进栈
        }
    }
};
preorder(bt);//调用先序遍历的方法，把二叉树丢进去

2. 中序遍历

const bt = require('./bt');  //利用require语法导入二叉树文件

//写一个中序遍历的方法，参数为root
const inorder = (root) => {
    // 根节点如果为空则不要了
    if (!root) {
        return;
    }
    // 我们知道如果在函数里面调用另外一个函数，则我们要往栈里面再推入一个函数
    const stack = [];// 新建一个stack代表一个函数的调用堆栈。把root传进栈，代表当前访问的这个节点是根节点

    // 第一步要把所有的左子树全部入栈，需要用到一个指针
    let p = root; //新建一个指针
    while (stack.length || p) {
        // 遍历整棵树的左节点，并把所有的左节点都推入栈中
        while (p) {
            stack.push(p); //每遍历一个节点都把它推入栈中
            p = p.left;//在指针有值的情况下
        }

        const n = stack.pop(); // 把最尽头的左节点弹出来
        console.log(n.val);//并访问左节点的值
        p = n.right; // 访问右节点，直接把指针指向右节点
    }
};

inorder(bt);//调用中序遍历的方法，把二叉树丢进去

3. 后序遍历

把先序遍历倒过来就是后序遍历了，但倒过来左右孩子还是不一样，需要改写一下

const bt = require('./bt');  //利用require语法导入二叉树文件

//写一个后序遍历的方法，参数为root
const postorder = (root) => {
    if (!root) {// 根节点如果为空则不要了
        return;
    }

    // 需要用到两个栈，声明两个栈
    const stack = [root];
    const outputStack = []; //这个栈用来倒置
    // 我们知道如果在函数里面调用另外一个函数，则我们要往栈里面再推入一个函数
    // 用一个while循环来
    while (stack.length) {
        const n = stack.pop(); //把根节点的值弹出来，下面再访问它
        outputStack.push(n); //直接把当前根节点推入栈
        // 如果根节点存在的话，我们就把它推入函数的调用堆栈中
        // 因为先序遍历倒序过来和后序遍历的左右孩子的顺序不太对，所心得换一下左右孩子的进栈顺序
        if (n.left) {//在根节点的左孩子有值的情况下
            stack.push(n.left);//left进栈
        }
        if (n.right) {
            /在根节点的右孩子有值的情况下
            stack.push(n.right);//right进栈
        }
        //全部是根节点先入倒置的那个栈
    }

    // 倒序输出
    while (outputStack.length) {
        const n = outputStack.pop();
        console.log(n.val);
    }
};

postorder(bt);//调用后序遍历的方法，把二叉树丢进去

8.5 LeetCode: 104. 二叉树的最大深度

在这里插入图片描述

解题思路：

  1. 求二叉树的最大深度，考虑使用深度优先遍历
  2. 在深度优先遍历过程中，记录每个节点所在的层级，找出最大层级

解题步骤：

  1. 新建变量，记录最大深度
  2. 深度优先遍历整棵树，并记录每个节点的层级，同时不断更新最大深度这个变量

代码实现：
法一：

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxDepth = function (root) {
    let res = 0;
    const dfs = (n, l) => {
        if (!n) { return; }
        res = Math.max(res, l);
        dfs(n.left, l + 1);
        dfs(n.right, l + 1);
    };
    dfs(root,1);
    return res;
};

代码解读：

  1. 先对二叉树进行了深度优先遍历：

在这里插入图片描述

  1. 获取每个节点的层级数：

在这里插入图片描述

法二：
代码实现：

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */
var maxDepth = function (root) {
    var res = 0;
    var dfs = (n, l) => {
        if (!n) { return; }
        if (!n.left && !n.right) {
            res = Math.max(res, l);
        }
        dfs(n.left, l + 1);
        dfs(n.right, l + 1);
    };
    dfs(root, 1);
    return res;
};

代码解读：

判断n是否是叶子节点，如果是则刷新最大的层级数： 如果当前的左节点为空并且右节点也为空，则刷新最大的层级数。

在这里插入图片描述

  1. 时间复杂度：O(n) n是整棵树的节点数，深度遍历循环了n次
  2. 空间复杂度：O(logn-n) 为二叉树的深度，最好深度为logn,最坏的情况深度为n

综上：法一效率更高些

8.6 LeetCode: 111. 二叉树的最小深度

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

在这里插入图片描述

在这里插入图片描述
代码实现：

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number}
 */

// 树的最小深度
var minDepth = function (root) {
    if (!root) { return 0; }
    var q = [[root, 1]];
    while (q.length) {
        var [n, l] = q.shift();
        if (!n.left && !n.right) {
            return l;
        }
        if (n.left) q.push([n.left, l + 1]);
        if (n.right) q.push([n.right, l + 1]);

    }
};

代码解读：

整棵树的广度优先遍历：

在这里插入图片描述

记录访问的每个节点的层级数。

在这里插入图片描述

8.7 LeetCode: 102. 二叉树的层序遍历

在这里插入图片描述
在这里插入图片描述
法一：
代码实现：

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var levelOrder = function (root) {
    if (!root) return [];//如果没有根节点，则返回一人空数组
    const q = [[root,0]];//新建一个根节点和层级数的数组
    const res = [];//新建一个数组，
    while (q.length) {
        const [n,level] = q.shift();
        if (!res[level]) {
            res.push([n.val]);
        } else {
            res[level].push(n.val);
        }
        if (n.left) q.push(n.left,level+1);//记录左节点，和其节点的层级数，为父节点加一
        if (n.right) q.push(n.right,level+1);   
    }
    return res;
};

代码解读：

整棵树的广度优先遍历：

在这里插入图片描述

记录访问的每个节点的层级数。

在这里插入图片描述

法二：
代码实现：

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var levelOrder = function (root) {
    if (!root) return [];
    var q = [root];
    var res = [];
    while (q.length) {
        let len = q.length;
        res.push([]);
        while (len--) {
            var n = q.shift();
            res[res.length - 1].push(n.val);
            if (n.left) q.push(n.left);
            if (n.right) q.push(n.right);
        }
    }
    return res;
};

8.8 LeetCode: 94. 二叉树的中序遍历

在这里插入图片描述

递归版：
代码实现：

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
// 递归版
var inorderTraversal = function (root) {
    var res = [];
    var rec = (n) => {
        if (!n) return;
        rec(n.left);
        res.push(n.val);
        rec(n.right);
    };
    rec(root);
    return res;
};

迭代版：
代码实现：

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
// 迭代版
var inorderTraversal = function (root) {
    var res = [];
    var stack = [];
    let p = root;
    while (stack.length || p) {
        while (p) {
            stack.push(p);
            p = p.left;
        }
        var n = stack.pop();
        res.push(n.val);
        p = n.right;
    }
    return res;
};

综上：迭代版的算法比递归版的算法效率要高。

8.9 LeetCode: 112. 路径总和

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

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

代码实现：

/**
 * Definition for a binary tree node.
 * function TreeNode(val, left, right) {
 *     this.val = (val===undefined ? 0 : val)
 *     this.left = (left===undefined ? null : left)
 *     this.right = (right===undefined ? null : right)
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} targetSum
 * @return {boolean}
 */
// 路径总和
var hasPathSum = function (root, sum) {
    if (!root) return false;
    let res = false;
    var dfs = (n, s) => {
        if (!n.left && !n.right && s === sum) {
            res = true;
        }
        if (n.left) dfs(n.left, s + n.left.val);
        if (n.right) dfs(n.right, s + n.right.val);
    };
    dfs(root,root.val);
    return res;
};

代码解读：

深度遍历二叉树：

在这里插入图片描述

记录每条路径值的总各和：

在这里插入图片描述

判断路径值是否和目标值相同：

在这里插入图片描述

8.10 前端与树：遍历JSON的所有节点

新建一个JSON

在这里插入图片描述

拿到所有节点的值：

在这里插入图片描述

可以知道值所属的节点：

在这里插入图片描述

8.11 前端与树：渲染Antd中的树组件

利用深度优先算法来渲染，在前端中经常用。

请添加图片描述

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

8.12 树总结

在这里插入图片描述

@ZGLi
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【16】第2版：​大厂面试题.rar
06-10
9. **算法与数据结构**： Java算法50道题目，涉及到排序、查找、图论、动态规划等，是考察编程思维和逻辑能力的重要部分。 通过这些题目，求职者可以全面了解和复习IT领域的核心知识点，为面试做好充分准备。同时...
代码随想录 面试大厂必备八股文
07-03
1. 数据结构：数据结构是编程的基础，包括数组、链表、栈、队列、哈希表、树（二叉树、平衡树如AVL和红黑树）、图等。理解并能灵活运用各种数据结构，能够帮助我们解决复杂问题，优化算法效率。 2. 算法：算法是...
java基础和大厂面试题汇总
08-09
4. **数据结构与算法**：常见数据结构（链表、队列、栈、树、图），排序算法（冒泡、选择、插入、快速、归并等）及复杂度分析。 5. **Spring框架**：IoC容器，AOP，事务管理，Spring Boot，Spring Cloud等。 6. **...
互联网大厂高频重点面试题.txt
03-03
以上仅列举了一部分Java互联网大厂面试中可能涉及的知识点。掌握这些核心概念和技术不仅能帮助求职者在面试中脱颖而出，更重要的是能够提高日常开发工作的效率和质量。希望每位读者都能在学习过程中有所收获，并在...
代码随想录最新第三版-最强八股文
03-24
【代码随想录最新第三版-最强八股文】是一份综合性的IT学习资料，包含了程序员面试必备的知识点，尤其适合准备大厂面试的求职者。这份文档详细涵盖了多个编程语言、算法、计算机基础和软件工程领域的重要概念，旨在...
JavaScript青少年简明教程：函数及其相关知识（下）
cnds123的专栏
07-26 631
JavaScript青少年简明教程：函数及其相关知识（下）
【React 】开发环境搭建详细指南
lph159的博客
07-24 1278
无论你是刚刚开始学习 React，还是希望在现有项目中采用 React 技术，搭建一个高效的开发环境都是至关重要的。本文将详细介绍如何从零开始搭建 React 开发环境，涵盖所需的工具和最佳实践，帮助你快速启动并顺利进行开发。Visual Studio Code（VS Code）是目前最流行的代码编辑器之一，提供了丰富的扩展和强大的功能。如果你希望对项目的配置有更多的控制，可以选择手动配置 React 项目。下载并安装最新版本的 Node.js，安装 Node.js 后，npm 会自动安装。
我们的前端开发逆天了！1 小时搞定了新网站，还跟我说 “不要钱”
努力做最接地气的编程干货分享，感谢关注
07-29 633
本文将带你了解一个新的 Web 框架 **Astro**，并手把手带你使用 Astro 搭建一个属于自己的站点，用过的都说真香！
vue el-select的下拉树形结构 带检索功能
Jokerxiuka的博客
07-26 204
【代码】vue el-select的下拉树形结构。
已解决：vue-office/excel 多个sheet点击切换，滚动条高度不重置，表格视图位置不正确
weixin_42289080的博客
07-26 249
解决 @vue-office/excel 多个sheet切换，内容以及滚动条展示不正确的问题
angular入门基础教程(四）动态属性与事件
最新发布
峰会路转的博客
07-29 60
状态的变化导致属性值的变化，这个时候我们就需要用到动态属性，ng中的动态属性用[]包裹即可。
easyui 点击单元格的时候，获取该行另外一个字段的值
极客栈
07-29 304
通过绑定 DataGrid 的 ​​ 事件，可以轻松地在单击单元格时获取该行的其他字段值。这个方法适用于各种场景，比如在用户点击某个单元格时显示额外的信息、执行特定的操作等。希望这个示例能帮助你更好地理解和应用 EasyUI DataGrid 的事件处理。
新手vue学习问题汇总（自用）（长期更新）
lapiii的博客
07-28 309
是 ES6 模块语法，用于导出模块的默认成员。在 Vue.js 中，通常用来导出一个组件对象，使其可以在其他文件中被导入并使用。
easyadmin layui js监听返回结果，进行token验证防止连点
weixin_43652106的博客
07-29 141
easyadmin layui js监听返回结果，进行token验证防止连点
Vue3可媲美Element Plus Tree组件实战之移除节点
felix_alone2012的博客
07-25 637
《Element Plus Tree - 自定义节点内容》示例中介绍了移除节点的用法，个人觉得作为提供给用户API，应该遵循迪米特法则，把功能实现的细节封装在组件内部，而提供给用户最简单的操作方式，同时在此基础上支持用户的扩展。因此，在API使用的人性化方便，个人觉得element plus做的并不优秀。为此，我们自定义tree组件时对用户API可以设计的更人性化些。
Angular由一个bug说起之八：实践中遇到的一个数据颗粒度的问题
KenkoTech的博客
07-24 810
之所以使用这种比较直接的方式是因为项目中的数据类型已经确定，而且对数字的处理逻辑没有统一在一个文件中。这是大型项目经常遇到的问题，起到相同作用的代码因为一些小的差别而分别写在管理各自功能的文件里。文件存入数据库，这样我们就可以统一维护一个表，不管是前端来处理数据还是后端来处理都能遵守相同的规则。针对这篇文章提到的数字缩写的问题，可以有两种处理方案。来展示数据的功能，这些数据根据不同的类型和单位会为其加上前缀、后缀或者省略小数。
让开发者生活更轻松的 JavaScript 字符串方法
粉丝们务必加入微信粉丝群
07-27 226
前端岗位内推来了JavaScript 最初被引入作为一种简单的客户端脚本语言，但现在，它已经成为一种真正的 WORA（一次编写到处运行）语言，使开发者能够构建桌面、移动、电视、CLI 和嵌入式应用程序。JavaScript 的初学者友好语法、生产性语言特性和良好管理的 ECMAScript 规范，激励了所有人使用 JavaScript 进行通用编程。ECMAScript 标准通过提供许多语言特性来...
爬虫基本原理入门
RHeng的博客
07-25 1128
爬虫（Web Crawler），又称为网络爬虫或网页蜘蛛，是一种按照一定的规则，自动地抓取万维网信息的程序或者脚本。它们可以模拟浏览器行为，遍历网页并抓取网页中的信息，如文本、图片、链接等。接下来，我们会尝试使用Python等编程语言，结合相关库和工具，动手编写自己的爬虫程序，探索更多关于爬虫技术的奥秘。
Vue3学习总结
inside802的博客
07-28 209
9、计算属性：使用computed属性，可以给template传递一个经过计算后的值，当这个值放在缓存中，当这个值不发生改变时，则JS不会再次执行computed，这样就能提高运行速度。4、属性绑定：使用v-bind:命令来实现属性绑定，如果是绑定单个属性，命令为v-bind:attr=“attr”，也可以写为v-bind:attr，也可以简写为：。11、绑定CSS样式，是通过绑定style属性来实现的，语法为v-bind:style=“myStyle”.其中，myStyle是在vue中自定义的样式。
理解红黑树：数据结构与算法面试关键知识点
"这份资料包含了2020年最新整理的一线大厂数据结构与算法面试题，重点探讨了红黑树、AVL树以及二叉搜索树等关键概念及其应用场景。" 在软件开发和算法设计中，数据结构与算法是核心部分，尤其在面试中常常被考察。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

@ZGLi

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

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

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

打赏作者

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

抵扣说明：

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

余额充值