Data Structures and Algorithms in Java[1].pdf - Fulvio Frisone

Show that, using an extendable array that grows and shrinks as described in the
previous exercise, the following series of 2n operations takes O(n) time: (i) n
push operations on an array list with initial capacity N = 1; (ii) n pop (removal
of the last element) operations.
C-6.4
Show how to improve the implementation of method add in Code Fragment 6.3
so that, in case of an overflow, the elements are copied into their final place in
the new array, that is, no shifting should be done in this case.
C-6.5
Consider an implementation of the array list ADT using an extendable array, but
instead of copying the elements of the array list into an array of double the size
(that is, from N to 2N) when its capacity is reached, we copy the elements into
an array with N/4 additional cells, going from capacity N to N + N/4.
Show that performing a sequence of n push operations (that is, insertions at the
end) still runs in O(n) time in this case.
C-6.6
The NodePositionList implementation given in Code Fragments 6.9-6.11
does not do any error checks to test if a given position p is actually a member of
this particular list. For example, if p is a position in list S and we call
T.addAfter(p, e) on a different list T, then we actually will add the
element to S just after p. Describe how to change the NodePositionList
implementation in an efficient manner to disallow such misuses.
C-6.7
Suppose we want to extend the Sequence abstract data type with methods
indexOfElement(e) and positionOfElement(e), which respectively
return the index and the position of the (first occurrence of) element e in the
sequence. Show how to implement these methods by expressing them in terms
of other methods of the Sequence interface.
C-6.8
Give an adaptation of the array list ADT to the deque ADT that is different from
that given in Table 6.1.
C-6.9
Describe the structure and pseudo-code for an array-based implementation of
the array list ADT that achieves O(1) time for insertions and removals at index
0, as well as insertions and removals at the end of the array list. Your
implementation should also provide for a constant-time get method. (Hint:
368