DATA STRUCTURES

A data structure is a collection of different data items that are

stored together as a single unit and the operations allowable on
them. Such data structures includes arrays, trees, linked lists, stacks
and queues. Data structures can be static or dynamic.

Static data structure

 Are those which do not change in size while the program is
running, e.g arrays and fixed length records.
 Most arrays are static, i.e., once you declare them, they cannot
change in size.
 It main advantage is that amount of storage is known and
therefore is easier to program

Advantages of Static Data Structures

 Easy to check for overflow
 Memory allocation is fixed and therefore there is no problem with
adding and removing data items.
 Compiler can allocate space during compilation
 Easy to program as there is no need to check for data structure
size at any given time/point
 An array allows random access and is faster to access elements
than in other data structures

Disadvantages of Static Data Structures

 Programmer has to estimate maximum amount of space needed,
which may be difficult
 Can waste a lot of space if some space is left with no data entered
into it.
 Adding, removing and modifying elements is not directly possible.
If done, it requires a lot of resources like memory.

DYNAMIC DATA STRUCTURES

 Can increase and decrease in size while the program is running,
e.g. binary trees, linked lists, etc.
 they uses the space needed at any time, no limitations at all,
unless computer memory is full
 its size changes as data is added & removed (size is not fixed)

Page 1 of 22
Advantages of Dynamic Data Structures
 Only uses the space that is needed at any time
 Makes efficient use of the memory, no spaces lie idle at any given
point
 Storage no-longer required can be returned to the system for
other uses.
 Does not allow overflow
 There is effective use of resources as resources are allocated at
run-time, as they are required.

Disadvantages of Dynamic Data Structures

 Complex and more difficult to program as software needs to keep
track of its size and data item locations at all times
 Can be slow to implement searches
 A linked list only allows serial access

Static data structure

Array
An array is a static data structure, which stores and implements a set of
items of the same data type using the same identifier name, in
contiguous memory location. Every array element is accessed or
referenced using an index (subscript), therefore uses index register
addressing. It can either store integers, or names, but not both in one
unit.

Declaration of arrays using VB 6.0

Arrays are declared by stating the following parameters: array name,
array size, dimensions and the data type. The size of the array is the
maximum number of elements that it can store. For example, the
following declares an array that reserves five locations in memory and
labels these as ‘Names’:
Dim Names(4) As String

This can also be declared as

Dim Names(0 to 4 ) As String

One may also declare the array as

Dim Names(1 to 5) As String

The last option modifies the starting value and the ending value of the

Page 2 of 22
indices, but the number of elements still remains the same.

By default, this implies that the array stores at most 5 elements. On

running, the computer creates 5 contiguous memory locations
under the name “Names”. Thus Names will contain 5 partitions.
Each memory partition will be accessed using an index, which is the
address of the memory space in the array.
In Visual Basic, the number of elements stored in an array is N
+ 1, N being the number (subscript) used when declaring the
array.
Array index starts at Zero up to N, N being the number in the
declaration of the array.
The index is also called Subscript, and therefore arrays are
subscripted data types.
It is not possible to exceed the upper limit or go below the lower
limit on the array index values. You will receive a “Subscript out of
range” error message if you try to do so.

In the above declaration, the array index starts from 0 to 4 and are
integer values. The memory locations will be as follows:

Names[0] Names[1] Names[2] Names[3] Names[4]

The five individual locations are Names (0), Names (1), Names (2),
Names (3) and Names (4).
Each data item is called an element of the array. To reference a
particular element one must use the appropriate index.

NB: However, most programming languages differ with Microsoft Visual basic
in handling arrays, especially on the amount of memory allocated. For
example, using Java, the following declaration:
Int [4 ]Names;
This array declaration creates exactly 4 memory spaces for the array Names.
The indices of the array range from 0 to 3 which are
Names[0], Names[1], Names[2] and Names[3]

Initialising an array in Visual Basic 6.0

The procedure of initializing an array in the computer memory is as
follows:

Page 3 of 22
 - Size of array is calculated
