Data Structures

Grade 12

Computer Studies HG

Data Types

An important concept in most programming languages is that of data types

Each variable or attribute that is declared needs an associated type

A type identifies a certain set or collection of values that a variable can store

Type Examples

For instance if we want to store counting numbers we could declare a variable of type int

We do this because the int (or integer) data type can store any whole number from -2,147,483,648 to 2,147,483,647

Another example is if we wanted to represent whether someone is married or not we could declare a variable of type boolean

We choose boolean because we can store two values with a boolean (true or false) which is all we need in this particular case

Java numeric data types

Java has the following data types:byte -128 to 127short -32768 to 32767 int -2,147,483,648 to 2,147,483,647 long -9,223,372,036,854,775,808 to

9,223,372,036,854,775,807 float 1.4 x 10-45 to 3.4 x 1038

double 4.9 x 10-324 to 1.7 x 10308

char any unicode character

Strings

The type String in Java is not really one of the basic data types

The type String is actually a class in Java This class has the necessary attributes and methods

to manipulate a String object e.g. substring(), length(), charAt()

The designers of Java made an exception in the case of Strings – you don’t have to declare a new string object as you would with other objects.

String myStr = “Hello World”; // this is fine String myStr = new String(); // this is also fine

Dynamic Variable Declaration

Programming languages that support dynamic variable declaration can have variable declarations anywhere in the program

Java supports this type of variable declaration You can have the line int num1; anywhere in

your program so long as it is in scope when it is needed

In other words the only restriction for declaration is that the variable is visible when it is needed

Static Variable Declaration

Believe it or not some languages don’t use dynamic declaration like Java does

Instead all variables need to be declared in a predefined section of the code.

This section is usually above all other code and all variables need to be declared in that section

The need for multi-valued variables

Sometimes we need to store a collection of data of the same type

Often having a separate variable for each value is cumbersome

For instance if we wanted to store the temperature for everyday in June we don’t want to declare 30 separate variables (temp1, temp2… temp30)

The ideal situation would be to have one variable that could store 30 values such that we can choose which value we want to retrieve or store/change

Luckily most programming languages provide us with this feature.

Arrays 1

An array is one variable The array can store as many data items as

the programmer chooses Each data item must be of the same type

(homogenous) Every data item is stored separately in the

array We can specify the location of the data item

we want to change or look at

We can represent an array called fiveInt of 5 integers as follows:

The data in position 2 is the number 6 and the data in position number 4 is 72

Notice how the numbering of the positions starts at 0 and ends at 4

So even though the array has 5 data items there is no position 5 in the array

Arrays 2

5634 6 7223

31 2 40position

We can represent an array called myStrings of 4 Strings as follows:

The data in position 0 is the word “dog” and the data in position number 3 is “frog”

Position 2 has a null value. Note that this is not the word “null” but a way of indicating that the 2nd position in the array is empty

Arrays 3

“frog”“cat” null“dog”

31 20position

Arrays in Java 1

Arrays are declared in a similar way to normal integers:

int[] myArray = new int[4];

An array of int’s

called myArray

allocates memory

holds 4 items

Arrays in Java 2

The array from the following slide can be filled with values as follows:

myArray[3] = 34; myArray[1] = 23;

myArray[0] = 87;myArray[2] = 33;

Position in the array to place the data

The int’s to place in each position

Arrays in Java 3

We can use the values in the arrays as follows:

myArray[0] = myArray[2] + 34 * 69;adds the data in position 2 to 34 * 69 and stores the result in position 0

System.out.println(myArray[0]);

prints out the value of the integer in position 0 of the array (that is 2433)

Arrays in Java 4

Why would the following lines of code not work with the previously declared array?

myArray[4] = 78;myArray[0] = “bob”;myArray = 45;

Can you correct the lines?

Static Structures

Arrays are static data structures because their size is determined when the code is being written

The size of the array cannot be changed during the execution of the program

If we declare an array of 12 integers then once the program starts running we cannot store any more than 12 integers in the array

Once memory has been allocated for the array it is fixed during execution of the program

Static data structures are like hose-pipes. If you get a bigger garden then too bad. Buy a new hose-pipe!

Static means motionless or inactive

Dynamic Data Structures

These data structures can change size during execution of a program

Dynamic data structures grow and shrink as required by the program

The size of the structure is determined during run-time

Dynamic data structures are like Kreepy-Krauly pipes. Getting a bigger pool? Just add more pipes :)

Dynamic means active or changing

Example

If we wanted to write a school database and we wanted to declare a structure to store Student objects what size would we make it? Option 1 – 1300? This is fine but what if we get

more students next year? Option 2 – 5000? This is way too big. We might

never get that many students Option 3 – Dynamic Data Structure. Perfect this

would grow and shrink depending on the amount of data items needed

The story so far…

We’ve looked at the basic data types in Java int, float, double, byte, long char String Arrays of all of the above

We’ve looked at the sizes of data structures Static and Dynamic

In the next episode of Data Structures Advanced Data Types (ADT’s)

Advanced Data Types (ADT’s)

ADT’s provide us with extra functionality in programming languages.

