Question

You must implement a BlockedList class that implements the List interface. You
may use any of the classes in JCF or in the textbook code. The constructor for this class takes an
integer block size b and the implementation should have the following performance characteristics:
a) get(i) and set(i,x) should run in O(1) time per operation
b) add(i,x) and remove(i) should run in O(b+ min{i, n-i}/b) amortized time per operation.
Any solution matching this specification is acceptable. However, the runtime would suggest a data
structure that contains other data structures, or “blocks” of size at most b. For one possible solution,
recall that an array backed Deque (an ArrayDeque in the textbook, or a Deque in the JCF)
implements add(i,x) and remove(i) in O(min{i, n-i}) amortized time per operation. We want a data
structure with performance characteristics similar to an ArrayDeque (within a factor of b). We
might therefore consider an ArrayDeque of data structures. It is then left to you to determine the
inner data structure. Also note, if we choose a block size of b=1, then we simply have an ArrayDeque
running in O(b+ min{i, n-i}/b) = O(min{i, n-i}) amortized time per operation, as required,
regardless of the inner data structure chosen.

Java

Answer 1

For this question, I have used the java list interface itself. (I have not implemented all the methods, just the required methods are implemented by me)

First of all, we need to understand that to archive get(i) and set(i,x) in O(1), we need a data structure in which we can access data elements in O(1). Such a data structure is Arrays in Java. So we'll use the Integer array for our task.

• The code of get(i) is simple. If i<size(data) then we'll simply return it else we'll return null object.

-------------------------------------------------------

public Object get(int i) {
    if(i>data.length)
        return null;
    else
        return data[i];
}

---------------------------------------------------------

• In the same way, set(i,o) we'll set element index i to o.

---------------------------------------------------------

public Object set(int i, Object o) {
    data[i] = (Integer)o;
    return data[i];
}

---------------------------------------------------------

• To get add(i,o) and remove(i) in O(b + min(i,n-i)/b), following algorithm can be used.
  • Add:
    • Copy i-1 data to a temp array
    • add i
    • copy rest of the elements
  • Remove:
    • Copy i-1 data to temp
    • Copy i+1 to rest of elements to temp

Code for it is -------------------------------------------

public void add(int i, Object o) {
    int max = i>data.length?i:data.length;
    int min = i<data.length?i:data.length
    Integer temp[] = new Integer[max];
    for(int a=0;a<min;++a)
        temp[a]=data[a];
    temp[i] = (Integer) o;
    for(int a=i+1;a<max;++a)
        temp[a] = data[a];
    data = temp;
}

@Override
public Object remove(int i) {
    Integer temp[] = new Integer[data.length-1];
    for(int k=0;k<i;++k)
        temp[k]=data[k];
    for(int k=i+1;k<data.length;++k)
        temp[k] = data[k];
    int removed = data[i];
    data = temp;
    return removed;
}

-----------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

Entire Code

----------------------------------------------------------------------------------------------------------------------------------------------------------------------

import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;

public class BlockedList implements List {

    private Integer data[];

    BlockedList(int b){
        data = new Integer[b];
    }
    @Override
    public int size() {
        return data.length;
    }

    @Override
    public boolean isEmpty() {
        return data.length==0?true:false;
    }

    @Override
    public boolean contains(Object o) {
        Integer val = (Integer)o;
        for( Integer i : data){
            if(i.intValue() == val.intValue())
                return true;
        }
        return false;
    }

    @Override
    public Iterator iterator() {
        return null;
    }

    @Override
    public Object[] toArray() {
        return data;
    }

    @Override
    public boolean add(Object o) {
        return false;
    }

    @Override
    public boolean remove(Object o) {
        return false;
    }

    @Override
    public boolean addAll(Collection collection) {
        return false;
    }

    @Override
    public boolean addAll(int i, Collection collection) {
        return false;
    }

    @Override
    public void clear() {

    }

    @Override
    public Object get(int i) {
        if(i>data.length)
            return null;
        else
            return data[i];
    }

    @Override
    public Object set(int i, Object o) {
        data[i] = (Integer)o;
        return data[i];
    }

    @Override
    public void add(int i, Object o) {
        int max = i>data.length?i:data.length;
        int min = i<data.length?i:data.length
        Integer temp[] = new Integer[max];
        for(int a=0;a<min;++a)
            temp[a]=data[a];
        temp[i] = (Integer) o;
        for(int a=i+1;a<max;++a)
            temp[a] = data[a];
        data = temp;
    }

    @Override
    public Object remove(int i) {
        Integer temp[] = new Integer[data.length-1];
        for(int k=0;k<i;++k)
            temp[k]=data[k];
        for(int k=i+1;k<data.length;++k)
            temp[k] = data[k];
        int removed = data[i];
        data = temp;
        return removed;
    }

    @Override
    public int indexOf(Object o) {
        return 0;
    }

    @Override
    public int lastIndexOf(Object o) {
        return 0;
    }

    @Override
    public ListIterator listIterator() {
        return null;
    }

    @Override
    public ListIterator listIterator(int i) {
        return null;
    }

    @Override
    public List subList(int i, int i1) {
        return null;
    }

    @Override
    public boolean retainAll(Collection collection) {
        return false;
    }

    @Override
    public boolean removeAll(Collection collection) {
        return false;
    }

    @Override
    public boolean containsAll(Collection collection) {
        return false;
    }

    @Override
    public Object[] toArray(Object[] objects) {
        return new Object[0];
    }

}