Linked Lists list elements are stored, in memory, in an arbitrary order explicit information (called a link) is used to go from one element to the next

Memory Layout abcdecaedb A linked representation uses an arbitrary layout. Layout of L = (a,b,c,d,e) using an array representation.

Linked Representation pointer (or link) in e is NULL caedb use a variable first to get to the first element a first

Normal Way To Draw A Linked List link or pointer field of node data field of node abcde NULL first

Chain A chain is a linked list in which each node represents one element. There is a link or pointer from one element to the next. The last node has a NULL (or 0) pointer. abcde NULL first

Node Representation class Node { private: char data; Node *link; }; link data

Get(0) Node* p; p = first; // gets you to first node return p  data; abcde NULL first

Get(1) Node* p; p = first  link; // gets you to second node return p  data; abcde NULL first

Get(2) Node* p; p = first  link  link; // gets you to third node return p  data; abcde NULL first

Get(n) Node* p=first; int count=0; while (count<n) { if (p==NULL) return; p=p->link; count++; } return p->data;

Delete An Element Delete(0) abcde NULL first Node* deleteNode; deleteNode = first; first = first  link; delete deleteNode;

abde NULL first c Delete(2) first get to node just before node to be removed c c beforeNode = first  link ; b beforeNode

Delete(2) save pointer to node that will be deleted deleteNode = beforeNode  link; beforeNode abcde null first

Delete(2) now change pointer in beforeNode beforeNode  link = deleteNode  link; delete deleteNode; beforeNode abcde null first

How about delete the nth element?

