从相邻元素对还原数组

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/restore-the-array-from-adjacent-pairs

题目描述：

存在一个由 n 个不同元素组成的整数数组 nums ，但你已经记不清具体内容。好在你还记得 nums 中的每一对相邻元素。

给你一个二维整数数组 adjacentPairs ，大小为 n - 1 ，其中每个 adjacentPairs[i] = [ui, vi] 表示元素 ui 和 vi 在 nums 中相邻。

题目数据保证所有由元素 nums[i] 和 nums[i+1] 组成的相邻元素对都存在于 adjacentPairs 中，存在形式可能是 [nums[i], nums[i+1]] ，也可能是 [nums[i+1], nums[i]] 。这些相邻元素对可以 按任意顺序 出现。

返回 原始数组 nums 。如果存在多种解答，返回 其中任意一个 即可。

示例 1：

输入：adjacentPairs = [[2,1],[3,4],[3,2]]
输出：[1,2,3,4]
解释：数组的所有相邻元素对都在 adjacentPairs 中。
特别要注意的是，adjacentPairs[i] 只表示两个元素相邻，并不保证其 左-右 顺序。

示例 2：

输入：adjacentPairs = [[4,-2],[1,4],[-3,1]]
输出：[-2,4,1,-3]
解释：数组中可能存在负数。
另一种解答是 [-3,1,4,-2] ，也会被视作正确答案。

示例 3：

输入：adjacentPairs = [[100000,-100000]]
输出：[100000,-100000]

思路：

与首尾两端的数字相邻的元素必然只有一个，也就是首尾元素在数组adjacentPairs中必然只会出现一次，因此可以先找到首尾两端的元素，然后再找到和收尾两端相邻的元素，再找到相邻元素相邻的元素，直到找到所有元素。

代码实现

class Solution {
    public int[] restoreArray(int[][] adjacentPairs) {
        Map> map = new HashMap<>();
        for (int[] adjacentPair : adjacentPairs) {
   
            ArrayList list1 = map.get(adjacentPair[0]);
            ArrayList list2 = map.get(adjacentPair[1]);

            if (list1 == null) {
                list1 = new ArrayList();
            }
            if (list2 == null) {
                list2 = new ArrayList();
            }

            list1.add(adjacentPair[1]);
            list2.add(adjacentPair[0]);

            map.put(adjacentPair[0], list1);
            map.put(adjacentPair[1], list2);
            
        }

        int n = adjacentPairs.length + 1;
        int[] arr = new int[n];
        boolean flag = true;
        for (Map.Entry> entry : map.entrySet()) {
            int e = entry.getKey();
            List nums = entry.getValue();
            if (nums.size() == 1 && flag) {
                arr[0] = e; // 填充首
                flag = false;
            } else if (nums.size() == 1 && !flag) {
                arr[n - 1] = e; // 填充尾
                break;
            }
        }
        // 填充首元素的相邻元素
        arr[1] = map.get(arr[0]).get(0);
        // 填充尾元素的相邻元素
        arr[n - 2] = map.get(arr[n - 1]).get(0);
        for (int i = 2, j = n - 3; i <= j ; i ++, j--) {
            // 从左往右填充首元素的相邻元素的相邻元素
            List left = map.get(arr[i - 1]);
            arr[i] = arr[i - 2] == left.get(0) ? left.get(1) : left.get(0);
            // 从右往左尾元素的相邻元素的相邻元素
            List right = map.get(arr[j + 1]);
             arr[j] = arr[j + 2] == right.get(0) ? right.get(1) : right.get(0);
        }
        return arr
    }
}