3.4

4.4 - 1

Chapter 3.4 Data Representation, Data Structures and Data Manipulation

3.4 (a) Numerical Representation

To turn a denary number into a binary number simply put the column headings, start

at the left hand side and follow the steps:

If the column heading is less than the number, put a 1 in the column and then

subtract the column heading from the number. Then start again with the next

column on the right.

If the column heading is greater than the number, put a 0 in the column and start

again with the next column on the right.

Note: You will be expected to be able to do this with numbers up to 255, because that

is the biggest number that can be stored in one byte of eight bits.

e.g. Change 117 (in denary) into a binary number.

Answer: Always use the column headings for a byte (8 bits)

128 64 32 16 8 4 2 1

Follow the algorithm.

128 is greater than 117 so put a 0 and repeat.

128 64 32 16 8 4 2 1

0 64 is less than 117 so put a 1.

128 64 32 16 8 4 2 1

0 1 Take 64 from 117 = 53, and repeat.

32 is less than 53, so put a 1.

128 64 32 16 8 4 2 1

0 1 1 Take 32 from 53 = 21, and repeat.

If you continue this the result (try it) is

128 64 32 16 8 4 2 1

0 1 1 1 0 1 0 1 So 117 (in denary) = 01110101 (in binary).

To turn a binary number into denary, simply put the column headings above the

binary number and add up all the columns with a 1 in them.

e.g. Change 10110110 into denary.

Answer:

128 64 32 16 8 4 2 1

1 0 1 1 0 1 1 0 So 10110110 = 128 + 32 + 16 + 4 + 2 = 182 (in denary).

This principle can be used for any number system, even the Babylonians’ sixties if

you can learn the symbols.

4.4 - 2

e.g. If we count in eights (called the OCTAL system) the column headings go up in

8’s.

512 64 8 1

So 117 (in denary) is 1 lot of 64, leaving another 53.

53 is 6 lots of 8 with 5 left over. Fitting this in the columns gives

512 64 8 1

0 1 6 5 So 117 in denary is 165 in octal.

Why bother with octal?

Octal and binary are related. If we take the three digits of the octal number 165 and

turn each one into binary using three bits each we get

1 = 001 6 = 110 5 = 101

Put them together and we get 001110101 which is the binary value of 117 which we

got earlier.

The value of this relationship is not important now, but it is the reason why octal is in

the syllabus.

Another system is called HEXADECIMAL (counting in 16’s). This sounds very

difficult, but it needn’t be, just use the same principles.

256 16 1

So 117 (in denary) is 7 lots of 16 (112) plus an extra 5. Fitting this in the columns

gives

256 16 1

0 7 5 Notice that 7 in binary is 0111 and that 5 is 0101, put them together and we get

01110101 which is the binary value of 117 again. So binary, octal and hexadecimal

are all related in some way.

There is a problem with counting in 16’s instead of the other systems. We need

symbols going further than 0 to 9 (only 10 symbols and we need 16!).

We could invent 6 more symbols but we would have to learn them, so we use 6 that

we already know, the letters A to F. In hexadecimal A stands for 10, B stands for 11

and so on to F stands for 15.

So a hexadecimal number BD stands for 11 lots of 16 and 13 units

= 176 + 13

= 189 ( in denary)

Note: B = 11, which in binary = 1011

D = 13, which in binary = 1101

Put them together to get 10111101 = the binary value of 189.

Binary Coded Decimal

Some numbers are not proper numbers because they don’t behave like numbers. A

barcode for chocolate looks like a number, and a barcode for sponge cake looks like a

number, but if the barcodes are added together the result is not the barcode for

chocolate cake. The arithmetic does not give a sensible answer. Values like this that

look like numbers but do not behave like them are often stored in binary coded

4.4 - 3

decimal (BCD). Each digit is simply changed into a four bit binary number which are

then placed after one another in order.

e.g. 398602 in BCD

Answer: 3 = 0011 9 = 1001

8 = 1000 6 = 0110

0 = 0000 2 = 0010

So 398602 = 001110011000011000000010 (in BCD)

Note: All the zeros are essential otherwise you can’t read it back.

3.4 (b) Negative Integers

Sign and Magnitude.

Use the first bit in the byte (the most significant bit (MSB)) to represent the sign (0

for + and 1 for -) instead of representing 128. This means that

+117 = 01110101 and -117 = 11110101

Notes: The range of numbers possible is now –127 to +127.

The byte does not represent just a number but also a sign, this makes arithmetic

difficult.

Two’s Complement

