插入K的重复项，因为它在数组中每次都出现

给定一个由N个整数和整数K组成的数组arr ，任务是在原始序列中为每个出现的K插入一个相邻的K，然后使用O(1)辅助空间将数组截断为原始长度。
例子：

Input: arr[] = {1, 0, 2, 3, 0, 4, 5, 0}, K = 0 
Output: {1, 0, 0, 2, 3, 0, 0, 4} 
Explanation: 
The given array {1, 0, 2, 3, 0, 4, 5, 0} is modified to {1, 0, 0, 2, 3, 0, 0, 4] after insertion of two 0’s and truncation of extra elements.

Input: arr[] = {7, 5, 8}, K = 8 
Output: {7, 5, 8} 
Explanation: 
After inserting an adjacent 8 into the array, it got truncated to restore the original size of the array. 
 

方法1：使用STL函数
可以使用内置函数pop_back()和insert()解决此问题。

下面是上述方法的实现：

C++

// C++ implementation to update each entry of zero
// with two zero entries adjacent to each other
#include 
using namespace std;
  
// Function to update each entry of zero
// with two zero entries adjacent to each other
vector duplicateK(vector& arr)
{
    int N = arr.size();
    for(int i=0;i arr 
= { 1, 0, 2, 3, 0, 4, 5, 0  };
  
    vector ans = duplicateK(arr);
  
    for (int i = 0; i < ans.size(); i++)
        cout << ans[i] << " ";
  
    return 0;
}

Java

// Java implementation to update each 
// entry of zero with two zero entries
// adjacent to each other
import java.util.*;
  
class GFG{
  
// Function to update each entry of
// zero with two zero entries 
// adjacent to each other
static Vector duplicateK(Vector arr)
{
    int N = arr.size();
    for(int i = 0; i < N; i++)
    {
       if(arr.get(i) == 0)
       {
             
           // Insert an adjacent 0
           arr.add(i + 1, 0);
             
           i++;
             
           // Pop the last element
           arr.remove(arr.size() - 1);
       }
    }
    return arr;
}
  
// Driver code
public static void main(String[] args)
{
    Integer []arr = { 1, 0, 2, 3, 0, 4, 5, 0 };
      
    Vector vec = new Vector();;
    for(int i = 0; i < arr.length; i++)
       vec.add(arr[i]);
          
    Vector ans = duplicateK(vec);
  
    for(int i = 0; i < ans.size(); i++)
       System.out.print(ans.get(i) + " ");
}
}
  
// This code is contributed by gauravrajput1

C#

// C# implementation to update each 
// entry of zero with two zero entries
// adjacent to each other
using System;
using System.Collections.Generic;
  
class GFG{
  
// Function to update each entry of
// zero with two zero entries 
// adjacent to each other
static List duplicateK(List arr)
{
    int N = arr.Count;
    for(int i = 0; i < N; i++)
    {
        if(arr[i] == 0)
        {
                  
            // Insert an adjacent 0
            arr.Insert(i + 1, 0);
                  
            i++;
                  
            // Pop the last element
            arr.RemoveAt(arr.Count - 1);
        }
    }
    return arr;
}
  
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 0, 2, 3, 0, 4, 5, 0 };
      
    List vec = new List();;
    for(int i = 0; i < arr.Length; i++)
    vec.Add(arr[i]);
          
    List ans = duplicateK(vec);
  
    for(int i = 0; i < ans.Count; i++)
    Console.Write(ans[i] + " ");
}
}
  
// This code is contributed by gauravrajput1

输出：

1 0 0 2 3 0 0 4 

方法2：使用两个指针技术

• 由于每个K都需要使用彼此相邻的两个K条目进行更新，因此该数组的长度将增加一个数量，该数量等于原始数组arr []中存在的K数量。
• 求出K的总数，然后假定我们有一个数组，该数组具有足够的空间来容纳每个元素。
• 初始化变量write_idx将指向索引在这个假想数组的末尾，并在实际数组的末尾另一个指针CURR即ARR [N-1]。
• 从末尾开始迭代，对于每个元素，我们假定将元素复制到其实际位置，但是仅当write_idx

下面是上述方法的实现：

C++

// C++ implementation to update each entry of zero
// with two zero entries adjacent to each other
#include 
using namespace std;
  
// Function to update each entry of zero
// with two zero entries adjacent to each other
vector duplicateZeros(vector& arr)
{
    const int N = arr.size();
  
    // Find the count of total number of zeros
    int cnt = count(arr.begin(), arr.end(), 0);
  
    // Variable to store index where elements
    // will be written in the final array
    int write_idx = N + cnt - 1;
  
    // Variable to point the current index
    int curr = N - 1;
  
    while (curr >= 0 && write_idx >= 0) {
        // Keep the current element to its correct
        // position, if that is within teh size N
        if (write_idx < N)
            arr[write_idx] = arr[curr];
  
        write_idx -= 1;
  
        // Check if the current element is also
        // zero then again write its duplicate
        if (arr[curr] == 0) {
            if (write_idx < N)
                arr[write_idx] = 0;
  
            write_idx -= 1;
        }
  
        --curr;
    }
  
    // Return the final result
    return arr;
}
  
