1、第226题：翻转二叉树

递归+迭代两种实现方式：

/** 反转二叉树* Definition for a binary tree node.* function TreeNode(val) {*     this.val = val;*     this.left = this.right = null;* }*/
/*** @param {TreeNode} root* @return {TreeNode}* 第一种方式迭代* 执行用时 :72 ms, 在所有 JavaScript 提交中击败了87.29%的用户* 内存消耗 :33.8 M, 在所有 JavaScript 提交中击败了24.26%的用户*/
var invertTree = function(root) {if (!root) return root;var arr = [root];while(arr.length){var current = arr.shift(); //取出节点，交换左右子节点var temp = current.right;current.right = current.left;current.left = temp;//将左右子节点push到数组中if (current.right) arr.push(current.right);if (current.left) arr.push(current.left);}return root;
};/*** 第二种方式递归* @param root* @returns {*}* 执行用时 :64 ms, 在所有 JavaScript 提交中击败了98.02%的用户* 内存消耗 :33.6 MB, 在所有 JavaScript 提交中击败了53.85%的用户*/
var invertTree2 = function(root) {if (!root) return root;var temp = invertTree(root.left);root.left = invertTree(root.right);root.right = temp;return root;
};

View Code

 2、第144题：二叉树的前序遍历

初看这个题目描述，没怎么看懂，特别是控制台的输入输出

比如输入：[3, 9, 20, 15, 7, 88, 16,  2, 19, 13, 26, 11]

输出是：[3,9,15,2,19,7,13,26,20,88,11,16]

一时没弄明白，后面琢磨了一下，才发现力扣这里的输入是按照输入顺序来组成树的，而不是按输入的大小组成树。

即上面这个输入的数字列表，做成二叉树图为：

如果输入的数字列表中带有null, 则null所在的子树空不占位，

比如输入：[3, 9,  null, 20, 15, 7,  88,  16,  2, 19,  null, 13, 26, 11]

输出为：[3, 9, 20, 7, 19, 88, 13, 26, 15, 16, 11, 2]

输入数字的二叉树图为：

理解了力扣题目的输入输出逻辑，咱们再做题，二叉树的前序遍历递归+迭代方式code (先根节点，再左子节点，再右子节点)：

/**  前序遍历规则：先根节点，再左子节点，再右子节点* Definition for a binary tree node.* function TreeNode(val) {*     this.val = val;*     this.left = this.right = null;* }*/
/** 第一种方式：递归* @param {TreeNode} root* @return {number[]}执行用时 :72 ms, 在所有 JavaScript 提交中击败了86.38%的用户内存消耗 :33.8 MB, 在所有 JavaScript 提交中击败了17.62%的用户*/
var preorderTraversal = function(root) {var arr = [];recusion(root, arr);return arr;function recusion(root){if (!root) return;//前序遍历，先根节点，再左节点，再右节点
        arr.push(root.val);recusion(root.left, arr);recusion(root.right, arr);}
};// function TreeNode(val) {//     this.val = val;
//     this.left = this.right = null;
// }/*** 第二种方式：迭代* 执行用时 :76 ms, 在所有 JavaScript 提交中击败70.96%的用户* 内存消耗 :33.6 MB, 在所有 JavaScript 提交中击败了60.62%的用户*/
var preorderForeach = function(root) {var res = [];if (!root) return res;var arr = [root];while(arr.length){//借助于栈的特性：后进先出var current = arr.pop();res.push(current.val);//先将右节点压入栈底，因为右节点后取值if (current.right){arr.push(current.right);}//左节点先取值，压入栈顶if (current.left){arr.push(current.left);}}return res;
};

View Code

3、第94题：二叉树的中序遍历

二叉树中序遍历，先找到最左边的左子节点，从这里开始，然后左子节点， 再根节点，再右子节点：

/** 中序遍历：从小到大，从做左边的左子节点，最后一个是右边的右子节点* Definition for a binary tree node.* function TreeNode(val) {*     this.val = val;*     this.left = this.right = null;* }*/
/** 中序遍历：按照从小到大排序，先找到最左边的子节点，也就是最小值，再依次往上走父节点，右节点* @param {TreeNode} root* @return {number[]}* 第一种方式：递归* 执行用时 :64 ms, 在所有 JavaScript 提交中击败了97.67%的用户* 内存消耗 :33.8 MB, 在所有 JavaScript 提交中击败20.52%的用户*/
var inorderTraversal = function(root) {const res = [];if (!root) return res;recusion(root);return res;function recusion(root){if (!root) return;recusion(root.left);res.push(root.val);recusion(root.right);}
};/*** 第二种方式：迭代* 执行用时 :68 ms, 在所有 JavaScript 提交中击败了94.67%的用户* 内存消耗 33.7 MB, 在所有 JavaScript 提交中击败了30.60%的用户*/
var inorderTraversal2 = function(root) {const res = [];if (!root) return res;const arr = [];while (root || arr.length){while(root){arr.push(root);root = root.left;}root = arr.pop();  //最后一个左节点
        res.push(root.val);root = root.right;}return res;
};

View Code

4、第145题：二叉树的后序遍历

后序遍历的规则：先叶子节点，再根节点；即先左子节点，再右子节点，再根节点。

/** 后序遍历规则：先叶子节点，叶子节点先左后右，再根节点* Definition for a binary tree node.* function TreeNode(val) {*     this.val = val;*     this.left = this.right = null;* }*/
/** 后序遍历：先叶子节点，再左子树，再右子树* 第一种方式：递归* @param {TreeNode} root* @return {number[]}* 执行用时 :76 ms, 在所有 JavaScript 提交中击败了68.85%的用户* 内存消耗 :33.9 MB, 在所有 JavaScript 提交中击败了9.84%的用户*/
var postorderTraversal = function(root) {var res = [];if (!root) return res;recusion(root);return res;function recusion(root){if (!root) return;recusion(root.left);recusion(root.right);res.push(root.val);}
};/*** 第二种方式：迭代* @param root* @returns {Array}* 执行用时 :80 ms, 在所有 JavaScript 提交中击败了48.15%的用户* 内存消耗 :33.7 MB, 在所有 JavaScript 提交中击败25.41%的用户*/
var postorderTraversal = function(root) {var res = [];if (!root) return res;var arr = [root];while (arr.length){var current = arr.pop();res.unshift(current.val);if (current.left){arr.push(current.left);}if (current.right){arr.push(current.right);}}return res;
};

View Code

5、第102题：二叉树的层级遍历

递归层级遍历和前序遍历差不多，迭代方式层级遍历有点绕

/** 层次遍历* Definition for a binary tree node.* function TreeNode(val) {*     this.val = val;*     this.left = this.right = null;* }* 给定二叉树: [3,9,20,null,null,15,7],3/ \9  20/  \15   7返回其层次遍历结果：[[3],[9,20],[15,7]]*/
/** 层次遍历，第一种方式：递归， 和前序遍历差不多* @param {TreeNode} root* @return {number[][]}* 执行用时 :84 ms, 在所有 JavaScript 提交中击败了55.19%的用户* 内存消耗 :34.6 M, 在所有 JavaScript 提交中击败了53.23%的用户*/
var levelOrder = function(root) {var res = [];if (!root) return res;recusion(root, 0);return res;function recusion(root, level){if (!root) return;if (res[level]){res[level].push(root.val);}else{res[level] = [root.val];}if (root.left){recusion(root.left, level+1);}if (root.right){recusion(root.right, level+1);}}
};/*** 第二种层序遍历：迭代* @param root* @returns {Array}* 执行用时 :80 ms, 在所有 JavaScript 提交中击败了73.64%的用户* 内存消耗 :34.8 MB, 在所有 JavaScript 提交中击败了28.36%的用户*/
var levelOrder2 = function(root) {var res = [];if (!root) return res;var queue = [root];while(queue.length){//内循环把这一层级的所有节点都放入tempQueue队列中，每一个外循环则是每一层级重新开始var arr = [], tempQueue = [];while(queue.length){var current = queue.shift();arr.push(current.val);if (current.left){tempQueue.push(current.left);}if (current.right){tempQueue.push(current.right);}console.log("tempQueue.length: ", tempQueue.length, ", queue.length: ", queue.length);console.log("-----------")}res.push(arr);queue = tempQueue;console.log(JSON.stringify(res))console.log("***************************")}return res;
};// function TreeNode(val){//     this.val = val;
//     this.left = this.right = null;
// }
//
// var node = new TreeNode(23);
// node.left = new TreeNode(16);
// node.right = new TreeNode(45);
// node.left.left = new TreeNode(3);
// node.left.right = new TreeNode(22);
// node.right = new TreeNode(45);
// node.right.left = new TreeNode(37);
// node.right.right = new TreeNode(99);
// console.log(levelOrder2(node));

View Code

6、第104题：二叉树的最大深度

二叉树的最大深度和求二叉树的层级遍历差不多

/**  二叉树的最大深度* 给定一个二叉树，找出其最大深度。二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。说明: 叶子节点是指没有子节点的节点。* Definition for a binary tree node.* function TreeNode(val) {*     this.val = val;*     this.left = this.right = null;* }*/
/*** @param {TreeNode} root* @return {number}* 第一种方式：递归* 执行用时 :96 ms, 在所有 JavaScript 提交中击败了51.18%的用户* 内存消耗 :37.1 MB, 在所有 JavaScript 提交中击败了40.00%的用户*/
var maxDepth = function(root) {if (!root) return 0;var maxLevel = 1;recusion(root, 1);return maxLevel;function recusion(root, level){if (level > maxLevel) {maxLevel = level;}if (root.left){recusion(root.left, level+1);}if (root.right){recusion(root.right, level+1);}}
};/*** 第二种：迭代* @param root* @returns {number}执行用时 :88 ms, 在所有 JavaScript 提交中击败了81.91%的用户内存消耗 :36.8 MB, 在所有 JavaScript 提交中击败了93.61%的用户*/
var maxDepth2 = function(root) {if (!root) return 0;var level = 0, queue = [root];while(queue.length){var tempQueue = [];//内循环，每次把整个层级节点遍历完， tempQueue存储每个层级的所有节点while(queue.length){var current = queue.shift();if (current.left){tempQueue.push(current.left);}if (current.right){tempQueue.push(current.right)}}level++;queue = tempQueue;}return level;
};// function TreeNode(val){//     this.val = val;
//     this.left = this.right = null;
// }
//
// var node = new TreeNode(3);
// node.left = new TreeNode(9);
// node.right = new TreeNode(20);
// node.right.left = new TreeNode(15);
// node.right.right = new TreeNode(7);
// console.log(maxDepth(node))

View Code

7、第662题：二叉树最大宽度

这个题和二叉树层级遍历/求最大深度类似，但比层级遍历要绕要麻烦点。

迭代方式：迭代遍历，用2个栈，一个用来存储每一层级的节点，另一个栈用来存储每个节点的编号。

对节点进行编号，规则：根节点编号从0开始，左子节点编号 = 父节点编号 * 2 + 1， 右子节点编号 = 父节点编号 * 2 + 2；

递归方式：规则同迭代方式，也是对节点进行编号

如图：

/*** 给定一个二叉树，编写一个函数来获取这个树的最大宽度。树的宽度是所有层中的最大宽度。这个二叉树与满二叉树（full binary tree）结构相同，但一些节点为空。每一层的宽度被定义为两个端点（该层最左和最右的非空节点，两端点间的null节点也计入长度）之间的长度。示例 1:输入:1/   \3     2/ \     \5   3     9输出: 4解释: 最大值出现在树的第 3 层，宽度为 4 (5,3,null,9)。示例 2:输入:1/3/ \5   3输出: 2解释: 最大值出现在树的第 3 层，宽度为 2 (5,3)。示例 3:输入:1/ \3   2/5输出: 2解释: 最大值出现在树的第 2 层，宽度为 2 (3,2)。示例 4:输入:1/ \3   2/     \5       9/         \6           7输出: 8解释: 最大值出现在树的第 4 层，宽度为 8 (6,null,null,null,null,null,null,7)。* Definition for a binary tree node.* function TreeNode(val) {*     this.val = val;*     this.left = this.right = null;* }*/
/*** @param {TreeNode} root* @return {number}* 第一种方式：递归* 执行用时 :84 ms, 在所有 JavaScript 提交中击败了100.00%的用户* 内存消耗 :36.7 MB, 在所有 JavaScript 提交中击败了37.50%的用户*/
var widthOfBinaryTree = function(root) {if (!root) return 0;//queue存储节点，numArr存储节点对应的节点编号位置var queue = [root], numArr = [0], maxWidth = 1;while (queue.length) {//tempQueue存储每一层级所有的节点，tempNumArr存储对应节点的编号位置var tempQueue = [], tempNumArr = [];while (queue.length) {var node = queue.shift(), num = numArr.shift(); //取出栈底节点和编号if (node.left) {tempQueue.push(node.left);tempNumArr.push(num * 2 + 1);}if (node.right) {tempQueue.push(node.right);tempNumArr.push(num * 2 + 2);}}var tempWidth = 0;//计算tempNumArr中存储的这一层的宽度, 最后一位元素存储这一层级最大宽度的编号if (tempNumArr.length) {tempWidth = tempNumArr[tempNumArr.length - 1] - tempNumArr[0] + 1;}if (tempWidth > maxWidth) {maxWidth = tempWidth;  //更新最大宽度
        }//开始下一个层级的宽度计算queue = tempQueue;numArr = tempNumArr;}return maxWidth;
};/*** 第二种递归方式：* @param root* @returns {number}* 执行用时 :84 ms, 在所有 JavaScript 提交中击败了100.00%的用户* 内存消耗 :36 MB, 在所有 JavaScript 提交中击败了75.00%的用户*/
var widthOfBinaryTree2 = function(root) {if (!root) return 0;var res = [], maxWidth = 1;recusion(root, 0, 0);return maxWidth;function recusion(root, level, num){if (res[level]){res[level].push(num);}else{res[level] = [num];}//计算最大宽度var tempArr = res[level];var tempWidth = tempArr[tempArr.length - 1] - tempArr[0] + 1;if (tempWidth > maxWidth) {maxWidth = tempWidth;}if (root.left){recusion(root.left, level + 1, num * 2 + 1);}if (root.right){recusion(root.right, level + 1, num * 2 + 2);}}
};// function TreeNode(val){//     this.val = val;
//     this.left = this.right = null;
// }
//
// //[1,1,1,1,null,null,1,1,null,null,1]
// var root = new TreeNode(1);
// root.left = new TreeNode(1);
// root.right = new TreeNode(1);
// root.left.left = new TreeNode(1);
// root.left.right = new TreeNode(3);
// root.right.right = new TreeNode(9);
// console.log(widthOfBinaryTree(root));

View Code

8、第589题：N叉树的前序遍历

N叉树和二叉树差不多，因此它的前序遍历也是在二叉树的前序遍历的基础上进行修改，递归+迭代：

/** N叉树的前序遍历* // Definition for a Node.* function Node(val,children) {*    this.val = val;*    this.children = children;* };*/
/*** @param {Node} root* @return {number[]}* 第一种方式：递归* 执行用时 :968 ms, 在所有 JavaScript 提交中击败了62.09%的用户* 内存消耗 :81.5 MB, 在所有 JavaScript 提交中击败了29.48%的用户*/
var preorder = function(root) {if (!root) return [];var res = [];recusion(root);return res;function recusion(root){if (!root) return;res.push(root.val);for (var i = 0; i < root.children.length; i++){recusion(root.children[i]);}}
};/*** 第二种方式：迭代* @param root* @returns {Array}* 执行用时 :948 ms, 在所有 JavaScript 提交中击败了73.46%的用户* 内存消耗 :87.4 MB, 在所有 JavaScript 提交中击败了6.32%的用户*/
var preorder2 = function(root) {if (!root) return [];var res = [], arr = [root];while(arr.length){var current = arr.pop();res.push(current.val);for(var i = current.children.length - 1; i >= 0; i--){arr.push(current.children[i]);}}return res;
};

View Code

9、第590题：N叉树的后序遍历

/*** // Definition for a Node.* function Node(val,children) {*    this.val = val;*    this.children = children;* };*/
/*** @param {Node} root* @return {number[]}* 第一种方式：递归* 执行用时 :964 ms, 在所有 JavaScript 提交中击败了54.40%的用户* 内存消耗 :87.6 MB, 在所有 JavaScript 提交中击败了6.10%的用户*/
var postorder = function(root) {if (!root) return [];var res = [];recusion(root);return res;function recusion(root){if (!root) return;for (var i = 0; i < root.children.length; i++){recusion(root.children[i]);}res.push(root.val)}
};/*** 第二种方式：迭代* @param root* @returns {Array}* 执行用时 :904 ms, 在所有 JavaScript 提交中击败了93.41%的用户* 内存消耗 :87.4 MB, 在所有 JavaScript 提交中击败了6.10%的用户*/
var postorder2 = function(root) {if (!root) return [];var res = [], arr = [root];while(arr.length){var current = arr.pop();for(var i = 0; i < current.children.length; i++){arr.push(current.children[i]);}res.unshift(current.val);}return res;
};

View Code

10、第559题：N叉树的最大深度

/*** // Definition for a Node.* function Node(val,children) {*    this.val = val;*    this.children = children;* };*/
/*** @param {Node} root* @return {number}* 第一种方式：递归* 执行用时 :1064 ms, 在所有 JavaScript 提交中击败了22.35%的用户* 内存消耗 :83 MB, 在所有 JavaScript 提交中击败了50.68%的用户*/
var maxDepth = function(root) {if (!root) return 0;var maxLevel = 1;recusion(root, 1);return maxLevel;function recusion(root, level){if (!root) return;if (level > maxLevel) {maxLevel = level;}for (var i = 0; i < root.children.length; i++){recusion(root.children[i], level + 1);}}
};/*** 第二种方式：迭代* @param root* @returns {number}执行用时 :908 ms, 在所有 JavaScript 提交中击败了81.01%的用户内存消耗 :81.1 MB, 在所有 JavaScript 提交中击败了54.79%的用户*/
var maxDepth2 = function(root) {if (!root) return 0;var level = 0, queue = [root];while(queue.length){var tempQueue = [];//内循环，每次把整个层级节点遍历完， tempQueue存储每个层级的所有节点while(queue.length){var current = queue.pop();for (var i = 0; i < current.children.length; i++){var node = current.children[i];if (node){tempQueue.push(node);}}}level++;queue = tempQueue;}return level;
};

View Code

11、第114题：二叉树展开为链表

根据题意和示例，相当于是进行一次前序遍历，然后不保留左子树，全部移到右子树来。

/*** 给定一个二叉树，原地将它展开为链表。例如，给定二叉树1/ \2   5/ \   \3   4   6将其展开为：1\2\3\4\5\6根据提意，在原地展开为链表，相当于把左子树设为nul, 通过前序遍历全部转成右子树* Definition for a binary tree node.* function TreeNode(val) {*     this.val = val;*     this.left = this.right = null;* }*/
/*** @param {TreeNode} root* @return {void} Do not return anything, modify root in-place instead.* 第一种方式：递归* 执行用时 :92 ms, 在所有 JavaScript 提交中击败了55.97%的用户* 内存消耗 :35.5 MB, 在所有 JavaScript 提交中击败了10.53%的用户*/
var flatten = function(root) {if (!root) return root;var preNode = root;recusion(root);return root;function recusion(node){var leftNode = node.left, rightNode = node.right;node.left = null;if (node != root){preNode.right = node;}preNode = node;if (leftNode){recusion(leftNode);}if (rightNode){recusion(rightNode);}}
};/*** 第二种方式：迭代* @param root* @returns {*}* 执行用时 :88 ms, 在所有 JavaScript 提交中击败了69.40%的用户* 内存消耗 :34.7 MB, 在所有 JavaScript 提交中击败了52.63%的用户*/
var flatten2 = function(root) {if (!root) return root;var arr = [root], preNode = root;while(arr.length){var node = arr.pop();if (node.right){arr.push(node.right);}if (node.left){arr.push(node.left);}if (node != root){preNode.right = node;}node.left = null;preNode = node;}return root;
};

View Code

12、第105题：从前序与中序遍历序列构造二叉树

/*** Definition for a binary tree node.* function TreeNode(val) {*     this.val = val;*     this.left = this.right = null;* }*/
/*** @param {number[]} preorder* @param {number[]} inorder* @return {TreeNode}* 第一种方式：递归* 执行用时 :104 ms, 在所有 JavaScript 提交中击败了91.63%的用户* 内存消耗 :36.2 MB, 在所有 JavaScript 提交中击败了83.05%的用户*/
var buildTree = function(preorder, inorder) {return recusion(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);function recusion(preorder, preL, preR, inorder, inL, inR){if (preL > preR || inL > inR){return null;}var rootVal = preorder[preL];var temp = inL;while (temp <= inR && inorder[temp] != rootVal){temp++;}var root = new TreeNode(rootVal);root.left = recusion(preorder, preL + 1, preL + temp - inL, inorder, inL, temp - 1);root.right = recusion(preorder, preL + 1 - inL + temp, preR, inorder, temp + 1, inR);return root;}
};function TreeNode(val){this.val = val;this.left = this.right = null;
}

View Code

转载于:https://www.cnblogs.com/tandaxia/p/11481462.html

JS数据结构第六篇 --- 二叉树力扣练习题相关推荐

  1. 数据结构（六）二叉树的遍历（递归非递归方法）

    数据结构(六)二叉树的遍历(递归非递归方法) 一.递归方法 1.先序遍历 void PreOrder(BiTree T) {visit(T);PreOrder(T->LChild)PreOrde ...

  2. 20210330:二叉树力扣相关习题复习（上）

    20210330:二叉树力扣相关习题复习(上) 题目 思路与算法 代码实现 写在最后 题目 路径总和 II 二叉树的最近公共祖先 二叉树展开为链表 思路与算法 路径总和 II:经典三序遍历二叉树题目, ...

  3. 力扣练习题（数组中数据反转）

    力扣练习题(数组中数据反转) 要求:int[] arr = {12,23,34,45,56,67,78,89,90}; 变为:int[] arr = {90,89,78,67,56,45,34,23, ...

  4. 【字符串篇】力扣刷题2

    文章目录 test3. 无重复字符的最长子串 test5. 最长回文子串 test13. 罗马数字转整数 test14. 最长公共前缀 test20. 有效的括号 test67. 二进制求和 test ...

  5. 数据结构（六）二叉树

    一.树形结构 概念 树是一种非线性的数据结构,它是由n(n>=0)个有限结点组成一个具有层次关系的集合.把它叫做树是因为它看起来像一棵倒挂的树,也就是说它是根朝上,而叶朝下的.它具有以下的特点: ...

  6. JAVA数据结构知识点,数据结构 树Tree 知识点总结 附Leetcode力扣练习题答案

    先来明确下树的概念:明确的父子关系 正确的示例: 错误的示例: 几个名词: 节点:线两端的点即节点 根节点:无父节点的节点 叶子节点:无子节点的节点 几个概念: 高度:从下到上,从0计数,根节点最高 ...

  7. 数据结构第六篇——顺序存储结构与链式存储结构的特点

    ♥注:未经博主同意,不得转载. 两者特点: 顺序表的特点是逻辑上相邻的数据元素,物理存储位置也相邻,并且,顺序表的存储空间需要预先分配. 它的优点: (1)方法简单,各种高级语言中都有数组,容易实现. ...

  8. js 数组按奇偶拆分_力扣：按奇偶排序数组js

    给定一个非负整数数组 A,返回一个数组,在该数组中, A 的所有偶数元素之后跟着所有奇数元素. 你可以返回满足此条件的任何数组作为答案. 示例: 输入:[3,1,2,4] 输出:[2,4,3,1] 输 ...

  9. 力扣刷题day32|738单调递增的数字、714买卖股票的最佳时机含手续费、968监控二叉树

    文章目录 738. 单调递增的数字 思路 难点:遍历顺序 难点:设置flag 714. 买卖股票的最佳时机含手续费 贪心思路 难点 968. 监控二叉树 思路 难点:如何隔两个节点放一个摄像头 738 ...

  10. 一年半´力扣´练习生超详细总结（附数据结构+算法）

    一年半´力扣´练习生超详细总结(附数据结构+算法) 文章目录 一年半´力扣´练习生超详细总结(附数据结构+算法) 我与力扣 数据结构 算法 未来计划 其他专栏推荐 我与力扣 专栏导航:LeetCode ...

最新文章

  1. C# 操作redis
  2. 客户端稳定性优化实战，Crash率最高下降40%
  3. php可以支持代码重用技术的命令,Linux下的编程 PHP高级技巧全放送(一)
  4. qt android webview,qt browser 加载一个webview过程
  5. python mysql numpy_Python 之Numpy应用
  6. HTML特殊字符转义
  7. 集丰照明｜LED 的产业链由哪些部分构成？
  8. 欧冠抽签程序c语言,欧冠抽签
  9. 蓝桥杯省赛C++A组B组题解整理（第十、九、八、七、六、五、四、三届）
  10. Visio自定义连接线，连接点位置
  11. vue项目中引用阿里云图标库
  12. 谷歌语法和FOFA常用语法总结
  13. 使用CSS3设置条纹背景
  14. 2018达内Web前端开发视频教程
  15. 图：美国首颗“嗅碳”卫星发射失败坠海
  16. Docker-Compose 容器编排技术
  17. Oracle主机变量锚定、游标变量
  18. R语言和医学统计学：非参数检验的补充
  19. 【GPT4】微软 GPT-4 测试报告（6）与人类的交互能力
  20. Java, C, 还是C++？

热门文章

  1. Linux快速查找库文件位置
  2. 软件需求工程与UML建模第十二周作业
  3. 无所不在的性能测试——《LoadRunner 没有告诉你的》之五
  4. 巴基斯坦削减光伏发电上网电价或影响清洁能源发展前景
  5. Sublime Text 3运行JavaScript控制台
  6. 44.用Tornado实现web界面爬虫
  7. 无需无线路由，将系统为win7的笔记本变成wifi的方法
  8. DNS服务器构建（一）-—构建域名缓存服务器
  9. VM6.5 beta2虚拟机新加网卡不能使用问题的解决方法
  10. Silverlight 2.0的了解