The MSB stays as a number, but is made negative. This means that the column

headings are

-128 64 32 16 8 4 2 1

+117 does not need to use the MSB, so it stays as 01110101.

-117 = -128 + 11

= -128 + (8 + 2 + 1) fitting this in the columns gives 10001011

Two’s complement seems to make everything more complicated for little reason at

the moment, but later it becomes essential for making the arithmetic easier.

3.4 (c) Binary Arithmetic

The syllabus requires the addition of two binary integers, and the ability to take one

away from another. The numbers and the answers will be limited to one byte.

Addition.

There are four simple rules 0 + 0 = 0

0 + 1 = 1

1 + 0 = 1

and the difficult one 1 + 1 = 0 (Carry 1)

e.g. Add together the binary equivalents of 91 and 18

Answer: 91 = 0 1 0 1 1 0 1 1

18 = 0 0 0 1 0 0 1 0 +

0 1 1 0 1 1 0 1 = 109

1 1

Subtraction.

This is where two’s complement is useful. To take one number away from another,

simply write the number to be subtracted as a two’s complement negative number and

then add them up.

e.g. Work out 91 – 18 using their binary equivalents.

Answer: 91 = 01011011

4.4 - 4

-18 as a two’s complement number is –128 + 110

= -128 +(+64 +32 +8 +4 +2)

= 11101110

Now add them 0 1 0 1 1 0 1 1

1 1 1 0 1 1 1 0 +

1 0 1 0 0 1 0 0 1

1 1 1 1 1 1 1

But the answer can only be 8 bits, so cross out the 9th

bit giving

01001001 = 64 + 8 + 1 = 73.

Notes: Lots of carrying here makes the sum more difficult, but the same rules are

used.

One rule is extended slightly because of the carries, 1+1+1 = 1 (carry 1)

Things can get harder but this is as far as the syllabus goes.

3.4 (d) Floating Point Representation

In the first part of this chapter we learned how to represent both positive and negative

integers in two's complement form. It is important that you understand this form of

representing integers before you learn how to represent fractional numbers.

In decimal notation the number 23.456 can be written as 0.23456 x 102. This means

that we need only store, in decimal notation, the numbers 0.23456 and 2. The number

0.23456 is called the mantissa and the number 2 is called the exponent. This is what

happens in binary.

For example, consider the binary number 10111. This could be represented by

0.10111 x 25 or 0.10111 x 2

101. Here 0.10111 is the mantissa and 101 is the exponent.

Similarly, in decimal, 0.0000246 can be written 0.246 x 10-4

. Now the mantissa is

0.246 and the exponent is –4.

Thus, in binary, 0.00010101 can be written as 0.10101 x 2-11

and 0.10101 is the

mantissa and –11 is the exponent.

It is now clear that we need to be able to store two numbers, the mantissa and the

exponent. This form of representation is called floating point form. Numbers that

involve a fractional part, like 2.46710 and 101.01012 are called real numbers.

3.4 (e) Normalising a Real Number

In the above examples, the point in the mantissa was always placed immediately

before the first non-zero digit. This is always done like this with positive numbers

because it allows us to use the maximum number of digits.

Suppose we use 8 bits to hold the mantissa and 8 bits to hold the exponent. The

binary number 10.11011 becomes 0.1011011 x 210

and can be held as

0 1 0 1 1 0 1 1 0 0 0 0 0 0 1 0

Mantissa Exponent

4.4 - 5

Notice that the first digit of the mantissa is zero and the second is one. The mantissa

is said to be normalised if the first two digits are different. Thus, for a positive

number, the first digit is always zero and the second is always one. The exponent is

always an integer and is held in two's complement form.

Now consider the binary number 0.00000101011 which is 0.101011 x 2-101

. Thus the

mantissa is 0.101011 and the exponent is –101. Again, using 8 bits for the mantissa

and 8 bits for the exponent, we have

0 1 0 1 0 1 1 0 1 1 1 1 1 0 1 1

because the two's complement of –101, using 8 bits, is 11111011.

The reason for normalising the mantissa is in order to hold numbers to as high a

degree of accuracy as possible.

Care needs to be taken when normalising negative numbers. The easiest way to

normalise negative numbers is to first normalise the positive version of the number.

Consider the binary number –1011. The positive version is 1011 = 0.1011 x 2100

and

can be represented by

0 1 0 1 1 0 0 0 0 0 0 0 0 1 0 0

Now find the two's complement of the mantissa and the result is

1 0 1 0 1 0 0 0 0 0 0 0 0 1 0 0

