linked list (part ii). introduction definition of equivalence relation: a relation ≡ over a set...
TRANSCRIPT
Linked List (Part II)
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, since1. 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 2Begin 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 4.26
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; }
Consideration
Consider implementation using array (for easy random access)m: the number of input pairsn: the number of objects
Declare a Boolean array, pairs[n][n].pairs[i][j] =true iff (i, j) is an input pair.
Implementation Using Array
Example:(0, 2) = true and (2, k) = true for all k implies
(0, k) = true.
Disadvantages:Could be wasteful of space if n is small.At least O(n2) of time is required to perform
initialization.
0 0 0 0 0 0
0 0 0 0 0 0
1
1 0 1 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 1 2 3 4 5
0
1
2
3
4
5
1
1 1
1
(0, 2) = true and (2, 1) = true Implies (0, 1) = true
(2, 3) = true Implies (0, 3) = true
0
Implementation Using Linked List Use one linked list to represent each row of
the array pairs.
0 1 2 3 4 5 6 7 8 9 10 11first
first is a 1D array with each element first[i] is a pointer to the first node for row i.
Program 4.27
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); process this pair; } initialize for output; for (each object not yet output) output the equivalence class that contains this object; }
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 ≡ 0.
0 1 2 3 4 5 6 7 8 9 10 11first
4 03 1 10 69 847
0
8
10
6
9
5
1
311
20
2
11
4
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.
out0 0
0 1
0 0
2 3
0 0
4 5
0 0
6 7
0 0
8 9
0 0
10 11
0 1 2 3 4 5 6 7 8 9 10 11first
4 03 1 10 69 847
0
8
10
6
9
5
1
311
20
2
11
4
out0 0
0 1
0 0
2 3
0 0
4 5
0 0
6 7
0 0
8 9
0 0
10 11
11
1
4
0 , 11 , 4
11
7
, 7
1
null2
1
, 2
Linked stack:
The first equivalence class
Program 4.28 – Part I
class ENode {friend void Equivalence();public: ENode(int d=0, ENode *next=0)//constructor
{data = d; link = next;}private: int data; ENode *link;};
Program 4.28 – Part II (Phase 1)
void Equivalence(){ ifstream inFile("equiv.in", ios::in); if (!inFile)
throw "Cannot open input file."; int n; inFile >> n; ENode **first = new ENode*[n]; bool *out = new bool [n]; for (int i=0; i<n, i++) first[i] = 0; for (int i=0; i<n, i++) out[i] = false; //Phase 1 int x, y; inFile >> x >> y; while (inFile.good()) { first[x] = new ENode(y, first[x]); first[y] = new ENode(x, first[y]); inFile >> x >> y; }
Program 4.28 – Part III (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; ENode *y = x->link; x->link = top; top = x; x = y; } else x = x->link; } if (!top) break; x = first[top->data]; top = top->link; //pop } } }
Check if the stack is empty
Check every node of out[i] if out[i] is true.
Array of Pointers Declare a pointer:
ENode *ptr = new ENode(1, 0); Declare a pointer of array with fixed length:
ENode *ptr[3];for (int i=0; i<3; i++)
ptr[i] = new ENode(i, 0);
Declare a pointer of array with arbitrary length:ENode **ptr;ptr = new ENode * [3];for (int i=0; i<3; i++)
ptr[i] = new ENode(i, 0);
0 1 2
Program 4.28 – Part IV
for (int i=0; i<n; i++) { while (first[i]) { ENode *delnode = first[i]; first[i] = delnode->link; delete delnode; } } delete [] first; delete [] out; }
Analysis of Equivalence()
Definem: the number of input pairs.n: the number of objects.
Space complexity:At most 2m nodes are inserted into first.The array out of length n is used.Space complexity: O(m+n).
Analysis of Equivalence()
Time complexity:Phase 1:
○ The initialization of first and out takes O(n) time. ○ The processing of each input pair is O(1) and there
are m pairs.○ Totally, the complexity for this phase is O(m+n).
Phase 2:○ The for-loop executes n times.
Each unprinted node is put onto the linked stack at most once and there are 2m nodes to examine.
○ The time for this phase is O(m+n).
Introduction In Chapter 2, we use array to implement
a sparse matrix.The sequential representation permits easy
access of matrix terms by row.However, accessing all the terms in a
specific column is difficult.
To provide easy access both by row and by column, we devise a linked representation for a sparse matrix.
Introduction
Node structure for sparse matrices.Header nodesElement nodes
○ The field head is used to distinguish whether the node is a header node (true) or an element node (false).
row col value head
next
down right
head
Header Nodes Number of header nodes = 1 + max {number
of rows, number of columns}. The header node for row i is also the header
node for column i.The down field: used to link into a column list.The right field: used to link into a row list.The next field: used to link the next header nodes.
The list of header nodes has its header node, H, where the fields row and col are used to store the matrix dimension, and value is used to stored the number of nonzero ters.
Node Structure
next
down right
row col value
down right
Header node Element node
down right
row col value
Special use for the first node of the list of
header nodes.
Link to the next nonzero term in
the same column.
Link to the next nonzero term in the same row.
Example Consider the following 5x4 sparse matrix:
How many header nodes?
How many element nodes?
0600
1008
0000
3004
0002
5 4 6
H H0 H1 H2 H3 H4
H0
H1
H2
H3
H4
0 0 2
1 0 4
3 0 8
1 3 3
3 3 1
4 2
Representation of MatrixNode
class MatrixNode{friend class Matrix;public: MatrixNode(bool h=false, int r=-1, int c=-1, int v=0, MatrixNode *rp=0, MatrixNode *dp=0, MatrixNode *nt=0);private: MatrixNode *down, *right, *next; int row, col, value; bool head;};
Representation of Matrix
class Matrix{public: Matrix(int r=0, int c=0);private: MatrixNode *headnode; MatrixNode **head;};
Constructor of Matrix
Matrix::Matrix(int r, int c){ headnode = 0; head = 0; if (r <= 0 || c <= 0) return; int p = max(r, c); head = new MatrixNode*[p]; for (int i=0; i<p; i++) head[i] = new MatrixNode(true); for (int i=0; i<p-1; i++) head[i]->next = head[i+1]; headnode = new MatrixNode(true, r, c, 0, 0, 0, head[0]);}
C++ Program of Insertionvoid Matrix::Insertion(int row, int col, int value){ MatrixNode *prev1 = head[row]; MatrixNode *temp1 = head[row]->right; while (temp1 != NULL) { if (col < temp1->col) break; prev1= temp1; temp1 = temp1->right; } MatrixNode * prev2 = head[col]; MatrixNode * temp2 = head[col]->down; while (temp2 != NULL) { if (row < temp2->row) break; prev2= temp2; temp2 = temp2->down; } MatrixNode *newNode = new MatrixNode(false, row, col, value, temp1, temp2); prev1->right = newNode; prev2->down = newNode;}
5 4 6
H H0 H1 H2 H3 H4
H0
H1
H2
H3
H4
0 0 2
1 0 4
3 0 8
1 3 3
3 3 1
4 2
prev1 temp1
temp2
prev2
1 2 9
Insert a node at (1, 2)
Analysis of Insertion()
Suppose there are n nonzero entries. Space complexity:
O(1)
Time complexity:O(n)Compared to the implementation using
array, inserting an arbitrary entry into the matrix has no need for data shift anymore.
Easy to access a specific row or column.
Introduction 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 listA 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
Representationclass 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;};
left right left right left right0 right left 0
first last
dummydummy
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;}
left right
1left right
2
left right
3
temptemp->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;}
left right
1
left right
2
left right
3
temp->righttemp->left temp