LeetCode——距离顺序排列矩阵单元格

题目：给出 R 行 C 列的矩阵，其中的单元格的整数坐标为 (r, c)，满足 0 <= r < R 且 0 <= c < C。

另外，我们在该矩阵中给出了一个坐标为 (r0, c0) 的单元格。

返回矩阵中的所有单元格的坐标，并按到 (r0, c0) 的距离从最小到最大的顺序排，其中，两单元格(r1, c1) 和 (r2, c2)
之间的距离是曼哈顿距离，|r1 - r2| + |c1 - c2|。（你可以按任何满足此条件的顺序返回答案。）

示例 1：

输入：R = 1, C = 2, r0 = 0, c0 = 0
输出：[[0,0],[0,1]]
解释：从 (r0, c0) 到其他单元格的距离为：[0,1]

解决思路

我的解决思路是，使用二维数组存储当前位置于给定位置的距离，然后声明一个类，存储每个节点，包含该节点的xy坐标和距离值，然后以距离为关键字，对各节点排序，排序之后按顺序写输出节点的xy坐标即可。

//用于存储xy坐标和距离值
class Node {
	int i;
	int j;
	int val;

	Node(int a, int b, int c) {
		this.i = a;
		this.j = b;
		this.val = c;
	}
}

class Solution {
	public int[][] allCellsDistOrder(int R, int C, int r0, int c0) {
		int grid[][] = new int[R][C];//存放距离值
		int res[][] = new int[R * C][2];// result
		Node[] nodes = new Node[R * C];
		grid[r0][c0] = 0;//自己和自己距离0
		int count = 0;
		for (int i = 0; i < R; i++) {
			for (int j = 0; j < C; j++) {
				grid[i][j] = Math.abs(i - r0) + Math.abs(j - c0);//计算曼哈顿距离
				nodes[count] = new Node(i, j, grid[i][j]);//创建节点对象，存储
                count++;
			}
		}
		QuickSort(nodes, 0, R * C - 1);//利用快排进行排序
		for (int i = 0; i < nodes.length; i++) {//按顺序输出结果
			res[i][0] = nodes[i].i;
			res[i][1] = nodes[i].j;
		}
		return res;

	}

	private static Node[] QuickSort(Node[] nodes, int q, int r) {
		if (q < r) {
			int p = Partition(nodes, q, r);
			QuickSort(nodes, q, p - 1);
			QuickSort(nodes, p + 1, r);
		}
		return nodes;
	}

	private static int Partition(Node[] nodes, int q, int r) {
		int base = nodes[r].val;
		int i = q - 1;
		for (int j = q; j < r; j++) {
			if (nodes[j].val < base) {
				i++;
				swap(nodes, i, j);
			}
			
		}
        swap(nodes, i + 1, r);
		return i + 1;
	}

	public static void swap(Node[] nodes, int i, int j) {
		Node tmp = nodes[i];
		nodes[i] = nodes[j];
		nodes[j] = tmp;
	}
}