Notice that the first two digits are different.

As another example, change the decimal fraction –11/32 into a normalised floating

point binary number.

11/32 = 1/4 + 1/16 + 1/32 = 0.01 + 0.0001 + 0.00001 = 0.01011

= 0.1011 x 2-1

Therefore –11/32 = -0.1011 x 2-1

Using two's complement –0.1011 is 1.0100 and –1 is 11111111

and we have

Mantissa Exponent

Mantissa Exponent

Mantissa Exponent

4.4 - 6

1 0 1 0 0 0 0 0 1 1 1 1 1 1 1 1

The fact that the first two digits are always different can be used to check for invalid

answers when doing calculations.

3.4 (f) Accuracy and Range

The smallest positive mantissa is 0.1000000 and the smallest exponent is 10000000.

This represents

0.1000000 x 210000000

= 0.1000000 x 2-128

which is very close to zero; in fact it is 2-129

.

The largest negative number (i.e. the negative number closest to zero) is

1.0111111 x 210000000

= -0.1000001 x 2-128

Note that we cannot use 1.1111111 for the mantissa because it is not normalised. The

first two digits must be different.

The smallest negative number (i.e. the negative number furthest from zero) is

1.0000000 x 201111111

= -1.0000000 x 2127

= -2127

.

NOTE: reducing the size of the mantissa reduces the accuracy, but we have a much

greater range of values as the exponent can now take larger values.

3.4 (g) Static and Dynamic Data Structures

Static data structures are those structures that do not change in size while the program

is running. A typical static data structure is an array because once you declare its size,

it cannot be changed. (In fact, there are some languages that do allow the size of

arrays to be changed in which case they become dynamic data structures.)

Dynamic data structures can increase and decrease in size while a program is running.

A typical example is a linked list.

The following table gives advantages and disadvantages of the two types of data

structure.

Mantissa Exponent

4.4 - 7

Advantages Disadvantages

Static structures Compiler can allocate

space during compilation.

Easy to program.

Easy to check for

overflow.

An array allows random

access.

Programmer has to

estimate the maximum

amount of space that is

going to be needed.

Can waste a lot of space.

Dynamic structures Only uses the space

needed at any time.

Makes efficient use of

memory.

Storage no longer required

can be returned to the

system for other uses.

Difficult to program.

Can be slow to implement

searches.

A linked list only allows

serial access.

3.4 (h) Algorithms

Linked Lists - Insertion

The algorithm must check for an empty free list as there is then no way of adding new

data. It must also check to see if the new data is to be inserted at the front of the list.

If neither of these are needed, the algorithm must search the list to find the position

for the new data. The algorithm is given below.

1. Check that the free list is not empty.

2. If it is empty report an error and stop.

3. Set NEW to equal FREE.

4. Remove the node from the stack by setting FREE to pointer in cell pointed to

by FREE.

5. Copy data into cell pointed to by NEW.

6. Check for an empty list by seeing if HEAD is NULL

7. If HEAD is NULL then

a. Pointer in cell pointed to by NEW is set to NULL

b. Set HEAD to NEW and stop.

8. If data is less than data in first cell THEN

a. Set pointer in cell pointed to by NEW to HEAD.

b. Set HEAD to NEW and stop

9. Search list sequentially until the cell found is the one immediately before the

new cell that is to be inserted. Call this cell PREVIOUS.

10. Copy the pointer in PREVIOUS into TEMP.

11. Make the pointer in PREVIOUS equal to NEW

12. Make the pointer in the cell pointed to by NEW equal to TEMP and stop.

4.4 - 8

Linked Lists - Deletion

In this case, the algorithm must make sure that there is something in the list to delete.

1. Check that the list is not empty.

2. If the list is empty report an error and stop.

3. Search list to find the cell immediately before the cell to be deleted and call it

PREVIOUS.

4. If the cell is not in the list, report an error and stop.

5. Set TEMP to pointer in PREVIOUS.

6. Set pointer in PREVIOUS equal to pointer in cell to be deleted.

7. Set pointer in cell to be deleted equal to FREE.

8. Set FREE equal to TEMP and stop.

Linked Lists - Amendment

Amendments can be done by searching the list to find the cell to be amended.

The algorithm is

1. Check that the list is not empty.

2. If the list is empty report an error and stop.

3. Search the list to find the cell to be amended.

4. Amend the data but do not change the key.

5. Stop.

Linked Lists - Searching

Assuming that the data in a linked list is in ascending order of some key value, the

following algorithm explains how to find where to insert a cell containing new data

