CS 310: HW 1: DynamicArray

Transcription

1 CS 310: HW 1: DynamicArray Chris Kauffman Fall 2016

2 Logistics Reading Weiss Ch 16: Stacks and Queues Weiss Ch 17: Linked Lists Goals Finish Discussion of Stacks and Queues Discuss HW1 s DynamicQueue Potentially start Linked Lists

3 Announcement: ACM + Programming Contest ACM student chapter is looking for new members Recruiting new programmers for the ICPC (ACM-ICPC International Collegiate Programming Contest) Webpage: Meeting Thursdays from 3 to 5 or 6 in ENGR 4201 New members meeting on the Thu 9/22 Other new members meetings: be October 13th and November 10th

4 HW 1 Is Up It s a good one: HW 1 Google Doc Implement a 1D array-based list: DynamicArray Similar to ArrayList: add(x), get(i), set(i,x), remove() methods Different speed/memory tradeoffs Slower get(i) / set(i,x) time but still O(1) Less wasted memory: O( N) for DynamicArray than O(N) for ArrayList Based on an academic paper by Brodnick et. al Takes some work for DynamicArray to keep O(1) access with O( N) memory overhead

5 Blocks and blocks and SuperBlocks DynamicArray appears to the outside as a 1D list Internally it has a 2D flavor Field arrayofblocks track an array of Blocks Each Block is itself an array, fixed size Blocks are grouped into SuperBlocks

6 Block Growth Each Block has a field arrayofelements[] which holds the actual elements of the DynamicArray As elements are da.add(x) to the DynamicArray, more blocks are created Later Blocks are larger than earlier blocks A SuperBlock is a group of Blocks each having the same size Block Block SB# Count Size SB0 1 1 SB1 1 2 SB2 2 2 SB3 2 4 SB4 4 4 SB5 4 8 SB6 8 8 Block# SB# Size

7 A Picture

8 add(x) in DynamicArray When adding, determine the "coordinates" of new last index If a block already exists with space available, tack on the the new element x If a block doesn t exist, create one of the appropriate size and add the new element May require the arrayofblocks[] to be reallocated if it is too small NEVER requires O(N) re-allocation Must carefully track the the lastsuperblock Demo adding: A, B, C, D, E, F, G, H, I, J, K...

9 remove() in DynamicArray Only removes the highest index element (last to be added) null-ify that element and adjust internals like the size of the DynamicArray Do not immediately nullify empty blocks in arrayofblocks Wait until there the last 2 blocks are empty, then remove only the last one Track lastsuperblock and adjust to smaller as elements are removed Occasionally shrink arrayofblocks[] when only 25% full Demo repeated calls to remove()

