Linear Linked Structures

1. Linear Linked Structures

2. Dynamic Structures • collections • limitations of static structures (i.e. arrays) • fixed size • waste space • rearrangement of entries • dynamic data structures • change size over time • storage proportional to amount of information • linked structures • nodes (objects) connected together by references • dynamic allocation/deallocation • in array proximity implicit, in linked structure it is explicit • linear linked structures • aka linked lists

3. Sequentially-linked Structures • each node indicates its successor (via a reference) • first node located via reference • last node has no successor (null) • each node represents one entity • empty collection has null reference

5. Representation • dynamic creation • nodes are objects • let entity objects be nodes? • add reference field • disadvantages • object must “know” it is on list • multiple lists • must modify class

7. Node Wrapper Class • separate class that references entities • wrapper class, mixin, decorator (GoF) • fields • reference (p.theStudent) • link (p.next) • constructor • visibility • class • fields • as sequentially-linked structure • general case • initial (empty) state • multiple lists • different sequence of Nodes, same entity objects

11. Operations • insertion • where? • deletion • which node? • traversal • “visit” all nodes • like array traversal • search • special traversal • simple vs exhaustive

12. Insertion • insert where? • front • end • in some order (e.g. sorted) • at front • new entry points to previous front • list reference points to new entry • algorithm • O(1) • repeated application • reverse order

15. Deletion • delete which node? • first • last • matching a key • only if not empty • delete first • move list pointer to second node • garbage collection • node • entity • algorithm • O(1)

18. Traversal • sequential processing • to get to nth node must first get to (n-1)st node • travelling pointer • start at first node • move to node's successor • p = p.next • termination • no more nodes (p == null) • algorithm • O(n) • vs array traversal • sequential traversal pattern

23. Search • sequential structure • sequential search • variant of traversal • two exit conditions • found • not found • algorithm • O(n)

26. Insertion at End of List • for insertion in order • find end of list • traversal • 2 travelling pointers • initial state • q is predecessor of p • insert • algorithm • traverse • updating p & q • insert • 2 cases • q == null (empty list) • q != null (at end) • O(n)

29. Deletion of Last Node • must modify second last node • find second last node • traversal • 2 travelling pointers • test • algorithm • pre test • error • traverse • delete • 2 cases • q == null (only node) • q != null (last node) • O(n)

32. Insertion in Sorted Order • insert between 2 nodes • criteria • find insertion point • search • 2 travelling pointers • insert between p & q • combination of termination conditions (order) • algorithm • search • first entity with greater key • termination on found or end of list • insert • 2 cases • q == null (front of list or empty list) • q != null (after q) • O(n)

35. Deletion of Node by Key • criterion • match key • find deletion point • search • 2 travelling pointers • termination and subsequent test • exception • algorithm • search • delete if found • 2 cases • q == null (delete first node) • q != null (delete q’s successor) • O(n)

38. Insertion at End with Tail reference • O(n) since must find end • remember where end is then O(1) • pair of pointers (head, tail) • must be sure to update both appropriately • insertion at end • empty list insertion • deletion at front • last node deletion • performance • extra cost is O(1) • deletion of last in O(1)? • not possible

46. Symmetrically-linked Structures • each node points to successor and predecessor • traversal in both directions • arbitrary insertion/deletion • extra work in insertion and deletion (extra pointers) • e.g. sorted insertion • e.g. keyed deletion

50. Circular Linked Structures • sequentially-linked or symmetrically-linked • last node points back to first • single node • traversal from any point • treating each node as head in turn • potential infinite loop in traversal