Some ADT’s come standard with Java and others need to be implemented by the programmer. Either way they are fairly complex to code.

The ADT’s that we will examine are the most widely used ADT’s in programming.

Lists

Lists are everyday occurences. Telephone directories Shopping lists To Do lists Class lists

Definition: A list is a sequence of items of the same type

Ordered lists have their items in a predefined order. i.e. Alphabetically or numerically

The size of a list is how many items it contains at any given time

Linked Lists

Linked Lists are a dynamic data structure

Each item in a linked list is referred to as a node.

Each node consists of two parts:Data (Item) Field – This is the actually data

stored in that position of the list (e.g. “dog”, 23)

Next Field – Contains a pointer to the next node in the list

Diagram of a node

34

Data Field Next Field

Design of a Linked List

Each node is connected to the next node via the next field of each node.

The first node is indicated by a head node which contains no data field but only a next field.

The last node’s next field always points to null.

45 67 89 99

head

null

Operations on a Linked List

Create an empty list Check if list is empty Get number of items in the list Copy one list to another list Traverse the list Retrieve an item, given it’s position Search for an item Insert an item Delete an item

Adding

We need to be careful when adding items to a linked list because if we lose a next field of any of the nodes we lose all nodes after that node.

5 Steps: Create the new node with a pointer to it. Find the position where the node is to be inserted (call it

position x). Create a temporary pointer to the node after the

position (i.e. the node in position x + 1). Make the next field of node (x-1) point to the new item. Make the new items next field point to temporary

pointer.

Adding: Step 1

45 67 89 99

head

null

72

new

Adding: Step 2

45 67 89 99

head

null

72

new

position x

Adding: Step 3

45 67 89 99

head

null

72

new

temp

Adding: Step 4

45 67 89 99

head

null

72

new

temp

Adding: Step 5

45 67 89 99

head

null

72

new

temp

Deleting

Deleting is much easier2 Steps

Chose the item to be deleted (position x)Point the next field of node at (x-1) to the

node after position x (x+1)

Deleting: Step 1

45 67 89 99

head

null

position x

Deleting: Step 2

45 67 89 99

head

null

Stacks

Stacks are data structures that allow data items to be added and removed at the top only.

For this reason stacks are called LIFO (Last In First Out) structures because the last item to be added to the stack is the first item to be removed.

Just like a stack of plates at a restaurant. Inserting an item at the top of a stack is referred to

as pushing. Removing an item off the top is referred to as

popping.

Example

Consider the following operations:push “R”; push “T”; push “Y”; pop; push “J”; pop; pop;

R

T

R

Y

T

R

T

R

J

T

R

T

R R

Output: Y J T

Stack Operations

Empty the stackCheck if the stack is emptyDetermine size of the stackLook at the top itemPushPop

Uses of the Stack

RecursionPostfix Notation

Queues

Queues are structures that allow data items to inserted at the rear and removed from the front only.

Known as FIFO (First In First Out) structures because the first item to be inserted into the queue will be the first item to be removed.

These queues are no different from the queues in everyday life (e.g. shopping centers)

Example

Consider the following operationsinsert “A”

insert “B”

insert “C”

remove an element

remove an element

A

A B

A B C

B C

C

Output: A B

Uses

Print Queues Real-life Simulation Statistics:

Average number of element in queue Average time spent in queue Probability that queue will be longer than x Probability that waiting time will be greater than x Minimum and maximum length of a queue of a

period of time Minimum and maximum waiting time over a period

of time

Implementation: Stacks and Queues

Option 1: Using arraysProgrammer has to keep track of where the

front (top) and rear of the structure is.Only homogenous items can be storedFIXED SIZE! Queues and stacks grow and

shrink during executionOption 2: Using a dynamic structure

Linked list!

Trees

In a tree each node may have one or more next field.

This results in a tree-like structure.N

F Q

E G T

Naming Conventions

Root Node – The first nodeChild Node – Node beneath another

node (each node has only one parent)Parent Node – A node with nodes

beneath itLeaf Node – Nodes with no childrenSiblings – Adjacent nodes

Naming Conventions

Root node and parent of F and Q

Child node of N and Parent of T

Sibling of Q

Leaf node

N

F Q

E G T

Binary Trees

Binary trees are trees in which each node may have at most two sub trees. These are called left and right sub trees.

Each node has three elements: Data (Item Field) Left Pointer Right Pointer

The left children of a parent always have smaller values than their parents.

The right children of a parent always have larger values that their parents.

Example

Insert the following into a binary tree:

50, 34, 12, 78, 36, 30, 67, 44, 52

Insert the following into a binary tree:

N, A, Y, T, F, D, S, R, R

Binary Tree Traversal

Pre-Order Visit the root Traverse the left sub-tree in pre-order Traverse the right sub-tree in pre-order

In-Order Traverse the left sub-tree in in-order Visit the root Traverse the right sub-tree in in-order

Post-Order Traverse the left sub-tree in post-order Traverse the right sub-tree in post-order Visit the root

Examples

Traverse both previous trees in in-order, pre-order and post-order.

What do you notice about in-order traversals?

Uses

Representing mathematical expressionsCompilersSearchingSorting

End