1. Linked List Containers

2. Useful Linked List Add-Ons Are there new variables/changes to the lists as they have been defined that could make our jobs as programmers easier? Are there new variables/changes to the lists as they have been defined that could make our jobs as programmers easier? Size member variable Size member variable Be able to determine current size of list, bound positions for add, delete, etc. Be able to determine current size of list, bound positions for add, delete, etc. Maintaining a variable is cheap, counting the nodes every time size is called (the alternative) is not! Maintaining a variable is cheap, counting the nodes every time size is called (the alternative) is not! Tail pointer Tail pointer Significantly simplifies addition at end of list Significantly simplifies addition at end of list

3. Tail Pointers If doing a lot of adds to the end (which is natural), a tail pointer provides instant access to the last node If doing a lot of adds to the end (which is natural), a tail pointer provides instant access to the last node Does require some extra overhead in the add/delete functions to keep tail updated Does require some extra overhead in the add/delete functions to keep tail updated List Construction: first=tail=0; 1-node: first != 0 and first == tail List Construction: first=tail=0; 1-node: first != 0 and first == tail List1 Data1List1 Data2List1 Data3 tailfirst

4. Circular Lists Another improvement on LinkedLists: Another improvement on LinkedLists: Use link pointer of last node to point to the first node. Use link pointer of last node to point to the first node. Changes to implementation: Changes to implementation: Check to see if at last node: Check to see if at last node: test “if (current -> link == first)” instead of “if (current->link == 0)” Insertion and deletion need to preserve property that last nodes link is always set equal to first Insertion and deletion need to preserve property that last nodes link is always set equal to first

5. Circular List Implementation Retrofitting our LinkedList to make circular: Don’t want to have just a head pointer: Why? Don’t want to have just a head pointer: Why? If inserting at tail, have to traverse the whole list from head to get to tail to update the tails link If inserting at tail, have to traverse the whole list from head to get to tail to update the tails link If inserting at head, need to find last node to point its link to new head - this also traverses the whole list If inserting at head, need to find last node to point its link to new head - this also traverses the whole list Circular linked lists are much more efficient if use tail (last) pointer as the pointer for the list. Circular linked lists are much more efficient if use tail (last) pointer as the pointer for the list. Two pointers (head and tail) are actually overkill.. why? Two pointers (head and tail) are actually overkill.. why?

6. Circular Linked Lists List1 Data1List1 Data2List1 Data3 tailfirst Can access head via tail->link in one step so don’t need head pointer

7. Circular Linked List void insertAtFront(ListNode *x) { if (tail == 0) { // empty list, tail = x; x-> link = x; // point to yourself }else{ x->link = tail->link; // point new head link to old head tail->link = x; // point tail to new head }} insertAtRear() only requires adding tail = x in the else statement (to update rear to new node)

8. Linked List Examples Now that the basic structures of LinkedLists have been defined, what are some potential applications? Now that the basic structures of LinkedLists have been defined, what are some potential applications? Target problems where can take advantage of LinkedList memory usage model Target problems where can take advantage of LinkedList memory usage model Target problems where can take advantage of dynamic aspects of LinkedList Target problems where can take advantage of dynamic aspects of LinkedList

9. Linked List Example Polynomials Polynomials Interested in representing and manipulating polynomials Interested in representing and manipulating polynomials Polynomial defined as: Polynomial defined as: Y = coef_n * x exp_n + coef_n-1 * x exp_n-1 + … coef_0 * x 0 Y = coef_n * x exp_n + coef_n-1 * x exp_n-1 + … coef_0 * x 0 Examples: Examples: 3x 14 + 2x 8 + 1 8x 14 – 3x 10 + 10x 6

10. Polynomials Has a very nice linked representation Has a very nice linked representation In particular, able to take advantage of sparse number of coefficients with a linked representation In particular, able to take advantage of sparse number of coefficients with a linked representation Compare against an array that holds the coefficients and exponents for all possible indices from 0 to max degree Compare against an array that holds the coefficients and exponents for all possible indices from 0 to max degree Horribly wasteful in terms of space Horribly wasteful in terms of space What if we had an array of Term objects, where a Term was an exponent/coefficient What if we had an array of Term objects, where a Term was an exponent/coefficient Only need enough array space to hold true terms, so amount of space required ok.. However, we’ll see this is still inflexible. Only need enough array space to hold true terms, so amount of space required ok.. However, we’ll see this is still inflexible.

11. Polynomials For each component of the polynomial, need to store coefficient and exponent For each component of the polynomial, need to store coefficient and exponent struct Term { int coef; int exp; void Init(int c, int e) { coef = c; exp = e;} };

12. Polynomials Polynomial itself implemented by a templated LinkedList of Terms Polynomial itself implemented by a templated LinkedList of Terms class Polynomial {private: LinkedList poly; };

13. Polynomials Adding Polynomials: Adding Polynomials: 3x 3 + 2x + 1 + 2x 3 + 3x 2 + 5 2x 3 + 3x 2 + 5================= 5x 3 + 3x 2 + 2x + 6 5x 3 + 3x 2 + 2x + 6

14. Polynomials Adding Polynomials: Adding Polynomials: Iterate through both lists Iterate through both lists If exponent1 == exponent2, If exponent1 == exponent2, CoefficientSum = Coefficient1 + Coefficient2 CoefficientSum = Coefficient1 + Coefficient2 If CoefficentSum != 0, add term to new polynomial representing answer If CoefficentSum != 0, add term to new polynomial representing answer Else, Else, Find higher exponent Find higher exponent Add term to new polynomial representing answer Add term to new polynomial representing answer

15. Polynomials 3 2 11 02 33 25 05 33 22 16 0

16. Polynomials The “Answer” polynomial is where LinkedLists have another win. There is now way beforehand to know how may terms there will be in the answer polynomial The “Answer” polynomial is where LinkedLists have another win. There is now way beforehand to know how may terms there will be in the answer polynomial Number of terms is anywhere from (the size of the largest list) to the size of the largest list plus the size of the smallest list) Number of terms is anywhere from (the size of the largest list) to the size of the largest list plus the size of the smallest list) With an array representation, would have to overallocate to handle large answers With an array representation, would have to overallocate to handle large answers With LinkedLists, just grab a new Node when need it. With LinkedLists, just grab a new Node when need it.