10 get(i) and set(i,x) Must determine the "coordinates" of index i Encoded in a Location Location = (block#,indexinblock) Several snaky operations are involved in this; examples in spec Useful Formulas Virtual index i Super Block #: sb = floor(log2 (i+1)) Position where sb starts in arrayofblocks sb even: sbstart = 2 * (2^floor(sb/2) - 1) sb odd: sbstart = 2 * (2^floor(sb/2) - 1) + 2^floor(sb/2) Element index in target block for i elementindexinblock = bits 0 to ceil(sb/2) of i Index of block containing i in sb blockindexinsb = bits ceil(sb/2) to (ceil(sb/2)+floor(sb/2)) of i

11 Example: Index 410, Location Welcome to DrJava > Integer.toString(410,2) " " > Integer.toString(410+1,2) " " > new Location(410) // Override tostring (8,9,11) // (SuperBlock#,B#InSuperblock,Elem#InBlock) > Math.floor( DynamicArray.log2( ) ) 8.0 // SuperBlock# is even bit index = bits ^^^ ^^^ leading zeros < leading blockindex in SB = 9 < elementindex in block = 11 <---+

12 Masks to extract portions of integers Bitwise operations result = x y; result = x & y; result = ~x; result = x << y; result = x >> y; result = x - y; // bitwise OR // bitwise AND // invert bits of x // shift x left by y bits // shift x right by y bits // normal subtraction // Create a mask of N 1 s in the low order bits protected int maskofn(int N) { return (1 << N)-1; // (1 << 5) = = 32 // (1 << 5)-1 = = 31 } Welcome to DrJava > Integer.toString( DynamicArray.maskOfN(4), 2) "1111" > Integer.toString( DynamicArray.maskOfN(8), 2) " "

13 Example Index 410: Find elementindex bit index = bits ^^^ elementindex in block = 11 <---+ > new Location(410) // Override tostring (8,9,11) // (SB#,RB#,E#) > 2 * (Math.pow(2, 8/2) - 1) // before SB8 starts 30.0 > Math.floor(8 / 2) 4.0 // Number of bits for block index in SB > Math.ceil(8 / 2) 4.0 // Number of bits for element index block > (410+1) & DynamicArray.maskOfN(4) 11 // // & // // elementindex = 11

14 Example Index 410: Find blockindex bit index = bits ^^^ blockindex in SB = 9 < > ((410+1) >> 4) & DynamicArray.maskOfN(4) // // >> 4 // // // & // // blockindex = 9 // // Have block index in superblock, figure out which // block# superblock starts at > Math.floor( DynamicArray.log2( ) ) 8.0 // SuperBlock# is even > 2 * (Math.pow(2, 8/2) - 1) // #blocks before SB8 starts 30.0 // SuperBlock 8 starts at index 30 of arrayofblocks > // Index of desired block in arrayofblocks

15 Additional Bitwise Tricks Bit tricks can yield fast results for certain mathematical operations. The following are useful for HW1 s locate(..) computations. int twotopowerp = 1 << p; // Raise 2 to power p int floorxover2 = x >> 1; // Quickly computer floor(x / 2) int ceilxover2 = (x+1) >> 1; // Quickly computer ceil(x / 2)

16 DynamicQueue "Simulate" a queue with two "stacks" The stacks are just DynamicArrays with add(x) as a push(x) operation and remove(size()-1) as the pop() operation DynamicArray handles all the expansion/removal ops on its own making DynamicQueue relatively easy q.enqueue(x) will put elements into the incoming q.dequeue() will remove elements from the outgoing stack Occasionally one must transfer elements from incoming to outgoing to facilitate a q.dequeue() operation Important: Do not rebuild DynamicArray, just use it. Being abstract is something profoundly different from being vague... The purpose of abstraction is not to be vague, but to create a new semantic level in which one can be absolutely precise. Edsger Dijsktra

17 A Queue from Two Stacks Empty DynamicQueue in and out are empty DynamicArrays Numbers show are virtual indices, shown in a "stacky" order size: Enqueue 3 Elems q.enqueue(a); q.enqueue(b); q.enqueue(c); Incoming elements are added to in array size: C 2 1 B 1 0 A 0

18 Transferring Between in and out First call to dequeue() out is empty but in has elements Transfer all elements from in to out in reverse order Equivalent to repeated out.push(in.pop()) A is now top element of out so is removed and returned Note that transferring from in to out is expensive but happens infrequently > q.enqueue(a); q.enqueue(b); q.enqueue(c); size: 3 2 C 2 1 B 1 0 A 0 > result = q.dequeue(); // Transfer elements from in to out size: A 1 1 B 0 0 C // remove top element in out and return size: B 0 0 C > result == A

19 Further Demo Ops q.enqueue(x) adds to in q.dequeue(x) takes from out > q size: B 0 0 C > q.enqueue(d) size: B 0 D 0 C > q.enqueue(e) size: 4 1 E 1 B 0 D 0 C > q size: 4 1 E 1 B 0 D 0 C > result = q.dequeue() // B size: 3 1 E 1 0 D 0 C > result = q.dequeue() // C size: 2 1 E 1 0 D 0 Next q.dequeue() would trigger a transfer from in to out

20 Mixed Ops First > q size: 2 1 E 1 0 D 0 > q.enqueue(f) size: 3 2 F 2 1 E 1 0 D 0 > result = q.dequeue() // D size: E 0 0 F Then > q.enqueue(g); q.enqueue(h); size: 4 1 H 1 E 0 G 0 F > result = q.dequeue(); // E size: 3 1 H 1 0 G 0 F > q.enqueue(i); size: 4 2 I 2 1 H 1 0 G 0 F