More on

Linked List Algorithms

Linked List and Template • Remember the implementation of a double linked list we learned

before. Some of methods are shown below

class Node;typedef Node* NodePtr;

class Node {public: int number; NodePtr next; NodePtr prev;};

class DLL {private: NodePtr top; void destroyDLL(NodePtr&); public: DLL(); ~DLL(); void printDLL(); void insertDLL(int number); void destroy(NodePtr&); int searchDLL(int key); … …};

void DLL::insertDLL(int number) { NodePtr temp = top; temp = new Node; temp->next = top; temp->number = number; temp->prev = NULL; if (top != NULL) top->prev = temp; top = temp;}

void DLL::destroyDLL(NodePtr& top) { NodePtr temp = top; while (top != NULL) {

top = top->next;delete temp;temp = top;

} top = NULL;}

int DLL::searchDLL(int key) { NodePtr curr = top; int count = 0; while (curr != NULL) { if (curr->number == key)

count++; curr = curr -> next; } return count;}

void DLL::printDLL() { NodePtr c=NULL, curr=top; while (curr != NULL) { cout << curr->number << "-->"; curr = curr->next; } cout << endl;}

See: Example 1

• Consider the class node. It has three members:

number of type integernext of type NodePtr prev of type NodePtr

• next and prev are just pointers to the successor and predecessor of a node respectively.

• But number represents the actual content of a node. If this content has a different structure instead of being a simple integer, we need to create a different node class for creating different types of linked lists.

• Fortunately with the help of template tools we learned in C++ we can make the content of a node to be of any data type

• Next slide shows the doubly linked list structure with template

template <class T>class Node {public:

T element;Node<T> *next;Node<T> *prev;

};

template <class T>class DLL {private:

Node<T> *top;public:

DLL(); ~DLL(); void destroyDLL( Node<T> *&);

void printDLL();void insertDLL(T obj);bool searchDLL(T key);….….

};

See: Example 2

template <class T>void DLL<T>::insertDLL(T obj) {

Node<T> *temp = top;temp = new Node<T>;temp->next = top;temp->element = obj;temp->prev = NULL;if (top != NULL)

top->prev = temp;top = temp;

}

template <class T>bool DLL<T>::searchDLL(T key) {

Node<T> *curr = top;while (curr != NULL){

if (curr->element == key)return true;

curr = curr -> next;}return false;

}

template <class T>void DLL<T>::printDLL() { Node<T> *curr=NULL; cout << endl; curr = top; while (curr != NULL) { cout << curr->element << "-->"; curr = curr->next; } cout << endl;}

template <class T>void DLL<T>::destroyDLL(Node<T> *&top) {

Node<T> *temp = top;while (top != NULL){

top = top->next;delete temp;temp = top;

}top = NULL;

}

Skip Lists • The serious drawback with the linked list is that to search an

element we need to do sequential scanning of the linked list

• One way to solve this problem is to order the list to speed up searching, but sequential search is still required.

• The Skip List is an interesting variant of ordered linked list which makes such a non-sequential search possible

• In the skip list method• Every node is linked (1 2 3, … )• Every second node is linked (1357, …)• Every fourth node is linked (159 …) • Every eighth node is linked (191725, …)• Every sixteenth node is linked (117 33, …)• ….

• Therefore, a node may have different levels of pointers.

• The following shows an example of a skip list. This type of skip list is called evenly spaced skip list

57

8

10

1217

22

2831

3335

19

• Suppose we are looking for number 16 in the list

• Level 4 in the root node is tried first and we follow the link realizing that 22 > 16.

• Then level 3 in the root node is tried and we follow the link to 10 and then from 10 to 22 realizing that 22>16

• Next we set the pointer to the last valid node (in this case node 10) we visited but we try next level. (level 2 in this case)

• From 10 we get to 17 and 17> 16

• So we stay at node 10 again and we try the first level (level 1)

• We follow the link to 12 and then 17 and we realize that 17>16

• Since we cannot go any lower, we conclude that 16 is not in the list

• Searching will improve with skip list method relative to the regular linked list

• But what about insert and delete?

• If we insert a node or delete a node from the list, the whole structure changes.

• The skip list we discussed was a type of evenly spaced nodes of different levels. Skip lists can be made of unevenly spaced nodes of different levels as shown in the next slide

• Making the skip list unevenly spaced with multiple levels, insert becomes simple and restructuring is not required

• Deleting still needs a bit of work. When we delete a node x, we need to make sure that at all levels predecessors of node x are properly connected to the successors of node x

• For example if we delete node 17, we need to make sure that node 8 is connected to node 28, node 10 is connected to node 22 and node 12 is connected to node 19

510

12

8

7

28

3522

3117

1933

Self-Organizing Lists • Other methods to improve the efficiency of the search in the

linked list is to dynamically organize the linked list in certain order

• This organization depends on the configuration of the data, thus the stream of the data requires reorganizing the nodes already on the list

• Several ways to reorganize the nodes are:• Move to the front method• Transpose method• Count method and • Ordering method

• Move to the front method:• After the desired element is located, put it at the beginning

of the list

• Transpose method:• After the desired element is located, swap it with its

predecessor unless it is at the head of the list

• Count Method:• Order the list by the number of times elements are being