- Location of array is decided according to data type and size
- Locations are reserved for the array
- Size of array is stored in a table
- Lower bound of the array is stored in a table
- Upper bound of array is stored in a table
- Data type is stored in a table
- Address of first element is stored in a table

Inserting data into an array

One may use the assignment statement or use looping structures.
For example, the following statement assigns data to the 4th
element:
Names(3) = “Manyeruke”

Arrays simplify the processing of similar data. An algorithm for

getting four names from the user and storing them in the array
Names is shown below:
Dim Names(4) As String
For i=0 to 4
Input Value
Names(i)=Value
Next i

One-dimensional arrays
A one-dimensional array is a data structure in which the array is
declared using a single index and can be visually represented as a
list.

The following diagram shows the visual representation of the array

Names(4):

0 Theresa
1 Lameck
2 Johanne
3 Laurence
4 Fadzai

Page 4 of 22
Two-dimensional arrays
A two-dimensional array is a data structure in which the array is
declared using two indices and can be visually represented as a
table.

Indices 0 1 2 3
0 Makombe Tinashe M 4A
1 Vheremu Alex M 4B
2 Mununi Mary F 3C
3 Chirongera Salpicio M 2C
4 Mutero Violet F 4C

The diagram above shows the visual representation of a 2

dimensional array Names(4,3)- 5 rows and 4 columns:

Each individual element can be referenced by its row and column

indices. For example:
Names(0,0) is the data item “Makombe”
Names(2,1) is the item “Mary”
Names(1,2) is the item “M”

Initialising an array
Initialising an array is a procedure in which every value in the array
is set with starting values – this starting value would typically be “”
for a string array, or 0 for a numeric array.

Initialisation is important to ensure that the array does not contain

results from a previous use, elsewhere in the program.

Algorithm for initialising a one-dimensional numeric array:

DIM TestScores(9) As Integer
DIM Index As Integer
FOR Index = 0 TO 9
TestScores(Index) = 0
NEXT Index

Algorithm for initialising a two-dimensional string array:

DIM Students(4,3) As String
DIM RowIndex, ColumnIndex As Integer
FOR RowIndex = 0 TO 4
FOR ColumnIndex = 0 TO 3
Students(RowIndex,ColumnIndex) = “”
Page 5 of 22
 NEXT ColumnIndex
NEXT RowIndex

Serial search on an array

The following pseudo-co de can be used to search an array to see if
an item X exists:
01 DIM Index As Integer
02 DIM Flag As Boolean
03 Index = 0
04 Flag = False
05 Input X
06 REPEAT
07 IF TheArray(Index) = X THEN
08 Output Index
09 Flag = True
10 END IF
11 Index = Index + 1
12 UNTIL Flag = True OR Index > Maximum Size Of TheArray
13 IF Flag = False THEN
14 Show Message “Item not found”
15 END IF
Note that the variable Flag (line 04 and 09) is used to indicate
when the item has been found and stop the loop repeating
unnecessarily (line 12 ends the loop if Flag has been set to True).

The Actual Visual Basic Code will be as follows:

Dim Index As Integer

Dim Flag As Boolean
Dim x As Integer
Index = 0
Flag = False
x = InputBox("Enter item to Search")
Do
If Names(Index) = x Then
MsgBox (Names(Index) & " Has Been Found")
Flag = True
End If
Index = Index + 1
Loop Until (Flag = True Or Index > UBound(Names))
If Flag = False Then
MsgBox (x & " is not in the array")
End If

Page 6 of 22
Sorting Array Elements
Dim y As Integer
Dim p As Integer
Dim z As Integer
For y = LBound(Names) To UBound(Names)
For p = LBound(Names) To UBound(Names) - 1
If Names(y) < Names(p) Then
z = Names(y)
Names(y) = Names(p)
Names(p) = z
End If
Next p
Next y

Deleting Array Elements

Dim i As Integer
For i = LBound(Names) To UBound(Names) - 1
Names(i) = Names(i + 1)
Next
' VB will convert this to 0 or to an empty string.
Names(UBound(Names)) = Empty

The above algorithm will shift elements of the array up (or left),
removing the first element and then completely removing the last
element in the array.