17. Polynomials Overload + operator to perform polynomial addition Overload + operator to perform polynomial addition Implementation in page 193 Implementation in page 193

18. Example: Equivalence Classes Another Example of Linked List Usage: Another Example of Linked List Usage: Finding Equivalence Classes Definition: Definition: Given a relation (, ==, …), the relation is an equivalence relation over a set S if the relation is reflexive, symmetric, and transitive over S

19. Equivalence Relations Reflexive Reflexive A ? A Is < Reflexive? A < A No Is = Reflexive?A == AYes Symmetric: Symmetric: If A ? B, then B ? A If A ? B, then B ? A Is < Symmetric? A < B, then B < A No Is = Symmetric? A = B, then B = A Yes

20. Equivalence Relations Transitive Transitive If A ? B and B ? C, then A ? C If A ? B and B ? C, then A ? C Is < transitive?A < B, B < C, A < C Yes Is < transitive?A < B, B < C, A < C Yes Is = transitive?A = B, B = C, A = C Yes Is = transitive?A = B, B = C, A = C Yes = is reflexive, symmetric, and transitive, so it is an equivalence relation < fails on reflexive and symmetric, so it is not an equivalence relation

21. Equivalence Classes Effect of equivalence relations is the ability to partition a set S into classes such that any two members of S, x and y, are in the same class if x equiv y. Effect of equivalence relations is the ability to partition a set S into classes such that any two members of S, x and y, are in the same class if x equiv y. Classes are called equivalence classes Classes are called equivalence classes

22. Equivalence Classes Equivalence Class Example: Let our relationship be = mod 3 Reflexive 5 mod 3 = 5 mod 3 => 2 = 2 Yes Symmetric 5 mod 3 = 8 mod 3, then 8 mod 3 = 5 mod 3 2 = 2, then 2 = 2 Yes Transitive 5 mod 3 = 8 mod 3, 8 mod 3 = 14 mod 3, then 5 mod 3 = 14 mod 3 2 = 2, 2 = 2, then 2 = 2, Yes

23. Equivalence Classes Equivalence Classes: Equivalence Classes: All numbers that are = mod 3 are in the same equivalence class All numbers that are = mod 3 are in the same equivalence class Mod 3 = 0Mod 3 = 1Mod 3 = 2 {0,3,6,9,…}{1,4,7,10,…} {2,5,8,11,…}