and keep the list in ascending order. It assumes that the list is not empty and the data

is not to be inserted at the head of the list.

Set POINTER equal to HEAD

REPEAT

Set NEXT equal to pointer in cell pointed to by POINTER

If new data is less than data in cell pointed to by POINTER then set POINTER equal

to NEXT

UNTIL

Note: A number of methods have been shown here to describe algorithms associated

with linked lists. Any method is acceptable provided it explains the method. An

algorithm does not have to be in pseudo code, indeed, the sensible way of explaining

these types of algorithm is often by diagram.

4.4 - 9

Stacks – Insertion

The algorithm for insertion is

1. Check to see if stack is full.

2. If the stack is full report an error and stop.

3. Increment the stack pointer.

4. Insert new data item into cell pointed to by the stack pointer and stop.

Stacks – Deletion

When an item is deleted from a stack, the item's value is copied and the stack pointer

is moved down one cell. The data itself is not deleted. This time, we must check that

the stack is not empty before trying to delete an item.

The algorithm for deletion is

1. Check to see if the stack is empty.

2. If the stack is empty report an error and stop.

3. Copy data item in cell pointed to by the stack pointer.

4. Decrement the stack pointer and stop.

These are the only two operations you can perform on a stack.

Queues - Insertion

The algorithm for insertion is

1. Check to see if queue is full.

2. If the queue is full report an error and stop.

3. Insert new data item into cell pointed to by the head pointer.

4. Increment the head pointer and stop.

Queues - Deletion

Before trying to delete an item, we must check to see that the queue is not empty.

Using the representation above, this will occur when the head and tail pointers point

to the same cell.

The algorithm for deletion is

1. Check to see if the queue is empty.

2. If the queue is empty report error and stop.

3. Copy data item in cell pointed to by the tail pointer.

4. Increment tail pointer and stop.

4.4 - 10

These are the only two operations that can be performed on a queue.

3.4 (i) Algorithms for Trees

Trees - Insertion

To add a new value, we look at each node starting at the root. If the new value is less

than the value at the node move left, otherwise move right. Repeat this for each node

arrived at until there is no node. Insert a new node at this point and enter the data.

Now let's try putting "Jack Spratt could eat no fat" into a tree. Jack must be the root

of the tree. Spratt comes after Jack so go right and enter Spratt. could comes before

Jack, so go left and enter could. eat is before Jack so go left, it's after could so go

right. This is continued to produce the tree in Fig. 3.4.i.1.

Fig. 3.4.i.1

The algorithm for this is

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. Create new node and enter data.

Jack

could Spratt

fat

eat no

4.4 - 11

Using this algorithm and adding the word and we follow these steps.

1. The tree is not empty so go to the next step.

2. Current node contains Jack.

3. Node is not null.

4. and is less than Jack so go left.

5. Current node contains could.

3. Node is not null.

4. and is less than could so go left.

5. Current node is null.

3. Current node is null so exit loop.

6. Create new node and insert and and stop.

We now have the tree shown in Fig. 3.4.i.2.

Fig. 3.4.i.2

If the values are read from the left to the right, using the algorithm

Follow left subtree

Read node

Follow right subtree

Return

The values can be read in order. There are many different ways of reading the values

from a tree, but the simplest is the one illustrated by the dashed line in the diagram

above. It is also the only way that you will be asked to read a tree in an examination.

The diagram with the dashed line would be read as

Could, Eat, Fat, Jack, No, Spratt

Note that the words are now in alphabetic order.

Jack

could Spratt

fat

eat no and

4.4 - 12

3.4 (j) Searching Methods

Serial Search

Let the data consist of n values held in an array called DataArray which has subscripts

numbered from 1 upwards. Let X be the value we are trying to find. We must check

that the array is not empty before starting the search.

The algorithm to find the position of X is

1. If n < 1 then report error, array is empty.

2. For i = 1 to n do

a. If DataArray[i] = X then return i and stop.

3. Report error, X is not in the array and stop.

Note that the for loop only acts on the indented line. If there is more than one

operation to perform inside a loop, make sure that all the lines are indented.

Binary Search

Assume that the data is held in an array as described above but that the data is in

ascending order in the array. We must split the lists in two. If there is an even

number of values, dividing by two will give a whole number and this will tell us

where to split the list. However, if the list consists of an odd number of values we

will need to find the integer part of it, as an array subscript must be an integer.

We must also make sure that, when we split a list in two, we use the correct one for

the next search. Suppose we have a list of eight values. Splitting this gives a list of