accessed

• Ordering Method:• Order the list based on ascending or descending order

Example of Move-to-front Method

• Suppose a set data A, B, C, D, and E are sent to the system. Using Move-to-front technique we insert an element if it is not in the list or move it to the front if it does already exist in the list:

• Suppose some data arrive in this order:

A C B C D A D A C A C C E EECADBACBDEECADBEACBDEECADBACBDCCADBACBDCACDBACBDACADBACBDCADCBACBDADACBACBDDACBDACBDACABDACBDDCABACBCACBACBBACACCAAA

Mover-to-front Method

PlainElements

Example of Transpose Method

• Suppose a set data A, B, C, D, and E are sent to the system. Using Transpose technique we insert an element if it is not in the list or swap it with its predecessor if it is already in the list

• Suppose some data arrive in this order:

A C B C D A D A C A C C E ECADEBACBDEECADBEACBDEECADBACBDCCADBACBDCACDBACBDACADBACBDCACDBACBDAACDBACBDDACBDACBDACABDACBDDCABACBCACBACBBACACCAAA

Transpose Method

PlainElements

Example of Count Method

• Suppose a set data A, B, C, D, and E are sent to the system. Using Count technique we sort the elements based on the number of times that have been accessed

• Suppose some data arrive in this order:

A C B C D A D A C A C C E E

CAEDBACBDEECADBEACBDEECADBACBDCACDBACBDCACDBACBDACADBACBDCADCBACBDADCABACBDDCABDACBDACABDACBDDCABACBCACBACBBACACCAAACount MethodPlainElements

Example of Ordering Method

• Suppose a set data A, B, C, D, and E are sent to the system. Using Ordering technique we sort the elements in ascending order (in this example)

• Suppose some data arrive in this order:

A C B C D A D A C A C C E E

ABCDEACBDEEABCDEACBDEEABCDACBDCABCDACBDCABCDACBDAABCDACBDCABCDACBDAABCDACBDDABCDACBDAABCDACBDDABCACBCABCACBBACACCAAA

Ordering Method

PlainElements

• With the first three methods, we try to locate the elements most

likely to be looked for near the beginning of the list

• Every method except the ordering approach may require the search for an element to go to the end of the list

• It is important to see how the data in your environment arrive the system. Then based on the behavior of the data, you can choose the best method of searching to implement for your linked list

Sparse Table • In many applications, the choice of table seems to be the most

natural one but space consideration may also be an important factor to be considered

• Suppose we want to store grades of all students in a university for a certain semester

• Suppose there are 8000 students and 300 classes (courses)

• One way to do this is to create two dimensional table making the Student-Ids as the columns and Class-Ids (course Number) to be the rows of the array.

• Then we record the student’s grades in array cells

dc

acj

da

fheb

d

F

D

C-

C

C+

B-

B

B+

A-

A

j

i

h

g

f

e

d

c

b

a8000…5206…402401….321

300..116115

…3130…32

1

Students

• For example, this table shows that the student with Student-Id 5206 has received d ( grade B) in the course with course-Id 30

• Assuming that every student on average can take five courses per semester. In this case, we would have 300 - 5 = 295 empty cells per column

• Since there are 8000 columns, 8000*295 cells would be unused which is waste of a lot of space

• Another solution is to create two 2-dimensional arrays: • One is array of ClassesTakes where the columns represent

the student-Ids and rows would be the maximum number of courses that can be possibly taken by the students

• Second is array of StudentInClasses where the columns are the Course-Ids and rows refer to the maximum number of students per class

292 b..285 h

221 b136 f116 d218 b124 g115 a..115 e31a

..290 e..31 f2 h30 f2b

87654321

8000….520852075206….405404….321

5206 b

136 f

5207 f

404 h124 g

404 e3 e31a

3 d3078a1 b5208 b

250

..

..

3

2

1

300…..115….321

StudentsInClasses

ClassesTaken

• The ClassesTaken array shows that the student with Student-Id 5207 has taken 3 courses with course Ids 290, 115, and 116 and has received grades e, a, and d respectively.

• The StudentsInClasses array shows that course 115 have been taken by three students with students Ids 3078, 404, and 5207. These students have received grades a, e, and f in this course respectively.

• Although the numbers of free cells have been reduced a lot, we still have a lot of free spaces.

• Further, the major limitation of the ClassesTaken is that no student can take more than 8 courses per term. Similarly, in StudentsInClasses array, we must limit the enrollment of each course to 250 students per class

• If space is our main concern, the best solution is to reduce the wasted space as much as possible without having too much effect in the efficiency of search.

• The next slide shows this sparse table using the two-dimensional linked list techniques

52081d

12b

32e

230a

131a

520830d

4042h

52062b

40531f

….5208…5206…405404….321

31

…..……

30

…

2

1

Cla

ssesStudents

• As you see in the slide, Two two-Dimensional arrays of linked list can be used

• Each cell of the array class is a pointer to a linked list of students taking a class and each cell of the array students indicates a linked list of classes taken by a student

• The linked lists contain nodes of five members: student-Id, Course-Id, the grade, a pointer to next student and a pointer to next class

• Note that in this method we dynamically obtain space (creating a node) in memory only if we require that node to store the related information