Lecture06 methods for-making_data_structures_v2

Chapter 6
Methods for Making
Data Structures

1

Dynamic Arrays in
Data Structures
• In almost every data structure, we want
functions for inserting and removing data.
• When dynamic arrays are used, the insertion
function would add data to the array, while the
removal function would “eliminate” data from the
array (make it unusable).
• When the array becomes full, we would want to
do an expansion – when many elements have
been removed, we would want to do a
contraction, so that only the used elements
remain.
2

Array
Expansion/Contraction
• One possible method:
– When an element is inserted by the
client, increase the size of the array by 1.
– When an element is removed by the
client, decrease the size of the array by 1.
• The problem with this method is that it is
inefficient – every time an element is
inserted or removed, the changeSize
function is called…

3

changeSize Function
33
0 1 2 3 432 433 444 445

25 75 10 12 … 56 32 73 87

New element needs to be
put into array, so
changeSize function is
called

4

changeSize Function
(cont.)
0 1 2 3 432 433 444 445

25 75 10 12 … 56 32 73 87

0 1 2 3 432 433 444 445 446

…
new array is made

5

changeSize Function
(cont.)
0 1 2 3 432 433 444 445

25 75 10 12 … 56 32 73 87

0 1 2 3 432 433 444 445 446

25 75 10 12 … 56 32 73 87

elements are copied over one by one using a for loop

6

changeSize Function
(cont.)
33

0 1 2 3 432 433 444 445 446

25 75 10 12 … 56 32 73 87 33

Then, the new element can be put in
This process would take place every time a new element
needs to be inserted. 7

changeSize Function
(cont.)
0 1 2 3 432 433 444 445 446

25 75 10 12 … 56 32 73 87 33

Likewise, when an element needs to be removed, this
method contracts the array by one to conserve memory.

Suppose the element at the end of the array needs to be
removed.

8

changeSize Function
(cont.)
0 1 2 3 432 433 444 445 446

25 75 10 12 … 56 32 73 87 33

0 1 2 3 432 433 444 445

…
The changeSize function is called and a new, smaller
array is made.

9

changeSize Function
(cont.)
0 1 2 3 432 433 444 445 446

25 75 10 12 … 56 32 73 87 33

0 1 2 3 432 433 444 445

25 75 10 12 … 56 32 73 87

The elements are copied over one by one, using a for
loop.

10

changeSize Function
(cont.)

0 1 2 3 432 433 444 445

25 75 10 12 … 56 32 73 87

This method of array expansion/contraction is largely
inefficient, because there is too much element copying.

11

Linked Structures
• Sometimes it is best to store data in a
linked structure (an alternative to an
Array)
• A linked structure consists of a group of
nodes – each node is made from a struct.
• An object of the Node struct contains an
element of data.

12

A Node Struct
Template
The info member is
for the data. It can
template <typename T> anything (T), but it is
struct Node { often the object of
T info; another struct, used
Node<T> *next; as a record of
}; information.
The next pointer stores
the address of a Node
of the same type! This
means that each node
can point to another
node.
13

Nodes
• In a data structure, each node is made in
the heap; therefore, a node can only be
accessed by a pointer.
• The client does not deal with nodes.
• When the client uses an insertion
function, an element of data is passed into
the insert function, and the function places
it in a node.
14

Nodes (cont.)
• When the client wants to retrieve data, the
data in a node is returned to the client (but
not the node itself).
• The node struct template exists for use by
the data structure.

15

Example of a
Linked Structure

start

Each blue node is divided into two
sections, for the two members of
the Node struct.

16

Example of a
Linked Structure (cont.)

start

The left section is The right section is the
the info member. pointer called “next”.

17

Example of a
Linked Structure (cont.)

start

The start pointer would The last node doesn’t
be saved in the private point to another node, so
section of a data its pointer (called next) is
structure class. set to NULL (indicated by
slash).

18

Linked Lists
• The arrangement of nodes in the linked
structure on the previous slide is often
called a linked list.
• We can access any element of the linked
list, for retrieval of information.
• We can also remove any element from the
linked list (which would shorten the list).
• We can also insert any element into any
position in the linked list.
19

Linked List
Advantages

… 5 3 7 2 1 …

Removing an element from the
middle of a linked list is fast.

20

Linked List
Advantages (cont.)

… 5 3 2 1 …

Removing an element from the
middle of a linked list is fast.

21

Removal Problem in Array

211 212 213 214 215 216 217 218
… 25 75 10 12 33 49 29 87 …

Removing elements from the middle
of an array (without leaving gaps) is
more problematic.

22

Removal Problem in Array (cont.)

211 212 213 214 215 216 217 218
… 25 75 10 33 49 29 87 …