Page 7 of 22
The following is an alternative method of deleting an array element:

Dim Index As Integer

Dim Flag As Boolean
Dim x As Integer
Index = 0
Flag = False
x = InputBox("Enter item to Search")
Do
If Names(Index) = x Then
MsgBox (Names(Index) & " Has Been Found")
Flag = True
Names(Index) = Empty
End If
Index = Index + 1
Loop Until (Flag = True Or Index > UBound(Names))
If Flag = False Then
MsgBox (x & " is not in the array")
End If

The algorithm first searches the element to delete, and then remove it
from the array.

NB:
 If the item is string, it replaces with empty spaces. However, if it is
numeric, it replaces with a 0.
 Deleting form an array is often difficult as elements need to be
shifted positions after deletion. It is an effective method for
deleting elements.

Dynamic Declaration of Arrays:

Arrays can also be declared dynamically so that the user has to decide
the size of the array when the program is running. The user does not
need to specify the number of elements during the declaration stage.
Dynamic declaration of arrays is done as follows:
Dim Names( ) As String
Inside the module, one then needs to redefine the array as follows:
ReDim Names(5) As String

Page 8 of 22
This allows the user to create the array when he/she actually needs it,
using a ReDim statement: Dynamic arrays can be re-created at will, each
time with a different number of items. When you re-create a dynamic
array, its contents are reset to 0 (or to an empty string) and you lose the
data it contains. If you want to resize an array without losing its
contents, use the ReDim Preserve command:

ReDim Preserve Names(20) As String

DYNAMIC DATA STRUCTURE

Binary Trees
A binary tree is a data structure, consisting of a root node and zero, one
or two sub-tree which are organised in a hierarchical way. Each node is
a parent of at most two nodes.

-
 The data items are held in nodes.
 The possible routes are called paths/branches. They are lines
connecting the nodes.
 Each node has two possible paths.
 The nodes are arranged in layers.
 The first node is called the root, or root node. Each tree has only
one root node. However, each branch can have its branch root.
 Node created by another one is called child node (children)
 Each child node has only one parent node
 Each parent node has at most two children

Page 9 of 22
  The last node is called the leaf node/terminal node (has no
children)
 Nodes that share common parent are called siblings

For example, given the following numbers: 20, 30, 5, 2, 7, 6, 17, 58, 41
Placing them in the binary tree is as follows:
- The first element becomes the root node, i.e. 20
- For other numbers, the bigger number goes to the right and the
smaller one to the right of a node. Every time start from the root
node, until you get to an empty space to place the new node.
- For example, 30, is bigger than 20, therefore is placed to the right
hand side of 20. There is nothing on this side and therefore a new
node is created and 30 placed inside.
- Next is 5, which is smaller than 20 (root node) and therefore goes
to the left. There is an empty space therefore a new node is
created and 5 is placed inside.
- Then 2 is smaller than 20 (root node) and therefore goes to the
left. On the left there is 5. 2 is smaller than 5, therefore we go to
the left and place 2 there.
- Next is 7, which is smaller than 20, we go to the left where there is
5. Seven (7) is bigger than 5, therefore we place it to the right of 5.
- ……….finish on your own!!!!!!!!!!!

Algorithm for constructing a binary tree.

Place first item into root node
For subsequent items, start from root node
Repeat
If (new item > this node item) Then
Follow right pointer
Else

Page 10 of 22
 Follow left pointer
Endif
Until pointer =0
Place item at this node

Binary tree traversal

Tree traversal refers to means of walking through the tress structure
such that each node is visited once. Traversal of trees is a recursive
function-they call themselves. Common traversal methods are: Pre-
Order, In-order and Post-Order Traversals.

A. Pre-Order traversal
The order of traversal is:
- Visit the Node
- Traverse the Left sub-tree
- Traverse the Right sub-tree.
This is generally given as NLR
For the diagram above, the pre-order traversal will be as follows:
20, 5, 2, 7, 6, 17, 30, 58, 41.

The algorithm for pre-order traversal is as follows:

