1. Linked List (Part I)
Data structure

2. Introduction

3. Introduction Weakness of storing an ordered list in array:
Insertion and deletion of arbitrary elements are expensive.
Example:
Given an array which is arranged in ascending order.
Discuss how to insert a new element ‘1’ and how to delete the element ‘4’.
Storage allocation is not flexible. 2 4 6 7

4. Possible Improvements
The elements in an ordered list don’t need to be stored in consecutive memory space.
The insertion and deletion of an element will not induce excessive data movement.
The element can be “dynamically” allocated.

5. Linked Representation
Data structure for a linked list:
first
Node
Data
Link (pointer): used to store the address of the next node.

6. Example 8 first BAT 3 CAT 4 FAT 1 2 CAT 4 3 FAT 4 5 6 8 first 7 BAT 31 2
CAT 4 3
FAT 4 5 6 8
first 7
BAT 3 8 9

7. Insertion Insert EAT into an ordered linked list 8 first BAT 3 CAT 64
FAT
EAT
EAT
EAT
EAT
EAT 4 1
Find the position where EAT is to be inserted. 2
CAT 6 3
CAT 4 3
1) Get a new node a
FAT 4
2) Set the data field of a to EAT. 5
3) Set the link field of a to point the node after CAT, which contains FAT. 6
EAT 6
EAT 4 6 6 8
first 7
4) Set the link field of the node containing CAT to a.
BAT 3 8 9

8. Deletion Remove CAT from the linked list 8 first BAT 3 BAT 6 CAT 6 EAT4
EAT 4
FAT 1 2
Find the address of CAT
CAT 6 3 3
1) Set the link of BAT to EAT.
FAT 4
2) Deallocate CAT 5
EAT 4 6 8
first 7
BAT 6 8
BAT 3 8 9

9. Representation of a Linked List
class ListNode {
friend class LinkedList;
public:
ListNode();
ListNode(DataField value);
~ListNode();
private:
DataField data;
ListNode *link; };
class ListNode {
friend class LinkedList;
public:
ListNode();
ListNode(DataField value);
~ListNode();
private:
DataField data;
ListNode *link; };
first
data
link
class LinkedList {
private:
ListNode * first; };
class LinkedList {
private:
ListNode * first; };

10. Linked Ordered List

11. Linked Ordered List Suppose elements are arranged in ascending order.
ADT
class LinkedOrderedList {
public:
LinkedOrderedList();
~ LinkedOrderedList();
void Insert(DataField value);
bool Delete(DataField value); //return false if value is not found.
bool IsEmpty();
private:
ListNode *first; };

12. Initialization The constructor of ListNode:
The constructor of LinkedOrderedList:
ListNode::ListNode(DataField value) {
data = value;
link = NULL; }
LinkedOrderList::LinkedOrderList() {
first = NULL; }

13. Algorithm of Insert() 01 void LinkedOrderList::Insert(DataField value)
02 {
curr = first;
while (curr != NULL) {
06 if (curr->data >= value) {
ListNode *a = new ListNode(value);
a->link = curr;
previous->link = a;
break; }
previous = curr;
curr = curr->link; }
16 }

14. Insertion Insert EAT into an ordered linked list previous previous 8
first
BAT 3
CAT 4
CAT 6
FAT
curr
curr
curr
EAT 4
EAT a
curr = first;
while (curr != NULL) {
if (curr->data >= value) {
ListNode *a = new ListNode(value);
a->link = curr;
previous->link = a;
break; }
previous = curr;
curr = curr->link; }

15. Boundary Condition: Case 1
Consider to insert AT.
There will be no previous node for AT.
The update of first is required.
first
BAT
CAT
FAT AT

16. Boundary Condition: Case 2
Consider to insert GAT.
first
BAT
CAT
FAT
GAT
curr = first;
while (curr != NULL) {
if (curr->data >= value) {
ListNode *a = new ListNode(value);
a->link = curr;
previous->link = a;
break; }
previous = curr;
curr = curr->link; }
No statement is written to insert GAT at the end of the list.

17. Problem of Insert()
The function Insert() fails to deal with boundary conditions.
The insertion is always performed between two existing nodes.
Improvements
Add codes before- and after the while-statement for dealing with the boundary conditions.
Always maintain two (dummy) nodes so that insertion can always be performed between two nodes.

18. Improvement Using Two Dummy Nodes
Maintain two dummy nodes at each end of the list.
class LinkedList {
private:
ListNode * first, *last; };
first
last
LinkedOrderList::LinkedOrderList() {
first = new ListNode();
last = new ListNode();
first->link = last;
last->link = NULL; }
No need to update the pointer first.
Boundary conditions are eliminated (Insertion and Deletion always take place between two nodes).