A loop must be used to slide each
element on the right one slot to the
left, one at a time…

23

211 212 213 214 215 216 217 218
… 25 75 10 33 49 29 87 …
211 212 213 214 215 216 217 218
… 25 75 10 33 49 29 87 …
211 212 213 214 215 216 217 218
… 25 75 10 33 49 29 87 …
24


211 212 213 214 215 216 217 218
… 25 75 10 33 49 29 87 …

Only 100,000 more to go!

25

Linked List
Advantages (cont.)
• Linked lists also waste less memory for
large elements (records of information).
• Wasted memory is memory space in the
data structure not used for data.
• In arrays, the wasted memory is the part of
the array not being utilized.
• In linked lists, the wasted memory is the
pointer in each node.
26

Linked List
Advantages (cont.)

start

Linked List

Array

27

Accessing info
start

To access the info in the first node:

(*start).info

Or (better yet)
dereference and member
start->info access in one shot

28

Accessing info
(cont.)
start

To access the info in the second node:

start->next->info

29

Finding a Possible
Mercedes
start item
maker: Mercedes
price:

Mercedes
… year:
operator ==

Let’s solve the problem, but let’s assume that item
is passed in as a parameter (of type T). This is
normally what would happen.
Instead of the CarType struct having an overloaded
!= operator, it will have an overloaded == operator.

30

Finding a Possible
Mercedes (cont.)
start item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
item.maker = "Mercedes";
Node<T> *ptr = start;
bool found = false;
while (ptr != NULL && !found ) {
if ( ptr->info == item ) // overloaded ==
found = true;
if ( !found )
ptr = ptr->next;
31
}

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
item.maker = "Mercedes";
bool found = false;
found = true;
if ( !found )
ptr = ptr->next;
32
}

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
item.maker = "Mercedes"; found: false
bool found = false;
found = true;
if ( !found )
ptr = ptr->next;
} 33

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
bool found = false;
found = true;
if ( !found )
ptr = ptr->next;
} 34

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
bool found = false;
found = true;
if ( !found )
ptr = ptr->next;
} 35

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
bool found = false;
if ( ptr->info == item )
found = true;
if ( !found )
ptr = ptr->next;
} 36

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
bool found = false;
found = true;
if ( !found )
ptr = ptr->next;
} 37

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
bool found = false;
found = true;
if ( !found )
ptr = ptr->next;
} 38

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
bool found = false;
found = true;
if ( !found )
ptr = ptr->next;
} 39

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
bool found = false;
found = true;
if ( !found )
ptr = ptr->next;
40
}

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
bool found = false;
while (ptr != NULL && !found ) { After going through the
if ( ptr->info == item ) loop several times…
found = true;
if ( !found )
ptr = ptr->next;
} 41

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
bool found = false;
while (ptr != NULL && !found ) { Notice that found is
if ( ptr->info == item ) only set to true if ptr
found = true; is not NULL and
if ( !found ) Mercedes is found …
ptr = ptr->next;
42
}

Finding a Possible
Mercedes (cont.)
start ptr item
maker: Mercedes
price:

Mercedes
… year:
operator ==
CarType item;
bool found = false;
if ( ptr->info == item ) then, !found is false
found = true; and the loop exits
if ( !found )
ptr = ptr->next;
} 43

What If Mercedes Does Not Exist?
start ptr item
maker: Mercedes
price:
… year:
operator ==
CarType item;
bool found = false; If Mercedes is not found,
ptr eventually gets set to
found = true; NULL.
if ( !found )
ptr = ptr->next;
} 44

What If Mercedes Does not Exist?
(cont.)
start ptr is set to NULL item
maker: Mercedes
price:
… year:
operator ==
CarType item;
bool found = false; If Mercedes is not
found, ptr eventually
found = true; gets set to NULL.
if ( !found )
ptr = ptr->next;
} 45

What If Mercedes Does not Exist?
(cont.)
start ptr is set to NULL item
maker: Mercedes
price:
… year:
operator ==
CarType item;
bool found = false;
while (ptr != NULL && !found ) { Exit from loop
if ( ptr->info == item ) because ptr is
found = true; NULL.
if ( !found )
ptr = ptr->next;
} 46

What If Finding in an Empty Linked
List?
• When a linked list is empty, the start
pointer should always be set to NULL.
• The start pointer would be set to NULL
inside the constructor, when an empty
linked list is first made.

47

Finding in an Empty List
item
start is set to NULL maker: Mercedes
price:
year:
operator ==
bool found = false;
found = true; SAME CODE
if ( !found )
ptr = ptr->next;
}
48