1. Print current node
2. For the current node, check if there is left sub-tree
3. If there is left sub-tree, go to the root node of this sub-tree and print it
4. For the current node, check if there is right sub-tree
5. If right sub-tree is present, then go to 6, else go to 7
6. Repeat 1
7. End

Recursive Algorithm for pre-order traversal

Procedure traversefrom(p)
Print (data);
If Tree[p].Left<>0 Then
Traversefrom(Left)
EndIf
If Tree(p).Right <> 0 Then
traversefrom(Right)
endif
endProcedure

B. In-Order Traversal
The order of traversal is:
- Traverse the Left sub-tree
- Visit the Node

Page 11 of 22
 - Traverse the Right sub-tree.
This is generally given as LNR
For the diagram above, the pre-order traversal will be as follows:
2, 5, 6, 7, 17, 20, 30, 41, 58.

NB: In-order traversal prints items in ascending order or in

alphabetical order if they are alphabetic items.

In-order traversal algorithm:

1. For the current node, check if there is left-sb-tree. If it exists, go to the root node
of this sub-tree and then go to 2. If it doesn’t exist, go to 3.
2. Repeat 1
3. Print the current node
4. For the current node. Check whether it has a right sub-tree. If it has, go to 5.
Else go to 6
5. Repeat 1
6. End

Recursive Algorithm for in-order traversal

Procedure traversefrom(p)
If Tree[p].Left<>0 Then
Traversefrom(Left)
EndIf
Print (data);
If Tree(p).Right <> 0 Then
traversefrom(Right)
endif
endProcedure

C. Post-Order Traversal
The order of traversal is:
- Traverse the Left sub-tree
- Traverse the Right sub-tree.
- Visit the Node

This is generally given as LRN

For the diagram above, the pre-order traversal will be as follows:
2, 6, 17, 7, 5, 41, 58, 30, 20.

The algorithm for post-order traversal is as follows:

Procedure traversefrom(p)
If Tree[p].Left<>0 Then
Traversefrom(Left)
EndIf

Page 12 of 22
 If Tree(p).Right <> 0 Then
traversefrom(Right)
endif
Print (data);
endProcedure

Inserting Data into a Binary Tree

 Look at each node starting from the root node
 If the root is empty, create the node and place the value
 If the new value is less than the value of the of the node, move left, other wise
move right
 Repeat this for each node arrived until there is no node
 Then create a new node and insert the data.
 Perform until no new item need to be added

This can be written algorithmically as:

1. If tree is empty, enter data item at root and stop.

2. Current node = root.
3. Repeat steps 4 and 5 until current node is null.
4. If new data item is less than value at current node go left else go right.
5. Current node = node reached (null if no node).
6. if node reached is null, create new node and enter data.

This can also be written as:

Repeat
Compare new value with root value
If new value > root value then
Follow right sub-tree
Else
Follow left sub-tree
Endif
Until no sub-tree
Insert new value as root of new sub-tree.

Deleting Data from a Tree

Deleting data from a tree is quite complicated, because if it has sub-
nodes, these will also be deleted. There are two options however:
1. The structure could be left the same, but the value of that node
set to deleted.
2. The tree could be traversed, the values removed, put into a stack
and then put back into a binary tree.

Problems when deleting element from tree and solution

Page 13 of 22
  The value at the node is not only data, it is part of the structure of
the tree
 If the node is simply deleted then the sub-tree leading from it is
not navigable
*NB: the algorithm to delete a leaf node is straightforward as deleting a
leaf node does not change the structure of the tree
To remove the value from the tree, either:
 It remains in the tree structure
 Mark value as deleted so that it cannot be output but acts as the
root for its sub-tree

OR:
 The entire sub-tree without its root is read to a list
 The sub-tree is deleted
 The values in the list are read back into the tree (element which
was originally on the left will replace the deleted element
(becomes root of that branch))

Searching item from Binary Tree

The algorithm is as follows:
Enter item to search(this item)
Start at root node
Repeat
If wanted item = this item Then
Found = True
Display Item
Else
If wanted Item >this item Then
Follow right pointer
Else
Follow left pointer
EndIf
EndIf
Until (Found=True or Null pointer is encountered)

