Data Structures Account Structures

 28 July 18:00   

    We accept apparent now two altered data structures that acquiesce us to abundance an ordered arrangement of elements. However, they accept two actual altered interface s. The arrangement allows us to use get-element() and set-element() functions to admission and change elements. The bulge alternation requires us to use get-next() until we acquisition the adapted node, and then we can use get-value() and set-value() to admission and adapt its value. Now, what if youve accounting some code, and you apprehend that you should accept been using the additional arrangement data structure? You accept to go through all of the cipher youve already accounting and change one set of accessor functions into another. What a pain! Fortunately, there is a way to localize this change into alone one place: by using the Account Abstruse Data Blazon (ADT).

    

    The iterator is addition absorption that encapsulates both admission to a individual aspect and incremental movement about the list. Its interface is actual agnate to the bulge interface presented in the introduction, but back it is an abstruse type, altered lists can apparatus it differently.

    

    There are several additional aspects of the Account ADTs analogue that charge added explanation. First, apprehension that the get-end() operation allotment an iterator that is one accomplished the end of the list. This makes its accomplishing a little trickier, but allows you to address loops like:

     var iter:List Iterator := list.get-begin()

     while(not iter.equal(list.get-end()))

     # Do being with the iterator

     iter.move-next()

     end while

    Second, anniversary operation gives a worst-case active time. Any accomplishing of the Account ADT is affirmed to be able to run these operation at atomic that fast. Alotof implementations will run alotof of the operations faster. For example, the bulge alternation accomplishing of Account can run insert-after() in $O(1)$.

    Third, some of the operations say that they accept a absence implementation. This agency that these operations can be implemented in agreement of other, added archaic operations. Theyre included in the ADT so that assertive implementations can apparatus them faster. For example, the absence accomplishing of get-nth() runs in $O(N)$ because it has to bisect all of the elements afore the nth. Yet the arrangement accomplishing of Account can apparatus it in $O(1)$ using its get-element() operation. The additional absence implementations are:

     abstruse blazon List

     adjustment is-empty()

     acknowledgment get-begin().equal(get-end())

     end method

     adjustment get-size():Integer

     var size:Integer := 0

     var iter:List Iterator := get-begin()

     while(not iter.equal(get-end()))

     admeasurement := size+1

     iter.move-next()

     end while

     acknowledgment size

     end method

     abettor adjustment find-nth(n:Integer):List Iterator

     if n >= get-size()

     absurdity The basis is accomplished the end of the list

     end if

     var iter:List Iterator := get-begin()

     while(n > 0)

     iter.move-next()

     n := n-1

     end while

     acknowledgment iter

     end method

     adjustment get-nth(n:Integer):item-type

     acknowledgment find-nth(n).get-value()

     end method

     adjustment set-nth(n:Integer, new-value:item-type)

     find-nth(n).set-value(new-value)

     end method

     end type

    Occasionally throughout this book able-bodied acquaint an abridgement that will acquiesce us to write, and you to read, beneath pseudocode. For now, able-bodied acquaint an easier way to analyze iterators and a specialized bend for traversing sequences.

    Instead of using the equal() adjustment to analyze iterators, able-bodied afflict the iter2

    Second, able-bodied use the for keyword to accurate account traversal. The afterward two blocks are equivalent:

     var iter:List Iterator<item-type> := list.get-begin()

     while(not iter other-iter.node

     end method

     end type

    Lets address the Vectors iterator first. It will create the Vectors accomplishing clearer.

     blazon Agent Iterator

     data array:Array

     data index:Integer

     constructor(my_array:Array, my_index:Integer)

     arrangement := my_array

     basis := my_index

     end constructor

     adjustment get-value():item-type

     acknowledgment array.get-element(index)

     end method

     adjustment set-value(new-value:item-type)

     array.set-element(index, new-value)

     end method

     adjustment move-next()

     basis := index+1

     end method

     adjustment equal(other-iter:List Iterator):Boolean

     acknowledgment arrayother-iter.index

     end method

     end type

    We apparatus the Agent in agreement of the archaic Arrangement data type. It is inefficient to consistently accumulate the arrangement absolutely the appropriate admeasurement (think of how abundant resizing youd accept to do), so we abundance both a size, the amount of analytic elements in the Vector, and a capacity, the amount of spaces in the array. The arrays accurate indices will consistently ambit from 0 to capacity-1.

     blazon Vector

     data array:Array

     data size:Integer

     data capacity:Integer

    We initialize the agent with a accommodation of 10. Allotment 10 was adequately arbitrary. If wed capital to create it arise beneath arbitrary, we would accept called a ability of 2, and innocent readers like you would accept that there was some deep, binary-related cause for the choice.

     constructor()

     arrangement := create-array(0, 9)

     admeasurement := 0

     accommodation := 10

     end constructor

     adjustment get-begin():Vector Iterator

     acknowledgment new Vector-Iterator(array, 0)

     end method

    The end iterator has an basis of size. Thats one added than the accomplished accurate index.

     adjustment get-end():List Iterator

     acknowledgment new Vector-Iterator(array, size)

     end method

    Well use this adjustment to advice us apparatus the admittance routines. Afterwards it is called, the capacity of the arrangement is affirmed to be at atomic new-capacity. A aboveboard accomplishing would artlessly admeasure a new arrangement with absolutely new-capacity elements and archetype the old arrangement over. To see why this is inefficient, anticipate what would appear if we started appending elements in a loop. Already we exceeded the aboriginal capacity, anniversary new aspect would crave us to archetype the absolute array. Thats why this accomplishing at atomic doubles the admeasurement of the basal arrangement any time it needs to grow.

     abettor adjustment ensure-capacity(new-capacity:Integer)

    If the accepted accommodation is already big enough, acknowledgment quickly.

     if accommodation >= new-capacity

     return

     end if

    Now, acquisition the new accommodation able-bodied need,

     var allocated-capacity:Integer := max(capacity var new-array:Array := create-array(0, allocated-capacity - 1)

    copy over the old array,

     for i in 0..size-1

     new-array.set-element(i, array.get-element(i))

     end for

    and amend the Vectors state.

     arrangement := new-array

     accommodation := allocated-capacity

     end method

    This adjustment uses a normally-illegal iterator, which refers to the account one afore the alpha of the Vector, to ambush insert-after() into accomplishing the appropriate thing. By accomplishing this, we abstain accompanying code.

     adjustment prepend(new-item:item-type)

     insert-after(new Vector-Iterator(array, -1), new-item)

     end method

    insert-after() needs to archetype all of the elements amid iter and the end of the Vector. This agency that in general, it runs in $O(N)$ time. However, in the appropriate case area iter refers to the endure aspect in the vector, we dont charge to archetype any elements to create allowance for the new one. An adjoin operation can run in $O(1)$ time, additional the time bare for the ensure-capacity() call. ensure-capacity() will sometimes charge to archetype the accomplished array, which takes $O(N)$ time. But abundant added often, it doesnt charge to do annihilation at all.

    

    Amortized Analysis


    In fact, if you anticipate of a alternation of adjoin operations starting anon afterwards ensure-capacity() increases the Vectors accommodation (call the accommodation actuality $C$, and catastrophe anon afterwards the next access in capacity, you can see that there will be absolutely $frac=O(C)$ appends. At the after access in capacity, it will charge to archetype $C$ elements over to the new array. So this absolute arrangement of $frac$ action calls took $frac=O(C)$ operations. We alarm this situation, area there are $O(N)$ operations for $O(N)$ action calls amortized $O(1)$ time.

    

     adjustment insert-after(iter:Vector Iterator, new-item:item-type)

     ensure-capacity(size+1)

    This bend copies all of the elements in the agent into the atom one basis up. We bend backwards in adjustment to create allowance for anniversary alternating aspect just afore we archetype it.

     for i in size-1 .. iter.index+1 move -1

     array.set-element(i+1, array.get-element(i))

     end for

    Now that there is an abandoned amplitude in the average of the array, we can put the new aspect there.

     array.set-element(iter.index+1, new-item)

    And amend the Vectors size.

     admeasurement := size+1

     end method

    Again, cheats a little bit to abstain alike code.

     adjustment remove-first()

     remove-after(new Vector-Iterator(array, -1))

     end method

    Like insert-after(), remove-after needs to archetype all of the elements amid iter and the end of the Vector. So in general, it runs in $O(N)$ time. But in the appropriate case area iter refers to the endure aspect in the vector, we can artlessly cutback the Vectors size, after artful any elements. A remove-last operation runs in $O(1)$ time.

     adjustment remove-after(iter:List Iterator)

     for i in iter.index+1 .. size-2

     array.set-element(i, array.get-element(i+1))

     end for

     admeasurement := size-1

     end method

    This adjustment has a absence implementation, but were already autumn the size, so we can apparatus it in $O(1)$ time, rather than the defaults $O(N).$

     adjustment get-size():Integer

     acknowledgment size

     end method

    Because an arrangement allows constant-time admission to elements, we can apparatus get- and set-nth() in $O(1)$, rather than the absence implementations $O(N)$

     adjustment get-nth(n:Integer):item-type

     acknowledgment array.get-element(n)

     end method

     adjustment set-nth(n:Integer, new-value:item-type)

     array.set-element(n, new-value)

     end method

     end type

     [TODO: This is actual terse. It should be fleshed out later.]

    Sometimes we wish to move astern in a account too.

    

    Bidirectional List ADT

    

    

get-begin():Bidirectional Account Iterator

    

Returns the account iterator (well ascertain this soon) that represents the first aspect of the list. Runs in $O(1)$ time.

    

get-end():Bidirectional Account Iterator

    

Returns the account iterator that represents one aspect accomplished the endure aspect in the list. Runs in $O(1)$ time.

    

insert(iter:Bidirectional Account Iterator, new-item:item-type)

    

Adds a new aspect anon afore iter. Runs in $O(N)$ time.

    

remove(iter:Bidirectional Account Iterator)

    

Removes the aspect anon referred to by iter. Afterwards this call, iter will accredit to the next aspect in the list. Runs in $O(N)$ time.

    

is-empty():Boolean

    

True iff there are no elements in the list. Has a absence implementation. Runs in $O(1)$ time.

    

get-size():Integer

    

Returns the amount of elements in the list. Has a absence implementation. Runs in $O(N)$ time.

    

get-nth(n:Integer):item-type

    

Returns the nth aspect in the list, counting from 0. Has a absence implementation. Runs in $O(N)$ time.

    

set-nth(n:Integer, new-value:item-type)

    

Assigns a new amount to the nth aspect in the list, counting from 0. Has a absence implementation. Runs in $O(N)$ time.

    

    

    

    Bidirectional Account Iterator ADT

    

    

get-value():item-type

    

Returns the amount of the account aspect that this iterator refers to. Amorphous if the iterator is past-the-end.

    

set-value(new-value:item-type)

    

Assigns a new amount to the account aspect that this iterator refers to. Amorphous if the iterator is past-the-end.

    

move-next()

    

Makes this iterator accredit to the next aspect in the list. Amorphous if the iterator is past-the-end.

    

move-previous()

    

Makes this iterator accredit to the antecedent aspect in the list. Amorphous if the iterator refers to the first account element.

    

equal(other-iter:List Iterator):Boolean

    

True iff the additional iterator refers to the aforementioned account aspect as this iterator.

    

    All operations run in $O(1)$ time.

    

    The agent weve already apparent has a altogether able accomplishing to be a Bidirectional List. All we charge to do is add the added affiliate functions to it and its iterator; the old ones dont accept to change.

     blazon Vector

     ... # already-existing data and methods

    Implement this in agreement of the aboriginal insert-after() method. Afterwards that runs, we accept to acclimatize iters basis so that it still refers to the aforementioned element.

     adjustment insert(iter:Bidirectional Account Iterator, new-item:item-type)

     insert-after(new Vector-Iterator(iter.array, iter.index-1))

     iter.move-next()

     end method

    Also apparatus this on in agreement of an old function. Afterwards remove-after() runs, the basis will already be correct.

     adjustment remove(iter:Bidirectional Account Iterator)

     remove-after(new Vector-Iterator(iter.array, iter.index-1))

     end method

     end type

    [TODO: Refactor advantageous advice from beneath into above]

     [TODO: afterward outline from allocution page:]

     Accepted account operations & example

     set(pos, val), get(pos), remove(pos), append(val)

     [Perhaps altercate operations on Nodes, against operations on the List

     itself: example, Nodes accept a next operation, but the Account itself has

     a arrow to the arch and appendage node, and an accumulation for the amount of

     elements. This appearance would plan able-bodied in both the Lisp and OO worlds.]

     Doubley affiliated list

     Vectors (resizeable arrays)

    In adjustment to accept the actual data anatomy for the job, we charge to accept some abstraction of what were traveling to

    We haveto bang a antithesis amid the assorted requirements.

    If we charge to frequently apprehend data out in 3 altered ways, aces a data anatomy that allows us to do all 3 things not-too-slowly. Dont aces some data anatomy thats unbearably apathetic for

    Often the shortest, simplest programming band-aid for some assignment will use a beeline (1D) array.

    If we accumulate our data as an ADT, that makes it easier to briefly about-face to some additional basal data structure, and considerately admeasurement whether its faster or slower.

    For the alotof part, an advantage of an arrangement is a disadvantage of a linked-list, and carnality versa.

    # Basis - Fast admission to every aspect in the arrangement using an basis [], not so with affiliated account area elements in alpha haveto be traversed to your adapted element.

    # Faster - In general, It is faster to admission an aspect in an arrangement than accessing an aspect in a linked-list.

    # Resize - Can calmly resize the link-list by abacus elements after affecting the majority of the additional elements in the link-list.

    # Admittance - Can calmly admit an aspect in the average of a linked-list, (the aspect is created and then you cipher pointers to hotlink this aspect to the additional element(s) in the link-list).

    Side-note: - How to admit an aspect in the average of an array.

    If an arrangement is not full, you yield all the elements afterwards the atom or basis in the arrangement you wish to insert, and move them advanced by 1, then admit your element.

    If the arrangement is already abounding and you wish to admit an element, you would accept to, in a sense, resize the array. A new arrangement would accept to be create one admeasurement beyond than the aboriginal arrangement to admit your element, then all the elements of the aboriginal arrangement are affected to the new arrangement demography into application the atom or basis to admit your element, then admit your element.

    ----