// Driver code
int main(int argc, char* argv[])
{
    vector arr = { 1, 0, 2, 3, 0, 4, 5, 0 };
  
    vector ans = duplicateZeros(arr);
  
    for (int i = 0; i < ans.size(); i++)
        cout << ans[i] << " ";
  
    return 0;
}

Java

// Java implementation to update 
// each entry of zero with two zero 
// entries adjacent to each other
class GFG{
  
// Function to update each 
// entry of zero with two zero 
// entries adjacent to each other
static int[] duplicateZeros(int []arr)
{
      
    int N = arr.length;
      
    // Find the count of
    // total number of zeros
    int cnt = count(arr, 0);
      
    // Variable to store index 
    // where elements will be 
    // written in the final array
    int write_idx = N + cnt - 1;
      
    // Variable to point the current index
    int curr = N - 1;
      
    while (curr >= 0 && write_idx >= 0)
    {
          
        // Keep the current element 
        // to its correctposition, if 
        // that is within teh size N
        if (write_idx < N)
            arr[write_idx] = arr[curr];
      
        write_idx -= 1;
      
        // Check if the current element is also
        // zero then again write its duplicate
        if (arr[curr] == 0)
        {
            if (write_idx < N)
                arr[write_idx] = 0;
                  
            write_idx -= 1;
        }
        --curr;
    }
      
    // Return the final result
    return arr;
}
  
static int count(int []arr, int num)
{
    int ans = 0;
    for(int i : arr)
      
       if(i == num)
          ans++;
    return ans;
}
  
// Driver code
public static void main(String[] args)
{
    int []arr = { 1, 0, 2, 3, 0, 4, 5, 0 };
    int []ans = duplicateZeros(arr);
  
    for(int i = 0; i < ans.length; i++)
       System.out.print(ans[i] + " ");
}
}
  
// This code is contributed by Amit Katiyar

Python3

# Python3 implementation to update each entry of zero 
# with two zero entries adjacent to each other 
  
# Function to update each entry of zero 
# with two zero entries adjacent to each other 
def duplicateZeros(arr): 
  
    N = len(arr) 
  
    # Find the count of total number of zeros 
    cnt = arr.count(0)
  
    # Variable to store index where elements 
    # will be written in the final array 
    write_idx = N + cnt - 1
  
    # Variable to point the current index 
    curr = N - 1
  
    while (curr >= 0 and write_idx >= 0): 
          
        # Keep the current element to its correct 
        # position, if that is within the size N 
        if (write_idx < N): 
            arr[write_idx] = arr[curr] 
  
        write_idx -= 1
  
        # Check if the current element is also 
        # zero then again write its duplicate 
        if (arr[curr] == 0): 
            if (write_idx < N): 
                arr[write_idx] = 0
  
            write_idx -= 1
  
        curr -= 1
  
    # Return the final result 
    return arr 
  
# Driver Code 
arr = [ 1, 0, 2, 3, 0, 4, 5, 0 ]
  
ans = duplicateZeros(arr) 
for i in range(len(ans)):
    print(ans[i], end = " ") 
      
# This code is contributed by divyamohan123 

C＃

// C# implementation to update 
// each entry of zero with two zero 
// entries adjacent to each other
using System;
  
class GFG{
  
// Function to update each 
// entry of zero with two zero 
// entries adjacent to each other
static int[] duplicateZeros(int []arr)
{
    int N = arr.Length;
      
    // Find the count of
    // total number of zeros
    int cnt = count(arr, 0);
      
    // Variable to store index 
    // where elements will be 
    // written in the readonly array
    int write_idx = N + cnt - 1;
      
    // Variable to point the 
    // current index
    int curr = N - 1;
      
    while (curr >= 0 && write_idx >= 0)
    {
          
        // Keep the current element 
        // to its correctposition, if 
        // that is within teh size N
        if (write_idx < N)
            arr[write_idx] = arr[curr];
      
        write_idx -= 1;
      
        // Check if the current element is also
        // zero then again write its duplicate
        if (arr[curr] == 0)
        {
            if (write_idx < N)
                arr[write_idx] = 0;
                  
            write_idx -= 1;
        }
        --curr;
    }
      
    // Return the readonly result
    return arr;
}
  
static int count(int []arr, int num)
{
    int ans = 0;
    foreach(int i in arr)
    {
        if(i == num)
           ans++;
    }
    return ans;
}
  
// Driver code
public static void Main(String[] args)
{
    int []arr = { 1, 0, 2, 3, 0, 4, 5, 0 };
    int []ans = duplicateZeros(arr);
  
    for(int i = 0; i < ans.Length; i++)
       Console.Write(ans[i] + " ");
}
}
  
// This code is contributed by Amit Katiyar

输出：

1 0 0 2 3 0 0 4

时间复杂度： O(N)
辅助空间： O(1)