Binary tree maintain the order of elements. However, if one element is

deleted, the order is affected.
In some cases, each node (data) may be assigned pointers (right and left
pointer). This is as illustrated below:

Page 14 of 22
IMPLEMENTATION OF BINARY TREES USING ARRAYS
Binary trees can be implemented using left and right pointers for each
node. Each node will have the following:
- Left pointer
- Right pointer
- Data item
Let’s take the binary tree below:

Page 15 of 22
These can be illustrated as follows:
Left Data Right
Tree [1] 2 Long 5
Tree [2] 0 Charlesworth 3
Tree [3] 4 Illman 7
Tree [4] 0 Hawthorne 0
Tree [5] 8 Todd 6
Tree [6] 0 Youngman 0
Tree [7] 0 Jones 0
Tree [8] 0 Ravage 0
- The pointer value 0 indicates a ‘nil’ pointer, thus a node will be
pointing to nothing.
- Tree[1].Left = 2
- Tree[Tree[1].Left].Right = 3
- Tree[6].Data = “Youngman”

Binary trees are also important in the evaluation of postfix expressions

(Reverse Polish Notation)

Infix Expressions
Normal mathematical expressions are written as follows:
A+B
This method is called Infix Notation, because the operator is found
between the operands to be acted upon. Infix notation involves the use
of brackets and observes operator precedence, e.g. BODMAS/BOMDAS.
For example, the expression below is an Infix:
(A+B)*C+(D-A)
If there are no brackets, the expression will give a different answer. It is
not easy for the computer to evaluate infix expressions.

Prefix Expressions
The Polish Notation is also called the prefix. In Prefix (Polish) notation,
the operator precedes the operands. For example, the infix expression
A + B is given as: +AB
This has an advantage that it removes ambiguity and avoids use of
brackets

Page 16 of 22
Postfix Expressions
Reverse Polish Notation (Postfix) is a way of writing mathematical
expressions without using parenthesis and brackets, and in which the
operands precede the operator. Reverse Polish Notation is also called
Postfix. For example, the Infix expression A + B is written as follows in
Postfix:
AB+
Likewise, the infix expression (A+B)*C+(D-A) is written as:
AB+C*DA-+

There is no need for brackets in this situation.

Reverse Polish Notation has the following benefits:

 can be processed directly by reading the expression from left to
right
 is free of ambiguities
 does not require brackets
 does not require rules of precedence as in BODMAS/BOMDAS
 can be processed using a stack

Conversion of Infix Expression into Reverse Polish Notation

This can be easily done using the binary tree. The expression is written
down as a binary tree, then a post-order traversal is undertaken, writing
down the nodes visited. The result will be a Reverse Polish Notation of
the original expression.

The first procedure is to put elements into a binary tree, with each
operator or operand being a node on its own.
To do this, we look at operator precedence. The operator with the
lowest / weakest precedence becomes the root node. When the
weakest operator is identified, it is placed as the root node.
Expressions on the left hand side of this weakest operator makes up the
left sub tree, while those on the right hand side makes the right sub-
tree. This procedure is applied as we move down the tree.

Let’s take an example:

X=A*B+C/D
- The weakest operator is the = sign. So it becomes the root node.
- To its left, there is only X, which becomes a node to the left of =

Page 17 of 22
 - There are no more items to the left branch of the root node. We
therefore go to the right side.
- The weakest operator to the right of = is +, therefore it becomes
the first node to the left of the root.
- To the left of the + sign, the weakest sign is the *, which we place
as the node to the left of +
- To the left of * there is A, which becomes a node.
- To the right of * there is B, which becomes a node.
- We are now done with the left branch of the + node, lets move to
the right side.
- The weakest sign is /, it becomes a node there.
- To its left there is C, which becomes a node.
- To the right of / there is D, which also becomes a node.
- Thus all the items are now in a binary tree , which appears as
follows:

- Now, visiting each node in post-order we get:

XAB*CD/+=
which is the final Reverse Polish Notation.

NB: If the original expression to be converted contains, brackets or

