需要优化算法 - Arrays

Question

We have an array A of integers of size N. Given another array B which contains indices, where size of B <= N and 0<=B[i]<=N-1 .

Now we have to remove all elements from array A at position B[i] .

So with deletion we mean we are also shifting elements in array A.

Can someone help me in reaching to O(n) solution for this problem? And possibly O(1) space.

The first solution that comes to my mind is, traversing the array B and deleting elements in A sequentially( including shifting) but it is O(n^2) .

Answer 1

Similar to iliaden's solution except you could do the removing of deleted elements in place.

int[] a = 
int[] b = 
int nullValue = 
for(int i: b) a[i] = nullValue;
int j=0;
for(int i=0; i < a.length; i++) {
    if(a[i] != nullValue)
       a[j++] = a[i];
}
// to clear the rest of the array, if required.
for(;j<a.length;j++)
   a[j] = nullValue;

note: a won't be shorter, but it avoid creating any more space. 'j' will have the number of valid entries in a

Answer 2

in O(n) space, you can do:

1. traverse array A deleting every element at b[i] (no shifting, O(n))

2. create a new array C, copy all the non-empty elements from A into C sequentially (also O(n))

3. return array C or copy it back onto a cleared array A (O(n)). thus you get to do it in O(n) tim and O(n) space

Answer 3

No marking, O(n) time, but also O(n) space, in pseudo-code:

// create a boolean array indicating which elements are to be deleted
D = new boolean[N]
fill(D, false)
for (b in B) {
  D[b] = true
}

// compact `A in place
src = 0
dest = 0
while (src < N) {
  if (!D[src]) {
    A[dest++] = A[src]
  }
  src++
}

new_N = dest

Answer 4

if you can assume b is sorted you can shift as you iterate (you can sort the b in O(n*log(n)) if not)

int[] b;
int[] a;
int first=0,bInd=0;
for(int i = 0;i<a.length;i++){
    if(bInd>=b.length || b[bInd]!=i){
        a[first]=a[i];
        first++;
    }else{
        bInd++;
    }
}

Answer 5

Two obvious solutions: sort B in reverse order before starting, so you always delete the highest index (and so never shift a deleted element), or iterate through B to create a bitmap of elements to delete (and then do those in the reverse order). The first requires an additional O(lg n) step beforehand, and the second additional space. But I'm not sure there are any better alternatives.