19. New Version of Insert()
01 void LinkedOrderList::Insert(DataField value)
02 {
previous = first;
curr = first->link;
while (curr != NULL) {
07 if (curr == last || curr->data >= value) {
ListNode *a = new ListNode(value);
a->link = curr;
previous->link = a;
break; }
previous = curr;
curr = curr->link; }
17 }

20. Algorithm of Delete() 01 bool LinkedOrderList::Delete(DataField value)
02 {
if (IsEmpty())
return false; 05
previous = first;
curr = first->link;
while (curr != last) {
if (curr->data == value) {
previous->link = curr->link;
Deallocate curr;
return true; }
previous = curr;
curr = curr->link; }
return false;
20 }

21. Deletion Consider to remove BAT from the list. first last BAT previous
curr
curr->link
if (curr->data == value) {
previous->link = curr->link;
Deallocate curr;
return true; }

22. Destruction of Nodes
Remember to deallocate each node in the destructor.
01 LinkedOrderList ::~ LinkedOrderList()
02 {
curr = first;
while (curr != NULL) {
next = curr->link;
Deallocate curr;
curr = next; }
10 }

23. Performance Analysis Suppose there are n nodes in a linked list.
Space complexity:
A linked list uses an exact amount of memory space to store these n nodes.
Space complexity to perform a insertion or deletion O(1).
Time complexity to perform a insertion or deletion:
Consider a worst case in which nodes are always inserted and deleted at the end of the list. Therefore, the complexity is O(n).
Excessive request of allocation or deallocation of memory space for a node increases loading for the OS system (and may lower efficiency).

24. 4.6 LINKED STACKS AND QUEUE

25. Linked Stack
data
link
top B
Pop
Pop
Push D A D C E

26. Linked Queue Deletion takes place at front; insertion at rear. frontB C D A E
Pop
Pop
Push E

27. Implementation of Linked Queue
LinkedQueue:: LinkedQueue() {
front = rear = NULL; };
bool LinkedQueue::IsEmpty() {
if (front is NULL and rear is NULL)
return true;
return false; }

28. Implementation of Linked Queue
Datafield LinkedQueue::Pop() {
if (IsEmpty())
output error;
else
delNode = front;
value = front->data;
front = front->link;
deallocate delNode;
return value; } };
void LinkedQueue::Push(Datafield value) {
if (IsEmpty())
front = rear = new ListNode(value);
else
rear = rear->link = new ListNode(value); };
LinkedQueue::~ LinkedQueue() {
while (!IsEmpty())
Pop(); };

29. Comparison
Compare stack/queue implemented using array and linked stack/queue.
Array
Linked list
Memory space
The length of an array is fixed; Resize() is required if the stack is full.
Memory space can be dynamically allocated. The storage is more compact.
Execution time for Push() and Pop()
The time complexity is O(1).
The time complexity is also O(1). But the memory request increase overhead.

30. 4.7 Polynomials

31. Polynomial Representation
class ListNode {
friend class LinkedList;
public:
ListNode(int c, int e);
~ListNode();
private:
int coef, exp;
ListNode *link; };
f(x) =3x2+1
first 3 2 1
coef
exp
class Polynomial {
private:
ListNode *first; };

32. Adding Polynomial Example Consider the following two polynomials:
a(x) =3x14+2x8+1
b(x) =8x14-3x10+10x6
a.first 3 14 2 8 1 ai
b.first 8 14 -3 10 10 6 bi

33. Case 1 ai->exp == bi->exp C.first 3 14 2 8 1 aiai
Add coefficients and append to the result C. 8 14 -3 10 10 6 bi
Advance ai and bi to next term.
C.first 11 14

34. Append the term indicated by bi to the result C.
Case 2
ai->exp < bi->exp 3 14 2 8 1 ai
Append the term indicated by bi to the result C. 8 14 -3 10 10 6 bi
Advance bi to next term.
C.first 11 14 -3 10

35. Append the term indicated by ai to the result C.
Case 3
ai->exp > bi->exp
Append the term indicated by ai to the result C. 3 14 2 8 1 ai
Advance ai to next term. 8 14 -3 10 10 6 bi
C.first 1 11 14 -3 10 2 8 10 6

36. Algorithm of Add()
LinkedPolynomial LinkedPolynomial::Add(Polynomial B) {
Create a new LinkedPolynomial C as result;
ai = first;
bi = B.first;
while (ai != NULL && bi != NULL)
if (ai->exp == bi->exp) {
Sum = ai->coef + bi->coef;
if (Sum != 0)
C.InsertBack(Sum, ai->exp);
ai = ai->link;
bi = bi->link; }
else if (ai->exp < bi->exp) {
C.InsertBack(bi->coef, bi->exp);
else if (ai->exp > bi->exp) {
C.InsertBack(ai->coef, ai->exp);
for (; ai != NULL; ai = ai->link) C.InsertBack(ai->coef, ai->exp);
for (; bi != NULL; bi = bi->link) C.InsertBack(bi->coef, bi->exp);
return C;