1

Chapter 16-1

Linked Structures

Dale/Weems

2

Chapter 16 Topics

Meaning of a Linked List Meaning of a Dynamic Linked List Traversal, Insertion and Deletion of Elements

in a Dynamic Linked List Specification of a Dynamic Linked Sorted List Insertion and Deletion of Elements in a

Dynamic Linked Sorted List

3

What is a List?

A list is a varying-length, linear collection of homogeneous elements

Linear means that each list element (except the first) has a unique predecessor and each element (except the last) has a unique successor

4

To implement the List ADT

The programmer must

1) choose a concrete data representation for the list, and

2) implement the list operations

5

Recall:4 Basic Kinds of ADT Operations

Constructors -- create a new instance (object) of an ADT

Transformers -- change the state of one or more of the data values of an instance

Observers -- allow client to observe the state of one or more of the data values of an instance without changing them

Iterators -- allow client to access the data values in sequence

List Operations

Transformers Insert Delete Sort

Observers IsEmpty IsFull Length IsPresent

change state

observe state

6

7

ADT List Operations

Iterator Reset GetNextItem

Reset prepares for the iteration GetNextItem returns the next item in

sequence No transformer can be called between calls

to GetNextItem (Why?)

Iteration Pair

8

Array-based class List

Reset

IsFull

Length

IsPresent

Delete

IsEmpty

Insert

GetNexItem

Private data:

lengthdata [0] [1] [2]

[MAX_LENGTH-1]

currentPos

SelSort

9

// Specification file array-based list (“list.h”)const int MAX_LENGTH = 50;typedef int ItemType;

class List // Declares a class data type{public: // Public member functions

List(); // constructor bool IsEmpty () const; bool IsFull () const; int Length () const; // Returns length of list void Insert (ItemType item); void Delete (ItemType item); bool IsPresent(ItemType item) const; void SelSort (); void Reset (); ItemType GetNextItem ();

private: // Private data membersint length; // Number of values currently storedItemType data[MAX_LENGTH];

int CurrentPos; // Used in iteration };

9

10

Implementation Structures

Use a built-in array stored in contiguous memory locations, implementing operations Insert and Delete by moving list items around in the array, as needed

Use a linked list in which items are not necessarily stored in contiguous memory locations

A linked list avoids excessive data movement from insertions and deletions

11

Implementation Possibilities for a List ADT

List

Linked listBuilt-in array

Built-in dynamic data and pointers

Built-in arrayof structs

12

Array Representation of a Linked List

2

head 58 -1

4 5

46 0

16 7

39 4

component link

Node[0]

Node[1]

Node[2]

Node[3]

Node[4]

Node[5]

Node[6]

Node[7]

13

Data Structure of Array Based Linked List

struct NodeType

{

int component;

int link;

};

NodeType node[1000]; // Max. 1000 nodes

int head;

14

Insert a New Node into a Linked List

2

head 58 -1

25 7

4 5

46 0

16 1

39 4

component link

Node[0]

Node[1]

Node[2]

Node[3]

Node[4]

Node[5]

Node[6]

Node[7]

Insert 25,Setting link to 7

Change link from 7 to 1

15

Delete a Node from a Linked List

2

head 58 -1

25 7

4 5

46 0

16 1

39 0

component link

Node[0]

Node[1]

Node[2]

Node[3]

Node[4]

Node[5]

Node[6]

Node[7]Change the link

From 4 to 0

Deleted

16

A Linked List

A linked list is a list in which the order of the components is determined by an explicit link member in each node

Each node is a struct containing a data member and a link member that gives the location of the next node in the list

head ‘X’ ‘C’ ‘L’

17

Dynamic Linked List

head “Ted” “Irv” “Lee”

A dynamic linked list is one in which the nodes are linked together by pointers and an external pointer (or head pointer) points to the first node in the list

18

Nodes can be located anywhere in memory

The link member holds the memory address of the next node in the list

head 3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

19

// Type declarations struct NodeType { char component; NodeType* link;}

typedef NodeType* NodePtr;

// Variable DECLARATIONSNodePtr head;NodePtr ptr;

19

Declarations for a Dynamic Linked List

. component . link

‘A’ 6000

2020

Pointer Dereferencing and Member Selection

. Component . link

‘A’ 6000 ptr

ptr

ptr

. component . link

‘A’ 6000

*ptr

ptr

. component . link

(*ptr).component

ptr->component

‘A’ 6000

2121

ptr is a pointer to a node

. component . link

‘A’ 6000 ptr

ptr

2222

*ptr is the entire node pointed to by ptr

ptr

. component . link

‘A’ 6000

*ptr

2323

ptr->component is a node member

ptr

. component . link

ptr->component

(*ptr).component // Equivalent

‘A’ 6000

2424

ptr->link is a node member

ptr

. component . link

ptr->link

(*ptr).link // Equivalent

‘A’ 6000

25

Traversing a Dynamic Linked List

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

26

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr 3000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

27

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr 3000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

28

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr 3000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

29

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr 5000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

30

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr 5000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

31

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr 5000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

32

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

33

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

34

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr 2000

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

35

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr NULL

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

36

// Pre: head points to a dynamic linked list

ptr = head;

while (ptr != NULL)

{

cout << ptr->component;

// Or, do something else with node *ptr

ptr = ptr->link;

}

ptr NULL

3000 “Ted” 5000 “Irv” 2000 “Lee” NULL

3000 5000 2000

head

Traversing a Dynamic Linked List

37

The End of Chapter 16 Part 1