parenthesis, ignore them, that is, don’t put them in the tree, but use
them in getting the weakest operator. Items in brackets have a higher
priority and therefore are inserted in the tree latter than those NOT in
brackets.

Page 18 of 22
Given the following infix notation: (a+b) – c*(d-e)
This can be represented using a tree as follows:

Using the above tree, the reverse polish notation will be as follows;
ab+cde-*-

Evaluating Reverse Polish expressions

A Reverse Polish expression is evaluated using a stack.
 Any operand encountered is loaded into a stack (that is a number
or variable)
 If the next symbol is an operator (+, -,*,…), the last two operands
in the stack are popped,
 The first popped item is placed to the right which the last popped
one is placed to the left, and the operator place in on the middle.
 The operation is carried out and the result is pushed back into the
stack.
The procedure above can be shown diagrammatically as below:

Let us assume that the following postfix expression:

ab+cde-*-
with the following values. A = 5, b=3, c=2, d = 6 and e=4.
- The operands in this expression are: a, b, c, d and e.
- Operators are +, - and *

Page 19 of 22
  First a (5) is pushed into the stack
 b (3) is pushed into the stack
 an operator is encountered, therefore, b (3) is popped and placed
on the right
 a (5) is popped and placed on the left
 the operator (+) is placed in between and effected
 the result (8)is pushed back into the stack
 c (2) is pushed into the stack
 d (6) is pushed into the stack
 e (4) is pushed into the stack
 - sign is encountered. Thus e (4) is popped and placed on the right
 e (6) is popped and placed on the left, to give (d-e)
 Operator (-) is effected
 The result (2) is pushed back into the stack.
 Another operator is encountered(*)
 Result (2) is popped
 C (2) is popped and operator effected
 The result (4) is pushed back to the stack.
 Operator (-) again is encountered
 Result(4) is popped
 Another result (8) is popped and operator effected
 Result (4) is pushed into the stack
 There are no more operators. The answer is displayed.

The above can be shown diagrammatically. Can please draw this on

your own?

Questions

1. (a) State the difference between dynamic and static data structures giving an example of
each. (3)
b) Show how a binary tree can be used to store the data items Feddi, Eda, Joh, Sean, Dav,
Gali in alphabetic order. (4)
c) Explain why problems may arise if Joh is deleted from the tree and how such problems
may be overcome.

2. An array is to be used to store information. State three parameters that need to be given
about the array before it can be used, explaining the reason why each is necessary.

Page 20 of 22
3. (a) Explain the difference between static and dynamic data structures. [2]
(b) Give an example of a
(i) static,
(ii) dynamic
data structure, giving an advantage of each. [4]
(c) The details of a car part are stored in a binary tree according to this algorithm
READ VALUE NEW_PART
START AT ROOT NODE
WHILE NODE NOT EMPTY, DO
IF NEW_PART < VALUE AT NODE
THEN FOLLOW LEFT SUBTREE
ELSE FOLLOW RIGHT SUBTREE
ENDIF
ENDWHILE
INSERT NEW_PART AT NODE
END
(i) Show the binary tree after the following values have been input
Radio Visor Brakes Tyres Alternator Windscreen [3]
(ii) Explain how Clutch is added to the tree in (i). [5]
(iii) Describe an algorithm that can be applied to the binary tree of car parts, so that the
tree is read in alphabetic order.

4.
The following binary tree diagram contains a number of integers. In each case the right
pointer indicates the condition “higher number” and the left pointer indicates the
condition “lower or equal number”.

i) Write down the integer contained in the root node. [1]

(ii) Write down the order in which the nodes would be accessed to find the integer 2528.
[1]
(iii) Copy the tree and show where a new node containing the integer 3106 would be
added. [1]

Page 21 of 22
(iv) The integer 2550 is not in the diagram. Explain what would happen if a search was
made for this code.

5. An array x[1..n] contains a number of integer values.

Design an algorithm (in pseudo-code or a high- level programming language) which will
carry out a linear search of the array for a given search element. If the element is found,
it should output the position of the search element. If the element is not found, the
algorithm should output zero

Page 22 of 22