2822. 对象反转 🔒

🟢   🔗 力扣 LeetCode

题目

Given an object or an array obj, return an inverted object or array invertedObj.

The invertedObj should have the keys of obj as values and the values of obj as keys. The indices of array should be treated as keys.

The function should handle duplicates, meaning that if there are multiple keys in obj with the same value, the invertedObj should map the value to an array containing all corresponding keys.

It is guaranteed that the values in obj are only strings.

Example 1:

Input: obj = {"a": "1", "b": "2", "c": "3", "d": "4"}

Output: invertedObj = {"1": "a", "2": "b", "3": "c", "4": "d"}

Explanation: The keys from obj become the values in invertedObj, and the values from obj become the keys in invertedObj.

Example 2:

Input: obj = {"a": "1", "b": "2", "c": "2", "d": "4"}

Output: invertedObj = {"1": "a", "2": ["b", "c"], "4": "d"}

Explanation: There are two keys in obj with the same value, the invertedObj mapped the value to an array containing all corresponding keys.

Example 3:

Input: obj = ["1", "2", "3", "4"]

Output: invertedObj = {"1": "0", "2": "1", "3": "2", "4": "3"}

Explanation: Arrays are also objects therefore array has changed to an object and the keys (indices) from obj become the values in invertedObj, and the values from obj become the keys in invertedObj.

Constraints:

• obj is a valid JSON object or array
• typeof obj[key] === "string"
• 2 <= JSON.stringify(obj).length <= 10^5

题目大意

给定一个对象 obj，返回一个反转的对象 invertedObj。

invertedObj 应该以 obj 的键作为值，以 obj 的值作为键。题目保证 obj 中的值仅为字符串。该函数应该处理重复值，也就是说，如果在 obj 中有多个具有相同值的键，那么 invertedObj 应该将该值映射到一个包含所有相应键的数组中。

示例 1：

输入： obj = {"a": "1", "b": "2", "c": "3", "d": "4"}

输出： invertedObj = {"1": "a", "2": "b", "3": "c", "4": "d"}

解释： obj 中的键变成 invertedObj 中的值，而 obj 中的值变成 invertedObj 中的键。

示例 2：

输入： obj = {"a": "1", "b": "2", "c": "2", "d": "4"}

输出： invertedObj = {"1": "a", "2": ["b", "c"], "4": "d"}

解释： 在 obj 中有两个具有相同值的键，invertedObj 将该值映射到一个包含所有对应键的数组中。

示例 3：

输入： obj = ["1", "2", "3", "4"]

输出： invertedObj = {"1": "0", "2": "1", "3": "2", "4": "3"}

解释： 数组也是对象，因此数组已经转换为一个对象，obj 中的键（索引）变成了 invertedObj 中的值，而 obj 中的值变成了 invertedObj 中的键。

提示：

• obj 是一个有效的 JSON 对象
• typeof obj[key] === "string"
• 2 <= JSON.stringify(obj).length <= 10**5

解题思路

1. 首先遍历输入对象 obj 中的每个键，对于每个键值对，获取其值 val 和对应的键 key。

2. 反转操作：

   • 如果当前值 val 已经存在于反转对象 res 中，需要进行以下判断：
     • 如果 res[val] 已经是一个数组，说明已经有多个键与该值关联，则直接将当前的 key 推入数组中。
     • 如果 res[val] 不是数组，说明该值只对应一个键，将该键和当前的键一起存入一个数组中。
   • 如果 res[val] 不存在，则直接将当前的键 key 存入 res[val] 中，表示该值只对应一个键。

3. 完成整个对象的遍历后，返回 res，即反转后的对象。

复杂度分析

• 时间复杂度：O(n)，其中 n 是 obj 中的键的数量，需要遍历 obj 中的每个键。
• 空间复杂度：O(n)，最坏情况下，所有的键对应的值都不同，结果对象 res 中将存储 n 个不同的值。

代码

/**
 * @param {Object} obj
 * @return {Object}
 */
var invertObject = function (obj) {
	let res = {};
	for (let key in obj) {
		const val = obj[key];

		// 检查当前值是否已经存在于反转对象中
		if (res[val]) {
			// 如果已经存在，添加到数组中
			if (Array.isArray(res[val])) {
				res[val].push(key);
			} else {
				res[val] = [res[val], key];
			}
		} else {
			// 否则，直接将当前键赋值给 res[val]
			res[val] = key;
		}
	}
	return res;
};