懒人算法设计之哈希表（对角线遍历）

本文链接：https://blog.csdn.net/weixin_45333934/article/details/105869026

给你一个列表 nums ，里面每一个元素都是一个整数列表。请你依照下面各图的规则，按顺序返回 nums 中对角线上的整数。

示例 1：

在这里插入图片描述

输入：
nums = [[1,2,3],[4,5,6],[7,8,9]]
输出：[1,4,2,7,5,3,8,6,9]

示例 2：

在这里插入图片描述

输入：nums = [[1,2,3,4,5],[6,7],[8],[9,10,11],[12,13,14,15,16]]
输出：[1,6,2,8,7,3,9,4,12,10,5,13,11,14,15,16]

示例 3：

输入：nums = [[1,2,3],[4],[5,6,7],[8],[9,10,11]]
输出：[1,4,2,5,3,8,6,9,7,10,11]

示例 4：

输入：nums = [[1,2,3,4,5,6]]
输出：[1,2,3,4,5,6]

提示：

1 <= nums.length <= 10^5
1 <= nums[i].length <= 10^5
1 <= nums[i][j]<= 10^9

nums 中最多有 10^5 个数字。

（1）哈希储存聚类

根据矩形的特点，设行的标号为i，列的标号为j。则对于每一条对角线而言，i + j的值是唯一的。知道这一点之后，就可以按照对角线对nums中的值进行聚类。聚类完毕后，将所有的数值生成一个数组即可。
在这里插入图片描述

	public int[] findDiagonalOrder(List<List<Integer>> nums) {
		int len = 0;
		Map<Integer, List<Integer>> map = new LinkedHashMap<>();
		for (int i = 0; i < nums.size(); i++) {
			len += nums.get(i).size();// 获取最后要返回的数组的长度，级元素个数
			for (int j = 0; j < nums.get(i).size(); j++) {
				if (map.containsKey(i + j)) {
					map.get(i + j).add(nums.get(i).get(j));
				} else {
					List<Integer> list = new ArrayList<Integer>();
					list.add(nums.get(i).get(j));
					map.put(i + j, list);
				}
			}
		}
		int[] ans = new int[len];
		int index = 0;
		for (int key : map.keySet()) {// 遍历map
			List<Integer> list = map.get(key);
			for (int j = list.size() - 1; j >= 0; j--) {// 根据题目的要求确定数组元素的生成顺序
				ans[index] = list.get(j);
				index++;
			}
		}
		return ans;
	}

（2）找规律

nums[i][j] 必然在第（i + j）次斜线的结果中。i 越小，结果越靠后。
python

class Solution:
    def findDiagonalOrder(self, nums: List[List[int]]) -> List[int]:
        sub_result = []
        for i in range(len(nums)):
            for j in range(len(nums[i])):
                if i + j >= len(sub_result):
                    sub_result.append([])
                sub_result[i + j].append(nums[i][j])
                
        result = []
        for sub in sub_result:
            result += sub[::-1]
        return result

（3）上个思路，换个写法

	class Solution:
	    def findDiagonalOrder(self, nums: List[List[int]]) -> List[int]:
	        from collections import defaultdict
	        tmp = defaultdict(list)
	        # 根据主对角线坐标特性，将横纵方向坐标和相同的放在一组
	        for row in range(len(nums)):
	            for col in range(len(nums[row])):
	                tmp[row + col].append(nums[row][col])
	        res = []
	        # 按字典的 key 排序进行遍历，取出的就是按题意由左下到右上方↗一组一组的值
	        for r_plus_c in sorted(list(tmp.keys())):
	            res.extend(tmp[r_plus_c][::-1])  # 由于存的时候是先遍历的存到前面，按题目要求需要返回来，所以取[::-1]
	        return res