24. Equivalence Classes Goal: Goal: Given a list of equivalence relations between items x and y, construct the equivalence classes Given a list of equivalence relations between items x and y, construct the equivalence classes Relations: 0 = 4, 3 = 1, 6 = 10, 8 = 9, 7 = 4, 6 = 8, 3 = 5, 2= 11, 11 = 0 Relations: 0 = 4, 3 = 1, 6 = 10, 8 = 9, 7 = 4, 6 = 8, 3 = 5, 2= 11, 11 = 0 Classes: {0,2,4,7,11}, {1,3,5,}, {6,8,9,10} Classes: {0,2,4,7,11}, {1,3,5,}, {6,8,9,10}

25. Equivalence Classes Could build N by N (N = number of total items) matrix indicating relationship, but most of entries are likely to be zero Could build N by N (N = number of total items) matrix indicating relationship, but most of entries are likely to be zero Instead, use an array of pointers for 1-dimensional list of all items, where for each item, the pointer points to a list of all items that are equivalent in the input Instead, use an array of pointers for 1-dimensional list of all items, where for each item, the pointer points to a list of all items that are equivalent in the input For each item I = J input, For each item I = J input, Add J to I’s list Add I to J’s list

26. Equivalence Classes 12345678910110 43 571038468601092

27. Equivalence Classes To find equivalence classes, To find equivalence classes, Start at front of array Start at front of array Print X, Mark as printed Print X, Mark as printed Print all things equivalent to X (follow its list), mark as printed Print all things equivalent to X (follow its list), mark as printed For each thing equivalent to X, print the appropriate list For each thing equivalent to X, print the appropriate list

28. Equivalence Classes Include an array to indicate whether that data has already been written: Include an array to indicate whether that data has already been written: boolean out[n] initially all set to false Code on pages 205, 206 of book Code on pages 205, 206 of book

29. Equivalence Classes First Steps of Test Run on Previous Data First Steps of Test Run on Previous Data OutputStack Out Array FFFFFFFFFFFF NC: 0 TFFFFFFFFFFF NC: 0,11 Top->11TFFFFFFFFFFT NC: 0,11,4 Top->4,11TFFFTFFFFFFT NC: 0,11,4,7 Top->7,11TFFFTFFTFFFT

30. Complexity of Equivalence Class Operations Initialization Initialization Initializing sequence and output arrays with n possible values: O(n) Processing each pair of input – 2 steps * m inputs: O(m) So, pre-processing requires: O(n+m) Traversing list: Traversing list: n possible lists to look at, 2m entries total on the lists Only process list if haven’t already written So only looks at each entry in the array once (upper bound of n) Since only looks at each array once, only looks at nodes underneath the array entry once (upper bound of 2m) So traverse time is O(n+m)

31. Doubly Linked Lists Biggest problem with linked lists as we’ve used so far: Biggest problem with linked lists as we’ve used so far: Can only navigate in one direction Can only navigate in one direction Requires traversals from front to a position, even if currently located right behind where want to be Requires traversals from front to a position, even if currently located right behind where want to be Requires “trailing pointer” if want to easily get access to previous node for current node Requires “trailing pointer” if want to easily get access to previous node for current node When update current to current->next, update prev to current When update current to current->next, update prev to current

32. Doubly Linked Lists Work around these issues by storing both the left and right side neighbors of a linked list Work around these issues by storing both the left and right side neighbors of a linked list Makes add, delete, and other array manipulation operators more complicated as have to preserve doubly linked property Makes add, delete, and other array manipulation operators more complicated as have to preserve doubly linked property

33. Doubly Linked Lists Definition: Definition: class DblList; // forward declaration class DblListNode { friend class DblList; private: int data; DblListNode *right, *left; };

34. Doubly Linked Lists class DblList {public: // list manipulation private: DblListNode* first; DblListNode* first;};

35. Doubly Linked Lists LEFTDATARIGHTLEFT10RIGHTLEFT15RIGHTLEFT29RIGHT Example Node 3 Node Circular Doubly Linked List

36. Note that, given a pointer p, Note that, given a pointer p, p = p->left->right = p->right->left Going back and forth is equally easy. Going back and forth is equally easy.

37. Doubly Linked List void DblList::Insert(DblListNode *new, DblListNode *current) { // insert new after x new->left = current; new->right = current->right; current->right->left = new; current->right = new; } 10L current R12L R R11L new

38. Doubly Linked List void DblList::Delete(DblListNode *toDelete) { // delete node pointed to by toDelete toDelete->left->right = toDelete->right; toDelete->right->left = toDelete->left; delete toDelete; } 10LR12LR11L toDelete