1389. 按既定顺序创建目标数组『简单』

题目来源于力扣（LeetCode）

目录

• 一、题目
• 二、解题思路
  • 2.1 调用 LinkedList 类中 add 方法
  • 2.2 数组元素后移
  • 2.3 规范化 index 数组后直接映射
• 三、代码实现
  • 3.1 调用 LinkedList 类中 add 方法
  • 3.2 数组元素后移
  • 3.3 规范化 index 数组后直接映射
• 四、执行用时
  • 4.1 调用 LinkedList 类中 add 方法
  • 4.2 数组元素后移
  • 4.3 规范化 index 数组后直接映射
• 五、部分测试用例

一、题目

1389. 按既定顺序创建目标数组

题目相关标签：数组

说明：

• 1 <= nums.length, index.length <= 100
• nums.length == index.length
• 0 <= nums[i] <= 100
• 0 <= index[i] <= i

二、解题思路

将 nums[i] 上的元素插入到新数组的 index[i] 索引上，索引上已有的元素依次后移

2.1 调用 LinkedList 类中 add 方法

通过链表结构的 LinkedList 中 add 方法，在指定索引处添加元素

2.2 数组元素后移

1. 遍历 index 数组，判断当前元素是否等于当前遍历的索引 i

2. 相同时，直接在新数组的索引 i 上插入 nums[i] 元素

3. 不同时，进行后移已有元素再插入元素的操作

   1. 倒序循环索引 i 至要插入新元素的索引 + 1 处，通过对遍历索引上的元素 = 前一位索引上的元素来实现后移

   2. 全部后移结束后，在插入索引处插入元素 nums[i]

2.3 规范化 index 数组后直接映射

1. 遍历 index 数组，进行规范化（使数组中无重复的元素）的操作

2. 即遍历的索引与索引上的元素不同时，进行元素后移并插入元素的操作

   对于：0, 1, 2, 2, 1，第 2 个 2 时，取值应该是 nums[3]（在索引 3 上），插入新数组的索引为 2（数值为 2），需要进行后移再插入，对当前遍历索引 3 至当前遍历元素 2（不包括） 进行倒序遍历，完成后移，最后在 index[i] 上插入 i，即更改为：0, 1, 3, 2, 1，最后一个 1 的规范化同理。

3. 规范 index 数组后（即 index 数组中无重复元素），开始遍历 nums 数组完成映射：将 nums 数组中索引为 index[i] 的元素插入到新数组的索引 i 上，i 从 0 开始

   ans[i] = nums[index[i]];
   

三、代码实现

3.1 调用 LinkedList 类中 add 方法

public static int[] createTargetArray(int[] nums, int[] index) {
    LinkedList<Integer> list = new LinkedList<>();
    for (int i = 0; i < nums.length; i++) {
        // 直接调用 LinkedList 类库中的 add 方法，往指定的位置 add 元素，其他元素自动后移
        list.add(index[i], nums[i]);
    }
    // list 列表转数组
    int[] ans = new int[nums.length];
    for (int i = 0; i < nums.length; i++) {
        ans[i] = list.get(i);
    }
    return ans;
}

3.2 数组元素后移

public static int[] createTargetArray(int[] nums, int[] index) {
    // 结果集数组
    int[] ans = new int[nums.length];
    for (int i = 0; i < ans.length; i++) {
        int k = index[i];
        // k 与 ans 中依次插入元素的索引相同时，直接插入元素，0 与 0，1 与 1，2 与 2
        if (k == i) {
            ans[i] = nums[i];
        } else {
            // 索引不同时，需要在指定索引 k 处插入 nums[i] 中的元素
            // 而 ans 数组中已插入的元素会受到影响，需要对已有元素进行移动
            // 指定位置后一位索引至 索引 i 处的每个元素依次后移
            for (int j = i; j > k; j--) {
                // 当前索引元素 = 前一个索引元素，实现后移
                ans[j] = ans[j - 1];
            }
            // 后移完成后，在指定位置 k 插入 nums[i] 元素
            ans[k] = nums[i];
        }
    }
    return ans;
}

3.3 规范化 index 数组后直接映射

public static int[] createTargetArray(int[] nums, int[] index) {
    int[] ans = new int[nums.length];
    for (int i = 0; i < index.length; i++) {
        int n = index[i];
        // 对于索引与数值不同的元素进行修改
        if (n != i) {
            int j = i;
            // 循环完成后移操作
            for (; j > n; j--) {
                // 当前元素 = 前一个索引的元素，实现后移
                index[j] = index[j - 1];
            }
            // 指定位置插入，插入的索引值为当前遍历的索引值 i:0,1,2,3,4,5,...
            index[j] = i;
        }
    }
    // 一次性完成索引的映射并插入到 ans 数组中
    for (int i = 0; i < index.length; i++) {
        // 规范索引列表后：
        // 将 nums 数组中索引为 index[i] 的元素插入到新数组的索引 i 上，i 从 0 开始
        ans[i] = nums[index[i]];
    }
    return ans;
}

四、执行用时

4.1 调用 LinkedList 类中 add 方法

4.2 数组元素后移

4.3 规范化 index 数组后直接映射

五、部分测试用例

public static void main(String[] args) {
    int[] nums = {0, 1, 2, 3, 4}, index = {0, 1, 2, 2, 1};  // output:{0, 4, 1, 3, 2}
//    int[] nums = {1, 2, 3, 4, 0}, index = {0, 1, 2, 3, 0};  // output:{0, 1, 2, 3, 4}
//    int[] nums = {1}, index = {0};  // output:{1}
    
    int[] result = createTargetArray(nums, index);
    System.out.println(result);
}

标签：index,nums,int,元素,索引,1389,数组,既定
来源： https://www.cnblogs.com/zhiyin1209/p/12984846.html