View
241
Download
5
Tags:
Embed Size (px)
Citation preview
Introduction to Data StructuresIntroduction to Data StructuresArrays, Stacks and QueuesArrays, Stacks and Queues
What is an Array?What is an Array?
• An array is a data structure used for storing a collection of data items that are all the same type.
• By using an array, we can associate a single variable name with an entire collection of data.
• This enables us to save the entire collection of data in adjacent cells of main memory and to easily reference individual items by an Index number.
• To process an individual item, we need to specify the array name and indicate which array element is being manipulated.
Storage comparisonStorage comparison
• Using normal variables
• Using an array
Var1 Var2 Var3 Var4 Var5
5 8 3 6 2
MyArray
5
8
3
6
2
(0)
(1)
(3)
(2)
(4)
Index
Array Example 1Array Example 1
0 1 2 3 4 5 6
1.25 6.00 24.9 0.125 56 1.07 125
Size
Size(0) 1.25
Size(1) 6.00
Size(2) 24.9
Size(3) 0.125
Declaration
Declare Size(6) as Single
Will allow 7 Single numbers to be held (0 – 6)
Index number
Array Example 2Array Example 2
0 1 2 3 4 5 6
“Bob” “Sue” “Ali” “Jaz” “Udo” “Mick” “Gita”
Name
Name(0) “Bob”
Name(1) “Sue”
Name(2) “Ali”
Name(3) “Jaz”
Declaration
Declare Name(6) as String
Will allow 7 Strings to be held (0 – 6)
Array exerciseArray exercise
We are going to use an array to calculate the average of a number of integer values that are entered by the user
To do this we must declare the array.
Note - It is important to put a value in the brackets to give the upper bound index number the array has to hold. The lower bound number defaults to 0
We are going to accept 10 numbers so we declare the array:
VAR Number(9) as array of Integers
Set up a loopSet up a loop
We need to set up a loop to ask for ten numbers.
We will use the For structure so that we can stop after the user enters the tenth number
The code will be:
For x := 1 to 10 Number(X) = Number input by user
End For For x = 1 to 10
Number(X) = UserNum
Does x = 10?No
Yes
End
Next BitNext Bit
We should now have all the numbers we entered stored in the array.
The best way to add them up is by creating another loop to add them together a pass at a time.
Total = 0
For Pass = 1 To 10
Total = Total + Number(Pass)
Next
FinallyFinally
We could calculate the average by dividing this total by ten
Average = Total / 10
Table Look-UpTable Look-Up
• A common application of arrays is to use a value to look up another value in a table
• For example – find the number of days in a month given the month’s number
• The array element numbers are given on the right – these correspond to the month number
• Algorithm for look-up
Enter MonthNum
Num_of_Days = Days(MonthNum)
Display Num_of_Days
1 31
2 28
3 31
4 30
5 31
6 30
7 31
8 31
9 30
10 31
11 30
12 31
Sequential SearchSequential Search
• We may not know the element number but know the value of the element we are looking for
– e.g. when we know someone’s name and want to look them up in the phone book
• The easiest way to do this would be to search sequentially through the entire array looking for a match
Sequential Search AlgorithmSequential Search Algorithm
X := 1
While SearchName <> Array(X) and X <= ArraySizeX := X + 1
End While
If X < ArraySize
Then Display “Search name not found”
Else Display Array(X)
Binary SearchBinary Search
• A faster method for searching the array is the binary search method
• This only works if the contents of the array have been sorted – we will discuss algorithms for sorting later
• This algorithm is a bit more complex than the ones we have considered so far so I will use three flowcharts to describe it
• Each flowchart could be translated into a procedure in the eventual program
Binary Search Flowchart 1 of 3Binary Search Flowchart 1 of 3LB = 1
UB = N
R = Int ((LB + UB)/2)
Flag = 0
Does Flag = 0 ?
Does Array (R) = S
Flag := 1
Yes
Yes
No
No
Go to Flowchart
No. 2
Go to Flowchart
No. 3
Enter From Flowchart
No. 3
Analysis of Flowchart No. 1Analysis of Flowchart No. 1
The lower boundary is set to 1 (lowest element number)
The upper boundary is set to the max. number of elements in the arrayThe flag is set to 0. It will be set to 1 when the element is found or 2 if the element could not be found after an exhaustive search
We will loop whilever the flag is zero – if it isn’t 0 we go to flowchart 2 to display the result of the search
The mid-element number is calculated – we use the Int function to round down.
If the mid-element is not the search term we go to flowchart 3.
If the mid-element = search term we set flag to 1 and drop out of the loop
LB = 1
UB = N
Flag = 0
Does Flag = 0 ?
R = Int ((LB + UB)/2)
Does Array (R) = S
Flag := 1
Flowchart No 2 of 3Flowchart No 2 of 3
• We get to this flowchart because the flag is no longer 0 this means we have either found the search term or failed to find it after an exhaustive search
Display “Search Successful”
Display “Search Term not Found”
Does Flag = 2 ?
End
YesNo
Flowchart No 3 of 3Flowchart No 3 of 3
UB = R - 1 LB = R + 1
Is S > Array (R) ?
YesNo
Is LB > UB
Yes
Flag := 2
Return to Flowchart 1 at indicated
entrance point
No
Analysis of Flowchart No 3Analysis of Flowchart No 3
• This flowchart how we determine where to look next
• If the search term is bigger (or comes alphabetically later) than the array element we are currently considering then the lower boundary is set to one more than the current element number
• This means that we only consider the elements in the top-half of the array
• Similarly if the search term is smaller (or comes alphabetically earlier) than the current array element we set the upper bound to one less than the current element number
• This means that we will look for the desired element in the bottom-half of the array
A Dry Run with the AlgorithmA Dry Run with the Algorithm1 3
2 12
3 23
4 30
5 31
6 40
7 41
8 62
9 98
10 131
11 230
12 331
13 341
We are searching for 331
The number of comparisons made
will be:
1. Check element 7 (UB = 13; LB = 1; Element No = 7)
2. Check element 10 (UB = 13, LB = 8; Element No = 10)
3. Check element 12 (UB = 13; LB = 11; Element No = 12)
We have found 331 after three
comparisons – compared to the 12 that
would be needed in a sequential search
Parallel ArraysParallel ArraysJoe Bloggs
Bill Smith
Emily Wade
Tony Blair
Harry Truman
12, Charlton Road
23, Brander Road
12, Saxton Gardens
10 Downing Street
14, Sandon Grove
43
54
23
52
12
• We can store multiple pieces of related information across a number of parallel arrays
• For example - Student No. 3 has the name Emily Wade, lives at 12 Saxton Gardens and is aged 23
Multidimensional ArraysMultidimensional Arrays
• We can work with arrays of arrays
• So if we want to hold data for 10 homework scores for 15 students we can create a structure like this:
•And refer to elements in the structure like this:
ClassHomework (3,2)
•To find the mark that student number 3 has been awarded for homework number 2
StacksStacks
A Special Type of ArrayA Special Type of Array
What is a stack?What is a stack?
• An ordered collection of homogeneous items.
• Like a stack of coins
We need algorithms to add things to the stack and to take things off it
Stack SpecificationStack Specification
• Procedures to be carried out on stacks
– Push
»Add something to the stack
– Pop
»Take something off the stack
Algorithm for PushingAlgorithm for Pushing
If we assume an array called “MyStack” and a variable
called “Top” that holds the index of the last data item
pushed on to the stack
Obtain data item X
IF stack is full
THEN reply (“Unable to Push”)
ELSE Top := Top + 1
MyStack(Top) := X
Reply (“X has been pushed onto stack”)
ENDIF
Algorithm for PoppingAlgorithm for Popping
IF stack is empty
THEN reply (“Unable to Pop”)
ELSE X := MyStack(Top)
Top := Top -1
Reply (“X has been obtained from the stack”)
ENDIF
Exercise: recognizing palindromesExercise: recognizing palindromes
• A palindrome is a string that reads the same forward and backward.
Able was I ere I saw Elba
• Develop an algorithm to push this line of text a character at a time onto a stack and then pop it to reverse the string for comparison purposes
• Would your algorithm work for a palindrome like this:
Stella won no wallets.
Interesting application of a stackInteresting application of a stack
When you were at school
You were taught BODMAS or some other way of remembering that:
Arithmetic Calculations are done in a particular order.
Work out contents of Brackets
Work out Orders, e.g. R2
Work out Divisions and or Multiplications
Work out Additions and/or Subtractions
Why is it important?Why is it important?
Programming languages follow the same rules as we
have just seen. It is called Arithmetical Syntax or the
order of calculation.
Imagine this situation.
A customer orders two items costing £20 and £80
We need to calculate the VAT at 17.5%
So we write a line that says VAT = 20 + 80 * 17.5%
This will give us a VAT of £34 which is too much
What went wrong?What went wrong?
It came to £34 by working out the VAT on £80 (£14) then
adding the £20 because multiplication occurs before
addition.
We should ensure that the two prices are added
together before the VAT is calculated by enclosing the
two figures in brackets.
The correct line should be:
VAT = (20 + 80) * 17.5%
This will give £17.50 which is correct
Another exampleAnother example
Work out the average of 3, 7, 9 and 5
Average = 3+7+9+5/4
This gives 20.25 – wrong again
It has divided 5 by 4 first as division comes before addition
in the rules.
We should have written
Average = (3+7+9+5)/4
This gives an answer of 6 which is correct.
Expressions represented this way are known as
infix expressions
Postfix ExpressionsPostfix Expressions
• Postfix notation is an alternative way of writing arithmetic expressions.
• In postfix notation, the operator is written after the two operands.
infix: 2+5 postfix: 2 5 +
• Expressions are evaluated from left to right.
• Precedence rules and parentheses are never needed!!
Handling Postfix ExpressionsHandling Postfix ExpressionsAn Algorithm using StacksAn Algorithm using Stacks
WHILE more input items exist
Get an item
IF item is an operand
stack.Push(item)
ELSE
stack.Pop(operand2)
stack.Pop(operand1)
Compute result
stack.Push(result)
stack.Pop(result)
END IF
Another ApplicationAnother Application
• Another application of the stack data structure is the history in a web browser
• Each time a user visits a new web page the address of the page the user is leaving is pushed onto the top of a stack
• Thus the stack ends up containing all the pages the user has previously visited
• When the user eventually clicks on the back button an address is popped off the top of the stack and the browser navigates to that address
• The address popped off will be the one the user has most recently visited
An Illustrative ExampleAn Illustrative Example
• Use a stack to reverse a string of text entered by a user.
• The string should have a maximum length of 500 characters.
• The reversed string should be displayed on the screen.
Possible AlgorithmPossible Algorithm
MakeSureStackisEmpty;
Obtain string from the user;
While there are still characters in the string do
Read a character;
Push it on to the stack
Move to next character
EndWhile
While there are characters on the stack do
Pop a character from the stack;
Write it to the screen
EndWhile
Possible Pascal CodePossible Pascal CodeData DeclarationsData Declarations
program ReverseStringwithStack;
uses crt;
const maxstacksize = 500;
type
stack = record
elements: array[1..maxstacksize] of char;
NumItemsOnStack : integer;
end;
var
thestack: stack;
i: integer;
ch : char;
Possible Pascal CodePossible Pascal CodeProceduresProcedures
procedure startstack; begin thestack.NumItemsOnStack := 0; end;
procedure push; begin with thestack do begin if NumItemsOnStack = maxstacksize then writeln('**ERROR** Trying to place element on full stack!') else begin NumItemsOnStack := NumItemsOnStack + 1; elements[NumItemsOnStack] := ch; end; end; end;
Possible Pascal CodePossible Pascal CodeProceduresProcedures
procedure pop;
begin
with thestack do
begin
if NumItemsOnStack = 0 then
writeln('**ERROR** Trying to remove element from empty stack!')
else
begin
ch := elements[NumItemsOnStack];
NumItemsOnStack := NumItemsOnStack -1;
end;
end;
end;
Possible Pascal CodePossible Pascal CodeMain BodyMain Body
begin clrscr; startstack; write('Enter a string: '); while ch <> #10 do begin read(ch); push; end; writeln; writeln; write('The string reversed is: '); while thestack.NumItemsOnStack <> 0 do begin pop; write(ch); end; end.
Two Example OutputsTwo Example Outputs
QueuesQueues
What is a queue?What is a queue?
• An ordered group of homogeneous items of elements.
• Unlike stacks queues have two ends: – Elements are added at one end.
– Elements are removed from the other end.
• The element added first is also removed first – FIFO: First In, First Out
EnqueueEnqueue
• Function: Adds newItem to the rear of the queue.
• Preconditions: Queue is not full.
• Postconditions: newItem is at rear of queue.
DequeueDequeue
• Function: Removes front item from queue
• Preconditions: Queue is not empty.
• Postconditions: Front element has been removed from queue
Applications of QueuesApplications of Queues
• Queues are useful in any situation where a client’s demands for services can exceed the rate at which those services can be supplied
• For example in a local area network where a number of computers share a printer or communications channel
Review QuestionsReview Questions
• What is meant by an array element?
• Why are stacks called LIFO structures?
• What is infix notation and prefix notation?
• Why are queues called FIFO structures?
Review QuestionReview Question
Trace the following pseudocode showing the contents of the stack after each invocation:
Declare MyStack as StackMyStack.Push (“1”)MyStack.Push (“2”)MyStack.Push (“3”)MyStack.Push (“4”)MyStack.PopMyStack.PopMyStack.Push (“5”)MyStack.Push (“6”)MyStack.PopMyStack.PopMyStack.PopMyStack.Pop