1 / 67

Linear Linked Structures

Linear Linked Structures. 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

elke
Télécharger la présentation

Linear Linked Structures

An Image/Link below is provided (as is) to download presentation Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript


  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

  4. 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

  5. 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

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

  7. 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

  8. 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)

  9. 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

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

  11. 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)

  12. 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)

  13. 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)

  14. 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)

  15. 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

  16. 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

  17. 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

More Related