the four values in cells 1 to 4 and four values in cells 5 to 8. When we started we

needed to consider the list in cells 1 to 8. That is the first cell was 1 and the last cell

was 8. Now, if we move into the first list (cells 1 to 4), the first cell stays at 1 but the

last cell becomes 4. Similarly, if we use the second list (cells 5 to 8), the first cell

becomes 5 and the last is still 8. This means that if we use the first list, the first cell in

the new list is unchanged but the last is changed. However, if we use the second list,

the first cell is changed but the last is not changed. This gives us the clue of how to

do the sort.

3.4 (k) Sorting and Merging

Sorting is placing values in an order such as numeric order or alphabetic order. The

order may be ascending or descending. For example the values

3 5 6 8 12 16 25

are in ascending numeric order and

Will Rose Mattu Juni Hazel Dopu Anne

are in descending alphabetic order.

4.4 - 13

Merging is taking two lists which have been sorted into the same order and putting

them together to form a single sorted list. For example, if the lists are

Bharri Emi Kris Mattu Parrash Roger Will

and

Annis Chu Liz Medis Ste

when merged they become

Annis Bharri Chu Emi Kris Liz Mattu Medis Parrash Roger Ste Will

There are many methods that can be used to sort lists. You only need to understand

two of them. These are the insertion sort and the merge sort. This Section describes

the two sorts and a merge in general terms; the next Section gives the algorithms.

Insertion Sort

In this method we compare each number in turn with the numbers before it in the list.

We then insert the number into its correct position.

Consider the list

20 47 12 53 32 84 85 96 45 18

We start with the second number, 47, and compare it with the numbers preceding it.

There is only one and it is less than 47, so no change in the order is made. We now

compare the third number, 12, with its predecessors. 12 is less than 20 so 12 is

inserted before 20 in the list to give the list

12 20 47 53 32 84 85 96 45 18

This is continued until the last number is inserted in its correct position. In Fig.

3.4.k.1 the blue numbers are the ones before the one we are trying to insert in the

correct position. The red number is the one we are trying to insert.

20 47 12 53 32 84 85 96 45 18 Original list, start with second

number.

20 47 12 53 32 84 85 96 45 18 No change needed.

53 32 84 85 96 45 18 Now compare 12 with its

predecessors.

12 20 47 53 32 84 85 96 45 18 Insert 12 before 20.

12 20 47 53 32 84 85 96 45 18 Move to next value.

12 20 47 53 32 84 85 96 45 18 53 is in the correct place.

12 20 47 53 32 84 85 96 45 18 Move to the next value.

12 20 32 47 53 84 85 96 45 18 Insert it between 20 and 47


4.4 - 14







12 20 32 45 47 53 84 85 96 18 Insert 45 between 32 and 47.


12 18 20 32 45 47 53 84 85 96 Insert 18 between 12 and 20.

Fig. 3.4.k.1

Merging

Consider the two sorted lists

2 4 7 10 15 and 3 5 12 14 18 26

In order to merge these two lists, we first compare the first values in each list, that is 2

and 3. 2 is less than 3 so we put it in the new list.

New = 2

Since 2 came from the first list we now use the next value in the first list and compare

it with the number from the second list (as we have not yet used it). 3 is less than 4 so

3 is placed in the new list.

New = 2 3

As 3 came from the second list we use the next number in the second list and compare

it with 4. This is continued until one of the lists is exhausted. We then copy the rest

of the other list into the new list. The full merge is shown in Fig. 3.4.k.2.

First List Second List New List

2 4 7 10 15 3 5 12 14 18 26 2

2 4 7 10 15 3 5 12 14 18 26 2 3

2 4 7 10 15 3 5 12 14 18 26 2 3 4

2 4 7 10 15 3 5 12 14 18 26 2 3 4 5

2 4 7 10 15 3 5 12 14 18 26 2 3 4 5 7

2 4 7 10 15 3 5 12 14 18 26 2 3 4 5 7 10

2 4 7 10 15 3 5 12 14 18 26 2 3 4 5 7 10 12

2 4 7 10 15 3 5 12 14 18 26 2 3 4 5 7 10 12 14

2 4 7 10 15 3 5 12 14 18 26 2 3 4 5 7 10 12 14 15

2 4 7 10 15 3 5 12 14 18 26 2 3 4 5 7 10 12 14 15 18

2 4 7 10 15 3 5 12 14 18 26 2 3 4 5 7 10 12 14 15 18 26

Fig. 3.4.k.2

4.4 - 15

3.4

Documents