4. Linked Lists

Why they’re cool ArrayLists: LinkedLists (just the reverse) +: Infrastructure is already there (arrays) -: performance hit when capacity is reached (resize op) +: Lean memory usage: Array itself: 4/8 bytes per slot (a reference [32-bit = 4bytes, 64-bit = 8 bytes]) The actual data we’re storing Other items: A used-count (4 bytes) (static) capacity-increase amount (4 bytes) -: Require contiguous memory for the array. LinkedLists (just the reverse) We’ll explore the memory usage shortly.

Review: Nested Classes public class Outer { protected class Inner } Inner mSampleInst; A class within a class! We actually saw it with ArrayList.ArrayListItearator Why? Data Hiding (note the protected) The user of Outer need not even know about Inner! Encapsulation Data Hiding. Also implies we only need worry about it in Outer. Most LinkedList implementations have a hidden Node class. Contains the data… …and references to the neighboring Nodes.

Code View: Basic Structure class LinkedList<E> { protected class Node E mData; // Note how the generic was “inherited” Node mNext;// Reference to the following node // (or null if there is none) Node mPrev;// Similar for preceding. This makes // our Llist a doubly-linked list. } protected Node mStart; // Sometimes called the head protected Node mEnd; // Sometimes called the tail protected int mSize; // Number of nodes public void add(E new_val) { … } public void remove(E val) { … } // additional top-level methods. LinkedList<String> LL = new LinkedList<String>(); LL.addLast(“Sue”); LL.addLast(“Bob”); LL.addLast(“Tom”);

Logical View Empty List List with 3 elements mStart: (null) mEnd: mSize: 0 mStart: mEnd: mSize: 3 mData: “Bob” mNext: mPrev: mData: “Sue” mData: “Tom”

Memory View Stack Heap “Sue”’s node “Tom”’s node “Bob”’s node addr var contents Notes LL 40000 (in main program) … 50000 mStart field of list pointed to by LL 40004 55000 mEnd field of llist pointed to by LL 40008 3 mSize field llist pointed to by LL 72000 mData field 50004 60000 mNext field 50008 0 (null) mPrev field 71000 55004 55008 70000 60004 60008 “Bob” mData of Bob-node “Tom” mData of Tom-node “Sue” mData of Sue-node Memory View Stack Heap “Sue”’s node “Tom”’s node “Bob”’s node Note how the nodes are not in contiguous order (nor in the order they were allocated)! Also note the mData field is also a reference to data elsewhere on the heap!

Iteration Not an iterator (yet) A way to “visit” each node in a linked-list Used in most operations (internally!) Forward-iteration Backwards-iteration (doubly-linked lists only) You figure it out! Node cur = mStart; while (cur != null) { // Do something to cur.mData // (and / or mNext, mPrev) // Advance iteration cur = cur.mNext; }

Major methods java.util.linkedList void addFirst(E val); // (to end) void addLast(E val); void add(int index, E val); // insert at that pos. // 0: same as addFirst // size: same as addLast void clear(); int indexOf(E val); // -1 if not found. E get(int index); void remove(int index); // make both get and remove use a protected // method called getNodeByPosition(int index). int size(); Object[] toArray(); String toString(); // I want “<[first][second]…>” // or “<empty>” Iterator<E> iterator();

Freebie: Add (at index) void add(int index, E val); First: determine all cases case1: list is empty => call addFirst case2: list is non-empty and index = 0 => call addFirst case3: list is non-empty and index = size => call addLast case4: list is non-empty and 0 < index < size => work! case5: invalid index – raise an Exception Algorithm (for case4): Allocate a new node (disconnected) Iterate until cur is equal to index-1 Re-route references (see logical view, next slide) Add one to size Victory!

Add @ Index, cont. Logical view new_node: mData: <whatev> mNext: mPrev: … cur: mData: <whatev> mNext: mPrev: after traversal: cur is at index

code Implementation // Note: this is in the LinkedList class (but outside // the nested Node class) void add(int index, E val) throws IndexOutOfBoundesException { if (position < 0 || position > mSize) // Covers case 5 -- fast-fail! throw new IndexOutOfBoundsException("Invalid index: " + position); if (position == 0 || mSize == 0) addFirst(value); // Covers case 1 & 2 else if (position == mSize) addLast(value); // Covers case 3 else // Everything else falls under case 4 -- we're somewhere in the // middle (continued on next slide)

code Implementation, cont. // ... Create the new node (this is done in addFirst and addLast too... Node node_node = new Node(value); // ... traverse to the correct spot (so cur is at desired location) Node cur = mStart; int curPos = 0; while (curPos != position && cur != null) { cur = cur.mNext; curPos++; } // ... re-route the pointers node_node.mNext = cur; node_node.mPrev = cur.mPrev; cur.mPrev.mNext = node_node; cur.mPrev = node_node; // We now have one more node. Note: I put it in the else b/c // addFirst and addLast do it themselves – we don't want to do it twice! mSize++; } // end of else from last slide } // end of add function body

Lab 4 Make test program together You finish implementing the methods Like we did in Lab3 Ask questions – I’m more forthcoming in labs like this!