Finding in an Empty List (cont.)
item
ptr is set to NULL price:
year:
operator ==
bool found = false;
found = true;
if ( !found )
ptr = ptr->next;
}
49

item
year:
operator ==
bool found = false;
while (ptr != NULL && !found ) { found: false
found = true;
if ( !found )
ptr = ptr->next;
}
50

item
year:
operator ==
bool found = false;
while (ptr != NULL && !found ) { found: false
found = true; Exit loop
if ( !found ) because ptr is
ptr = ptr->next; NULL.
}
51

Inserting a New Node
• Let’s assume that we want to insert a new
node at the beginning of a linked list.
• Assume that the client passes in a
parameter called element (of type T).
• We would like to place the element into a
node and insert the node at the beginning
of the linked list.

52

Inserting a Node at Front
element

start

All new nodes must be made in the heap, SO…

53

Inserting a Node at Front (cont.)
element

start

ptr

Node<T> *ptr = new Node<T>;

54

element

start

ptr


Now we have to store element into the node

55

element

start

ptr

ptr->info = element;

56

element

start

Now we have to think about how to
ptr make the pointer called “next” point to
the first node in the list, to link it in


57

element

start

You can’t successfully write code like
ptr this without thinking about addresses.


58

element

start

REMEMBER…when you want to
ptr change the way a pointer points, you
HAVE to assign a different address to it


59

element

start

Right now, the pointer called “next”
ptr doesn’t have a valid address assigned
to it.


60

element

start

To store the correct address in it, we
ptr have to find the address of the first node
of the linked list.

61

element

start

ptr Where is the address of the first node
stored?


62

element

start

Now think, the address would be stored
ptr in something that points to it. So where
is it stored?


63

element

start

ptr That’s right, in the start pointer.


64

element

start

ptr So now, all we have to do is copy that
address into the pointer called “next”


65

element

start

ptr

ptr->next = start;
66

element

start

ptr Well, it’s been inserted. But start
should point to the first node now.

ptr->next = start;
67

element

start

REMEMBER…when you want to
ptr change the way a pointer points, you
have to assign a different address to it

ptr->next = start;
68

element

start

We’d like start to point to the new
ptr node, so what stores the address of
the new node?

ptr->next = start;
69

element

start

That’s right, ptr. So now all we have
ptr to do is assign the address stored in
ptr to the start pointer.

ptr->next = start;
70

element

start

ptr

ptr->next = start;
start = ptr;
71

element

start

ptr Easy, right?

ptr->next = start;
start = ptr;
72

REMEMBER…
• Use drawings when working with linked
lists, until you become an expert.
• When you want to change the way a
pointer points, you have to assign a
different address to it.
• You can find the address you need by
looking at other pointers (remember that
they store addresses).
73

Inserting into the Middle
of a Linked List

• Suppose we know that there is a
Mercedes in a linked list.
• We would like to insert a node containing
Honda right after it.
• We first find the Mercedes, using code that
we looked at before.

74

Inserting a Node at Middle
start ptr element
maker: Mercedes
price:

Mercedes
… year:
operator !=

After this code executes, ptr points to the
node that has Mercedes.

while ( ptr->info != element ) // element is a parameter
ptr = ptr->next;
75

Inserting a Node at Middle (cont.)
start ptr element
maker: Mercedes
price:

Mercedes
… year:
operator !=

Now we would like to insert a CarType object
called elementToInsert (containing Honda), which
would also be passed in as a parameter, right after
the Mercedes

76

start ptr
maker: Honda
price: 5000

Mercedes
… year: 1985
operator !=

elementToInsert

Well, all new nodes are created in the heap, SO…..

77

start ptr
maker: Honda
price: 5000

Mercedes
… year: 1985
operator !=

newNode elementToInsert

Node<T> *newNode = new Node<T>;

78

start ptr
maker: Honda
price: 5000

Mercedes
… year: 1985
operator !=


Now, how about placing elementToInsert into the new
node?
79

start ptr
maker: Honda
price: 5000

Mercedes
… year: 1985
operator !=


newNode->info = elementToInsert;

80

start ptr
maker: Honda
price: 5000

Mercedes
… year: 1985
operator !=



81

start ptr
Now, what we want is

Mercedes
shown by the dashed
…
arrows; this would
cause the insertion of
the node
newNode


82

start ptr
We have two
pointers we need to

Mercedes
… change – but we
have to be careful
about the way we
change them
newNode


83

start ptr
If we change the
left pointer first,

Mercedes
… we will no longer
be able to access
the last node
(memory leak)
newNode


84

start ptr
So, we first have to
assign the address

Mercedes
… of the last node into
the “next” pointer
of the new node
newNode


85

start ptr

Where is the

