feat: 新增无向连通图数据结构 parse toArray实现，补充测试用例等 fix: 优化了转换逻辑

Author: Hedwig-Fang

.vscode/launch.json

@@ -0,0 +1,18 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Launch Program",
+      "runtimeVersion": "20.10.0",
+      "skipFiles": [
+        "<node_internals>/**"
+      ],
+      "program": "${workspaceFolder}/src/133.clone-graph/index.js"
+    }
+  ]
+}

Readme.md

@@ -10,7 +10,7 @@
 - [x] 3.模板:获取跳转每日一题的链接替换@url
 - [x] 4.函数:优化时间和资源统计函数
 - [x] 5.优化创建时的体验，添加重复时候的确认覆盖或者添加额外符号
-- [ ] 6.特殊数据结构的处理(ListNode,Stack等)的处理
+- [x] 6.特殊数据结构的处理(链表ListNode,树TreeNode,无向连通图Node)的处理
 - [x] 7.创建某一特定编号的题目脚本,以及实现随机题目【随机题目汇集本地题目，然后排除自己本地存在的题目进行随机】
 - [ ] 8.实现在编辑器中预览图片(感觉可以不做)
 - [ ] 9.优化随机题目的随机方式，减少请求
@@ -202,3 +202,4 @@ Done in 0.19s.
 
 [EternalHeart](https://github.com/wh131462)
 [SmallTeddy](https://github.com/SmallTeddy)
+

common/resources/store.json

@@ -1 +1 @@
-{"today":"2182","today-question-info":{"enName":"stone-game-vii","title":"石子游戏 VII","detail":"<p>石子游戏中，爱丽丝和鲍勃轮流进行自己的回合，<strong>爱丽丝先开始</strong> 。</p>\n\n<p>有 <code>n</code> 块石子排成一排。每个玩家的回合中，可以从行中 <strong>移除</strong> 最左边的石头或最右边的石头，并获得与该行中剩余石头值之 <strong>和</strong> 相等的得分。当没有石头可移除时，得分较高者获胜。</p>\n\n<p>鲍勃发现他总是输掉游戏（可怜的鲍勃，他总是输），所以他决定尽力 <strong>减小得分的差值</strong> 。爱丽丝的目标是最大限度地 <strong>扩大得分的差值</strong> 。</p>\n\n<p>给你一个整数数组 <code>stones</code> ，其中 <code>stones[i]</code> 表示 <strong>从左边开始</strong> 的第 <code>i</code> 个石头的值，如果爱丽丝和鲍勃都 <strong>发挥出最佳水平</strong> ，请返回他们 <strong>得分的差值</strong> 。</p>\n\n<p> </p>\n\n<p><strong>示例 1：</strong></p>\n\n<pre>\n<strong>输入：</strong>stones = [5,3,1,4,2]\n<strong>输出：</strong>6\n<strong>解释：</strong>\n- 爱丽丝移除 2 ，得分 5 + 3 + 1 + 4 = 13 。游戏情况：爱丽丝 = 13 ，鲍勃 = 0 ，石子 = [5,3,1,4] 。\n- 鲍勃移除 5 ，得分 3 + 1 + 4 = 8 。游戏情况：爱丽丝 = 13 ，鲍勃 = 8 ，石子 = [3,1,4] 。\n- 爱丽丝移除 3 ，得分 1 + 4 = 5 。游戏情况：爱丽丝 = 18 ，鲍勃 = 8 ，石子 = [1,4] 。\n- 鲍勃移除 1 ，得分 4 。游戏情况：爱丽丝 = 18 ，鲍勃 = 12 ，石子 = [4] 。\n- 爱丽丝移除 4 ，得分 0 。游戏情况：爱丽丝 = 18 ，鲍勃 = 12 ，石子 = [] 。\n得分的差值 18 - 12 = 6 。\n</pre>\n\n<p><strong>示例 2：</strong></p>\n\n<pre>\n<strong>输入：</strong>stones = [7,90,5,1,100,10,10,2]\n<strong>输出：</strong>122</pre>\n\n<p> </p>\n\n<p><strong>提示：</strong></p>\n\n<ul>\n\t<li><code>n == stones.length</code></li>\n\t<li><code>2 <= n <= 1000</code></li>\n\t<li><code>1 <= stones[i] <= 1000</code></li>\n</ul>\n","id":"1690","jsCode":"/**\n * @param {number[]} stones\n * @return {number}\n */\nvar stoneGameVII = function(stones) {\n\n};","date":"2024-02-03"},"today-tag":"82","random-id":1314,"random-question-info":{"enName":"multiply-strings","title":"字符串相乘","detail":"<p>给定两个以字符串形式表示的非负整数&nbsp;<code>num1</code>&nbsp;和&nbsp;<code>num2</code>，返回&nbsp;<code>num1</code>&nbsp;和&nbsp;<code>num2</code>&nbsp;的乘积，它们的乘积也表示为字符串形式。</p>\n\n<p><strong>注意：</strong>不能使用任何内置的 BigInteger 库或直接将输入转换为整数。</p>\n\n<p>&nbsp;</p>\n\n<p><strong>示例 1:</strong></p>\n\n<pre>\n<strong>输入:</strong> num1 = \"2\", num2 = \"3\"\n<strong>输出:</strong> \"6\"</pre>\n\n<p><strong>示例&nbsp;2:</strong></p>\n\n<pre>\n<strong>输入:</strong> num1 = \"123\", num2 = \"456\"\n<strong>输出:</strong> \"56088\"</pre>\n\n<p>&nbsp;</p>\n\n<p><strong>提示：</strong></p>\n\n<ul>\n\t<li><code>1 &lt;= num1.length, num2.length &lt;= 200</code></li>\n\t<li><code>num1</code>&nbsp;和 <code>num2</code>&nbsp;只能由数字组成。</li>\n\t<li><code>num1</code>&nbsp;和 <code>num2</code>&nbsp;都不包含任何前导零，除了数字0本身。</li>\n</ul>\n","id":"43","jsCode":"/**\n * @param {string} num1\n * @param {string} num2\n * @return {string}\n */\nvar multiply = function(num1, num2) {\n\n};"},"specified-question-info":{"enName":"symmetric-tree","title":"对称二叉树","detail":"<p>给你一个二叉树的根节点 <code>root</code> ， 检查它是否轴对称。</p>\n\n<p>&nbsp;</p>\n\n<p><strong>示例 1：</strong></p>\n<img alt=\"\" src=\"https://pic.leetcode.cn/1698026966-JDYPDU-image.png\" style=\"width: 354px; height: 291px;\" />\n<pre>\n<strong>输入：</strong>root = [1,2,2,3,4,4,3]\n<strong>输出：</strong>true\n</pre>\n\n<p><strong>示例 2：</strong></p>\n<img alt=\"\" src=\"https://pic.leetcode.cn/1698027008-nPFLbM-image.png\" style=\"width: 308px; height: 258px;\" />\n<pre>\n<strong>输入：</strong>root = [1,2,2,null,3,null,3]\n<strong>输出：</strong>false\n</pre>\n\n<p>&nbsp;</p>\n\n<p><strong>提示：</strong></p>\n\n<ul>\n\t<li>树中节点数目在范围 <code>[1, 1000]</code> 内</li>\n\t<li><code>-100 &lt;= Node.val &lt;= 100</code></li>\n</ul>\n\n<p>&nbsp;</p>\n\n<p><strong>进阶：</strong>你可以运用递归和迭代两种方法解决这个问题吗？</p>\n","id":"101","jsCode":"/**\n * Definition for a binary tree node.\n * function TreeNode(val, left, right) {\n *     this.val = (val===undefined ? 0 : val)\n *     this.left = (left===undefined ? null : left)\n *     this.right = (right===undefined ? null : right)\n * }\n */\n/**\n * @param {TreeNode} root\n * @return {boolean}\n */\nvar isSymmetric = function(root) {\n\n};"}}
+{"today":"2182","today-question-info":{"enName":"stone-game-vii","title":"石子游戏 VII","detail":"<p>石子游戏中，爱丽丝和鲍勃轮流进行自己的回合，<strong>爱丽丝先开始</strong> 。</p>\n\n<p>有 <code>n</code> 块石子排成一排。每个玩家的回合中，可以从行中 <strong>移除</strong> 最左边的石头或最右边的石头，并获得与该行中剩余石头值之 <strong>和</strong> 相等的得分。当没有石头可移除时，得分较高者获胜。</p>\n\n<p>鲍勃发现他总是输掉游戏（可怜的鲍勃，他总是输），所以他决定尽力 <strong>减小得分的差值</strong> 。爱丽丝的目标是最大限度地 <strong>扩大得分的差值</strong> 。</p>\n\n<p>给你一个整数数组 <code>stones</code> ，其中 <code>stones[i]</code> 表示 <strong>从左边开始</strong> 的第 <code>i</code> 个石头的值，如果爱丽丝和鲍勃都 <strong>发挥出最佳水平</strong> ，请返回他们 <strong>得分的差值</strong> 。</p>\n\n<p> </p>\n\n<p><strong>示例 1：</strong></p>\n\n<pre>\n<strong>输入：</strong>stones = [5,3,1,4,2]\n<strong>输出：</strong>6\n<strong>解释：</strong>\n- 爱丽丝移除 2 ，得分 5 + 3 + 1 + 4 = 13 。游戏情况：爱丽丝 = 13 ，鲍勃 = 0 ，石子 = [5,3,1,4] 。\n- 鲍勃移除 5 ，得分 3 + 1 + 4 = 8 。游戏情况：爱丽丝 = 13 ，鲍勃 = 8 ，石子 = [3,1,4] 。\n- 爱丽丝移除 3 ，得分 1 + 4 = 5 。游戏情况：爱丽丝 = 18 ，鲍勃 = 8 ，石子 = [1,4] 。\n- 鲍勃移除 1 ，得分 4 。游戏情况：爱丽丝 = 18 ，鲍勃 = 12 ，石子 = [4] 。\n- 爱丽丝移除 4 ，得分 0 。游戏情况：爱丽丝 = 18 ，鲍勃 = 12 ，石子 = [] 。\n得分的差值 18 - 12 = 6 。\n</pre>\n\n<p><strong>示例 2：</strong></p>\n\n<pre>\n<strong>输入：</strong>stones = [7,90,5,1,100,10,10,2]\n<strong>输出：</strong>122</pre>\n\n<p> </p>\n\n<p><strong>提示：</strong></p>\n\n<ul>\n\t<li><code>n == stones.length</code></li>\n\t<li><code>2 <= n <= 1000</code></li>\n\t<li><code>1 <= stones[i] <= 1000</code></li>\n</ul>\n","id":"1690","jsCode":"/**\n * @param {number[]} stones\n * @return {number}\n */\nvar stoneGameVII = function(stones) {\n\n};","date":"2024-02-03"},"today-tag":"82","random-id":1314,"random-question-info":{"enName":"multiply-strings","title":"字符串相乘","detail":"<p>给定两个以字符串形式表示的非负整数&nbsp;<code>num1</code>&nbsp;和&nbsp;<code>num2</code>，返回&nbsp;<code>num1</code>&nbsp;和&nbsp;<code>num2</code>&nbsp;的乘积，它们的乘积也表示为字符串形式。</p>\n\n<p><strong>注意：</strong>不能使用任何内置的 BigInteger 库或直接将输入转换为整数。</p>\n\n<p>&nbsp;</p>\n\n<p><strong>示例 1:</strong></p>\n\n<pre>\n<strong>输入:</strong> num1 = \"2\", num2 = \"3\"\n<strong>输出:</strong> \"6\"</pre>\n\n<p><strong>示例&nbsp;2:</strong></p>\n\n<pre>\n<strong>输入:</strong> num1 = \"123\", num2 = \"456\"\n<strong>输出:</strong> \"56088\"</pre>\n\n<p>&nbsp;</p>\n\n<p><strong>提示：</strong></p>\n\n<ul>\n\t<li><code>1 &lt;= num1.length, num2.length &lt;= 200</code></li>\n\t<li><code>num1</code>&nbsp;和 <code>num2</code>&nbsp;只能由数字组成。</li>\n\t<li><code>num1</code>&nbsp;和 <code>num2</code>&nbsp;都不包含任何前导零，除了数字0本身。</li>\n</ul>\n","id":"43","jsCode":"/**\n * @param {string} num1\n * @param {string} num2\n * @return {string}\n */\nvar multiply = function(num1, num2) {\n\n};"},"specified-question-info":{"enName":"clone-graph","title":"克隆图","detail":"<p>给你无向&nbsp;<strong><a href=\"https://baike.baidu.com/item/连通图/6460995?fr=aladdin\" target=\"_blank\">连通</a>&nbsp;</strong>图中一个节点的引用，请你返回该图的&nbsp;<a href=\"https://baike.baidu.com/item/深拷贝/22785317?fr=aladdin\" target=\"_blank\"><strong>深拷贝</strong></a>（克隆）。</p>\n\n<p>图中的每个节点都包含它的值 <code>val</code>（<code>int</code>） 和其邻居的列表（<code>list[Node]</code>）。</p>\n\n<pre>class Node {\n    public int val;\n    public List&lt;Node&gt; neighbors;\n}</pre>\n\n<p>&nbsp;</p>\n\n<p><strong>测试用例格式：</strong></p>\n\n<p>简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（<code>val = 1</code>），第二个节点值为 2（<code>val = 2</code>），以此类推。该图在测试用例中使用邻接列表表示。</p>\n\n<p><strong>邻接列表</strong> 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。</p>\n\n<p>给定节点将始终是图中的第一个节点（值为 1）。你必须将&nbsp;<strong>给定节点的拷贝&nbsp;</strong>作为对克隆图的引用返回。</p>\n\n<p>&nbsp;</p>\n\n<p><strong>示例 1：</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/133_clone_graph_question.png\" style=\"height: 500px; width: 500px;\"></p>\n\n<pre><strong>输入：</strong>adjList = [[2,4],[1,3],[2,4],[1,3]]\n<strong>输出：</strong>[[2,4],[1,3],[2,4],[1,3]]\n<strong>解释：\n</strong>图中有 4 个节点。\n节点 1 的值是 1，它有两个邻居：节点 2 和 4 。\n节点 2 的值是 2，它有两个邻居：节点 1 和 3 。\n节点 3 的值是 3，它有两个邻居：节点 2 和 4 。\n节点 4 的值是 4，它有两个邻居：节点 1 和 3 。\n</pre>\n\n<p><strong>示例 2：</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/graph.png\" style=\"height: 148px; width: 163px;\"></p>\n\n<pre><strong>输入：</strong>adjList = [[]]\n<strong>输出：</strong>[[]]\n<strong>解释：</strong>输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。\n</pre>\n\n<p><strong>示例 3：</strong></p>\n\n<pre><strong>输入：</strong>adjList = []\n<strong>输出：</strong>[]\n<strong>解释：</strong>这个图是空的，它不含任何节点。\n</pre>\n\n<p><strong>示例 4：</strong></p>\n\n<p><img alt=\"\" src=\"https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2020/02/01/graph-1.png\" style=\"height: 133px; width: 272px;\"></p>\n\n<pre><strong>输入：</strong>adjList = [[2],[1]]\n<strong>输出：</strong>[[2],[1]]</pre>\n\n<p>&nbsp;</p>\n\n<p><strong>提示：</strong></p>\n\n<ol>\n\t<li>节点数不超过 100 。</li>\n\t<li>每个节点值&nbsp;<code>Node.val</code> 都是唯一的，<code>1 &lt;= Node.val &lt;= 100</code>。</li>\n\t<li>无向图是一个<a href=\"https://baike.baidu.com/item/简单图/1680528?fr=aladdin\" target=\"_blank\">简单图</a>，这意味着图中没有重复的边，也没有自环。</li>\n\t<li>由于图是无向的，如果节点 <em>p</em> 是节点 <em>q</em> 的邻居，那么节点 <em>q</em> 也必须是节点 <em>p</em>&nbsp;的邻居。</li>\n\t<li>图是连通图，你可以从给定节点访问到所有节点。</li>\n</ol>\n","id":"133","jsCode":"/**\n * // Definition for a Node.\n * function Node(val, neighbors) {\n *    this.val = val === undefined ? 0 : val;\n *    this.neighbors = neighbors === undefined ? [] : neighbors;\n * };\n */\n\n/**\n * @param {Node} node\n * @return {Node}\n */\nvar cloneGraph = function(node) {\n    \n};"}}

common/structures/Node.js

@@ -0,0 +1,58 @@
+class Node {
+  constructor(val, neighbors) {
+    this.val = val === undefined ? 0 : val;
+    this.neighbors = neighbors === undefined ? [] : neighbors;
+  }
+  parse(edges) {
+    const nodeMap = new Map();
+  
+    // 创建节点
+    const getNode = (val) => {
+      if (!nodeMap.has(val)) {
+        const newNode = new Node(val);
+        nodeMap.set(val, newNode);
+      }
+      return nodeMap.get(val);
+    };
+  
+    // 连接节点
+    edges.forEach((neighbors,index) => {
+      let val = index + 1;
+      const currentNode = getNode(val);
+      neighbors.forEach(neighborVal => {
+        const neighborNode = getNode(neighborVal);
+        currentNode.neighbors.push(neighborNode);
+      });
+    });
+  
+    return nodeMap.size > 0 ? nodeMap.values().next().value : null;
+  }
+  toArray(node) {
+    if (!node) {
+      return [];
+    }
+  
+    const visited = new Set();
+    const result = [];
+  
+    const dfs = (currentNode) => {
+      if (visited.has(currentNode.val)) {
+        return;
+      }
+     const {neighbors, val} = currentNode
+      visited.add(val);
+      result.push(neighbors.map(res=> res.val));
+  
+      for (const neighbor of currentNode.neighbors) {
+        dfs(neighbor);
+      }
+    };
+  
+    dfs(node);
+  
+    return result;
+  }
+  
+
+}
+module.exports = Node;

common/utils/parseStructure.js

@@ -1,6 +1,7 @@
 
 const {parse, toArray} = require('../structures/ListNode')
 const {TreeNode} = require('../structures/TreeNode')
+const Node = require('../structures/Node')
 /**
  * 
  * @param {Array} params 
@@ -18,7 +19,11 @@ const setDataStructure = (params, structs,type='cases') => {
         'ListNode[]':(param) => param.map(res => parse(res)),
         TreeNode:(param) => {
          const node = new TreeNode(param);
-        return node.parse(param)
+         return node.parse(param)
+        },
+        Node: (param) => {
+          const node = new Node(param);
+          return node.parse(param)
         },
         default: param,
 
@@ -31,6 +36,10 @@ const setDataStructure = (params, structs,type='cases') => {
           const node = new TreeNode(param);
          return node.toArray(param)
          },
+         Node: (param) => {
+          const node = new Node(param);
+          return node.toArray(param)
+         },
         default: param => param,
 
       }
@@ -39,7 +48,7 @@ const setDataStructure = (params, structs,type='cases') => {
   return params.map((param, index) => {
     const struct = structs[index];
     const map = paramMap(param)[type];
-    return  map[struct] ?  map[struct](param) || map['default'](param) : param
+    return  map[struct] ?  map[struct](param) : map['default'](param) 
   })
 }
 

src/133.clone-graph/index.js

@@ -0,0 +1,93 @@
+const { showLogs } = require("../../common/utils/withTimeLog");
+const Node = require('../../common/structures/Node')
+/**
+ * 133.克隆图 
+ * 给你无向 连通 图中一个节点的引用，请你返回该图的 深拷贝（克隆）。
+ * 图中的每个节点都包含它的值 val（int） 和其邻居的列表（list[Node]）。
+ * class Node {
+ *     public int val;
+ *     public List<Node> neighbors;
+ * }
+ *  
+ * 测试用例格式：
+ * 简单起见，每个节点的值都和它的索引相同。例如，第一个节点值为 1（val = 1），第二个节点值为 2（val = 2），以此类推。该图在测试用例中使用邻接列表表示。
+ * 邻接列表 是用于表示有限图的无序列表的集合。每个列表都描述了图中节点的邻居集。
+ * 给定节点将始终是图中的第一个节点（值为 1）。你必须将 给定节点的拷贝 作为对克隆图的引用返回。
+ *  
+ * 示例 1：
+ * 输入：adjList = [[2,4],[1,3],[2,4],[1,3]]
+ * 输出：[[2,4],[1,3],[2,4],[1,3]]
+ * 解释：
+ * 图中有 4 个节点。
+ * 节点 1 的值是 1，它有两个邻居：节点 2 和 4 。
+ * 节点 2 的值是 2，它有两个邻居：节点 1 和 3 。
+ * 节点 3 的值是 3，它有两个邻居：节点 2 和 4 。
+ * 节点 4 的值是 4，它有两个邻居：节点 1 和 3 。
+ * 示例 2：
+ * 输入：adjList = [[]]
+ * 输出：[[]]
+ * 解释：输入包含一个空列表。该图仅仅只有一个值为 1 的节点，它没有任何邻居。
+ * 示例 3：
+ * 输入：adjList = []
+ * 输出：[]
+ * 解释：这个图是空的，它不含任何节点。
+ * 示例 4：
+ * 输入：adjList = [[2],[1]]
+ * 输出：[[2],[1]]
+ *  
+ * 提示：
+ * 	节点数不超过 100 。
+ * 	每个节点值 Node.val 都是唯一的，1 <= Node.val <= 100。
+ * 	无向图是一个简单图，这意味着图中没有重复的边，也没有自环。
+ * 	由于图是无向的，如果节点 p 是节点 q 的邻居，那么节点 q 也必须是节点 p 的邻居。
+ * 	图是连通图，你可以从给定节点访问到所有节点。
+ * 
+ */
+/**
+ * // Definition for a Node.
+ * function Node(val, neighbors) {
+ *    this.val = val === undefined ? 0 : val;
+ *    this.neighbors = neighbors === undefined ? [] : neighbors;
+ * };
+ */
+
+/**
+ * @param {Node} node
+ * @return {Node}
+ */
+var cloneGraph = function(node) {
+        if (!node) return;
+    // 深度优先遍历
+    const visited = new Map();
+    const dfs = (n) => {
+        const nCopy = new Node(n.val);
+        visited.set(n, nCopy);
+        // 防止neighbors 为空
+        (n.neighbors || []).forEach(ne => {
+            if (!visited.has(ne)) {
+                dfs(ne);
+            }
+            // push 新节点，且可以确保一定有该节点
+            nCopy.neighbors.push(visited.get(ne));
+        })
+    };
+    dfs(node);
+    return visited.get(node);
+};
+
+/**
+ * Test case
+ */
+showLogs(
+    cloneGraph,
+    {
+        data: [[adjList = [[2,4],[1,3],[2,4],[1,3]]],[adjList = [[]]],[adjList = []],[adjList = [[2],[1]]]],
+        structure: ["Node"],
+    },
+    {
+        data: [[[2,4],[1,3],[2,4],[1,3]],[[]],[],[[2],[1]]],
+        structrue: ["Node"]
+    }
+)
+console.log("点击跳转到题目提交:https://leetcode.cn/problems/clone-graph/")
+