Delete An Element void Delete(int theIndex) { if (first == NULL) throw “Cannot delete from empty chain”; Node* deleteNode; if (theIndex == 0) {// remove first node from chain deleteNode = first; first = first->link; }

Delete An Element else { // use p to get to beforeNode Node* p = first; for (int i = 0; i < theIndex - 1; i++) {if (p == NULL) throw “Delete element does not exist”; p = p->next;} deleteNode = p->link; p->link = p->link->link; } delete deleteNode; }

Insert(0,’f’) abcde NULL first f p Step 1: get a node, set its data and link fields p = new Node; p->data=f; p->link=first;

Insert(0,’f’) abcde NULL first f p Step 2: update first first = p;

Insert(3,’f’) first find node whose index is 2 abcde NULL first f newNode beforeNode c next create a node and set its data and link fields newNode = new Node; newNode->data=‘f’; newNode->link=beforeNode->link; finally link beforeNode to newNode beforeNode  link = newNode;

Insert An Element void Insert(int theIndex,char data) { if (theIndex < 0) throw “Bad insert index”; Node *newnode = new Node; newnode->data=data; if (theIndex == 0) // insert at front { newnode->link=first; first = newnode; }

Inserting An Element else { // find predecessor of new element Node* p = first; for (int i = 0; i < theIndex - 1; i++) {if (p == 0) throw “Bad insert index”; p = p->next;} // insert after p newnode->link=p->link; p->link = newnode; }

Linked List Variations (1) “Single Linked List” There exists several Linked List Variations: –With or without Tail Pointer? –One link or double links per node? –Circular or not? –And combinations of these… Node 1Node 2 Node... Node N Head

Linked List Variations (2) Single Linked List with dummy head node –Pro: Simplify Single Linked List code –Cons: Same as standard Single Linked List DummyNode 1 Node... Node N Head

Linked List Variations (3) Single Linked List with Tail Pointer –Other than head, we also have tail pointer pointing to the last item –Pro: Can visit the tail very fast or add new item from tail –Cons: Slow to delete the tail…  Node 1Node 2 Node... Node N HeadTail

Linked List Variations (4) Circular Single Linked List –Tail->link = Head, the link cycles back to the head –Pro: Can visit all nodes from any node, good for Round Robin stuffs –Can choose to remember Tail only… –Cons: Slow to delete the tail…  Node 1Node 2 Node... Node N Head Node 1Node 2 Node... Node N Tail

Linked List Variations (5) Double Linked List –Two pointers per node: forward/backward –Pro: Can go backwards –Pro: If you have tail pointer, you can also delete tail efficiently! –Cons: Extra pointer is an overhead…  –Can be circular or not…, with or without tail… abcde NULL firstNode NULL lastNode

Double linked list The difficulties of using a singly linked list –The search of the list is limited to single direction. The only way to the preceding node is to start at the beginning. The same problem arises when one wishes to delete an arbitrary node from the list. Doubly linked list –A node in a doubly linked list has at least two fields left (left link): link to the preceding node right (right link): link to the following node

Representation class DbListNode { friend class DbList; public: DbListNode(int d=0, DbListNode *llink=0, DbListNode *rlink=0) { data = d; left = llink; right = rlink; }; private: int data; DbListNode *left, *right; }; class DbList { private: DbListNode *first, *last; }; leftrightleftrightleftright0 left0 first last dummy

Construction and Destruction DbList::DbList() { first = new DbListNode(); last = new DbListNode(); first->right = last; first->left = NULL; last->left = first; last->right = NULL; } DbList::~DbList() { while (first != NULL) { DbListNode *temp = first->right; delete first; first = temp; }

Inserting a Node into an Ordered List Suppose the list is sorted in non-decreasing order. void DbList::Insertion(int d) { DbListNode *temp = first->right; while (temp != last) { if (temp->data >= d) break; temp = temp->right; } DbListNode *newNode = new DbListNode(d, temp->left, temp); temp->left->right = newNode; temp->left = newNode; } leftright 1 leftright 2 leftright 3 temp temp->left newNode

Deleting a Node from an Ordered List bool DbList::Deletion(int d) { DbListNode *temp = first->right; while (temp != last) { if (temp->data == d) { temp->left->right = temp->right; temp->right->left = temp->left; delete temp; return true; } temp = temp->right; } return false; } leftright 1 leftright 2 leftright 3 temp->righttemp->lefttemp

Behavior: Last In First Out (LIFO) Stack implemented using Array with top pointer (Perhaps) the best implementation? –Using Single Link List with head pointer only – Stack Node 1Node 2 Node... Node N Head ADT Stack using SLL as underlying data structure Node 1 Node 2 Node... Node N Head is Top of Stack Node 0 Top: efficient Push: efficient Pop: efficient

Behavior: First In First Out (FIFO) Queue implemented using Circular Array Better: use Single Linked List with Tail Pointer –Head pointer (front) for delete, Tail pointer (rear) for insert We set these roles because pointer directions in SLL (arrows to the right) imply that only insertion is efficient at tail (thus only ok for enqueue) and both insertion/deletion are efficient at head (but since we already use tail for enqueue, head is for dequeue) –Or use Circular Single Linked List: save 1 pointer: Head = Tail.next ADT Queue using SLL with tail pointer as underlying data structure, circular SLL also ok Queue Node 1Node 2 Node... Node N Head Front of Queue Tail = Rear of Queue Node N+1 rear: efficient insert: efficient Front: efficient delete: efficient

Equivalence Classes Implementation

Introduction Definition of equivalence relation: –A relation ≡ over a set S, is said to be an equivalence relation over S iff it is reflexive, symmetric, and transitive over S. Example: the “equal to” (=) relationship is an equivalence relation, since 1.x = x. 2.x = y implies y = x. 3.x = y and y = z implies x = z.

Equivalence Class Problem To partition the set S into equivalence classes such that two members x and y of S are in the same equivalence class iff x ≡ y. Example: 0 ≡ 4, 3 ≡ 1, 6 ≡ 10, 8 ≡ 9, 7 ≡ 4, 6 ≡ 8, 3 ≡ 5, 2 ≡ 11, and 11 ≡ 0. Then, we get the following equivalence classes: {0, 2, 4, 7, 11}; {1, 3, 5}; {6, 8, 9, 10}

Idea Phase 1 –The equivalence pairs (i, j) are read in and stored. Phase 2 –Begin at 0 and find all pairs of (0, j). If 0 and j are in the same class, include k if any (j, k) exists. –Because, i ≡ j and j ≡ k implies i ≡ k (transitivity). –Continue in this way until the entire equivalence class containing 0 has been found and output. –Start an object that is not output for finding new equivalence class.

Program –What kind of data structure can be used to hold these pairs? void Equivalence () { initialize; while more pairs { input the next pair (i, j); process this pair; } initialize for output; for (each object not yet output) output the equivalence class that contains this object; } void Equivalence () { initialize; while more pairs { input the next pair (i, j); process this pair; } initialize for output; for (each object not yet output) output the equivalence class that contains this object; }

Implementation Using Linked List Use one linked list to represent each row of the array pairs first first is a 1D array with each element first[i] is a pointer to the first node for row i.

Example – Phase 1 Consider the following equivalence relations: 0 ≡ 4, 3 ≡ 1, 6 ≡ 10, 8 ≡ 9, 7 ≡ 4, 6 ≡ 8, 3 ≡ 5, 2 ≡ 11, and 11 ≡ first

Example – Phase 2 A Boolean array out[n] is used for determining whether object i is yet to be printed. –The array is initialized to false. –For each i such that out[i] = false, the elements in the list first[i] are output. –For satisfying transitivity, a linked stack is created. out

first out , 11, , 7 1 null 2 1, 2 Linked stack: The first equivalence class

Program void Equivalence () { read n;//read in the number of objects initialize first[0:n-1] to 0 and out[0:n-1] to false; while more pairs { input the next pair (i, j); put j on the chain first[i]; put I on the chain first[j]; } initialize for output; for (each object not yet output) output the equivalence class that contains this object; }

Program – ENode class class ENode { friend void Equivalence(); public: ENode(int d=0, ENode *next=0)//constructor {data = d; link = next;} private: int data; ENode *link; };

Program –Phase 1 void Equivalence() { // initialization for (int i=0; i<n, i++) first[i] = 0; for (int i=0; i<n, i++) out[i] = false; //Phase 1 while (not end of input) { read pair (x,y); first[x] = new ENode(y, first[x]); first[y] = new ENode(x, first[y]); }

Program – Phase 2 for (int i=0; i<n; i++) { if (!out[i]) { cout << endl; << "A new class: " << i; out[i] = true; ENode *x = first[i]; ENode *top = 0; //initialize stack while (1) { while (x) { int j = x->data; if (!out[j]) { cout << ", " << j; out[j] = true; push(j) } x = x->link; } if (stack is empty) break; x = pop(); } Check if the stack is empty Check every node of out[i] if out[i] is true.