Mercedes
… address of the last
node stored?

newNode


86

start ptr

That’s right, it is

Mercedes
… stored in ptr->next

newNode


87

start ptr

Mercedes
…

newNode

newNode->next = ptr->next;

88

start ptr

Mercedes
Mercedes
…

newNode

newNode->next = ptr->next;
ptr->next = newNode;
89

Removing a Node
• Suppose we definitely know there is a
Mercedes in the linked list and we wish to
remove the node that contains it.
• We need to find the node first.

90

Removing the First Node
start
Mercedes

…

Mercedes is in the first node
if ( ptr->info == element )
start = start->next;

91

(cont.)
start
Mercedes ptr

…


92

(cont.)
start
Mercedes ptr

…


93

(cont.)
Mercedes ptr start

…


94

(cont.)
ptr start

…

Node<T> *ptr = start; Well, start points to the
if ( ptr->info == element ) { beginning of the new
start = start->next; linked list, but a node isn’t
delete ptr; removed unless we free it.
}
95

(cont.)
ptr start

…

Node<T> *ptr = start; Now, let’s consider the
if ( ptr->info == element ) { other case whereby
Mercedes is in the
delete ptr; middle of the list.
}
96

Removing a Middle Node
start ptr

Mercedes
…

else {
The while loop
while ( ptr->next->info != element )
points ptr to the
ptr = ptr->next;
node BEFORE
the node that
has Mercedes.
97

Removing a Middle Node (cont.)
start ptr

Mercedes
…

else {
while ( ptr->next->info != element ) We need to join the
ptr = ptr->next; node before
Mercedes to the
node after
Mercedes
98

start ptr ptr2

Mercedes
…

else {
But we mus keep
ptr = ptr->next;
a pointer to the
node that has
Node<T> *ptr2 = ptr->next;
Mercedes
99

start ptr ptr2

Mercedes
…

else {
ptr = ptr->next; We now join the
node before
Node<T> *ptr2 = ptr->next; Mercedes to the
ptr->next = ptr2->next; node after
Mercedes
100

start ptr ptr2

…

else {
ptr = ptr->next;
We then delete the
ptr->next = ptr2->next; node that has Mercedes
delete ptr2;
We did it!
101

What If Mercedes is the Last
Node?
• Would our code still work?
• Try to consider every possible situation in
code design.

102

Removing the Last
Node
start ptr

Mercedes
…

else {
while ( ptr->next->info != element ) After looping, ptr
ptr = ptr->next; stops on the
next-to-the-last
Node<T> *ptr2 = ptr->next; node
ptr->next = ptr2->next;
delete ptr2;
}

103

Removing the Last
Node (cont.)
start ptr ptr2

Mercedes
…

else {
ptr = ptr->next;

delete ptr2;
}

104

Removing the Last
Node (cont.)
start ptr ptr2

Mercedes
…

else {
ptr = ptr->next;

delete ptr2;
}

105

Removing the Last
Node (cont.)
start ptr ptr2

…

else {
while ( ptr->next->info != element ) The code works
ptr = ptr->next;
in removing the
Node<T> *ptr2 = ptr->next; last node.
delete ptr2;
}

106

Working With Linked Lists
• As you can see, sometimes you have to
do a lot of thinking and problem-solving
when working with linked lists.
• It is not always obvious how to write code.
• You can’t memorize the code, because it
will not quite fit situations that you will
encounter.
• It is a matter of using logic (and knowing a
few tricks of the trade).
107

Code for Removing
a Node
1 Node<T> *ptr = start; Here is the resulting
2 if ( ptr->info == element ) { code for removing a
3 start = start->next; node. It is assumes
4 delete ptr; the node we are
5 } looking for is in the
6 else { linked list.
7 while ( ptr->next->info != element )
8 ptr = ptr->next;
9 Node<T> *ptr2 = ptr->next;
10 ptr->next = ptr2->next;
11 delete ptr2;
12 }
108

Speed
• In some situations, an array can be faster than a
linked list, such as when a calculated index is
used to access an element.
• In other situations, a linked list can be faster
than an array, such as when removing an
element from the middle (as we saw before).
– we usually need to search for the element to
remove, but we search for it in both the array and
linked list.

109

Reference
• Childs, J. S. (2008). Methods for Making
Data Structures. C++ Classes and Data
Structures. Prentice Hall.

110

Lecture06 methods for-making_data_structures_v2

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Viewers also liked

Viewers also liked (15)

Similar to Lecture06 methods for-making_data_structures_v2

Similar to Lecture06 methods for-making_data_structures_v2 (20)

More from Hariz Mustafa

More from Hariz Mustafa (12)

Lecture06 methods for-making_data_structures_v2