ITRW222VBC - Index of

Study guide compiled by:
DATASTRUKTURE EN ALGORITMES:
DATA STRUCTURES AND ALGORITHMS
STUDY GUIDE FOR
ITRW222VBC
*ITRW222VBC*
VAAL TRIANGLE CAMPUS
Dr R Goede (School of Information Technology)
Printed by The Platinum Press (018) 294 8879/(016) 981 9401
Copyright © 2011 edition. Date of revision 2012
North-West University, Vaal Triangle Campus
All rights reserved. No part of this book, may be reproduced in any form or by any means
without written permission from the publisher. It includes the making of photocopies of the
whole or parts of this book.

INHOUDSOPGAWE
Rekenaarwetenskap en Inligtingstelsels ................................................................................ 3
Tydverdeling .......................................................................................................................... 3
Module-uitkomste ................................................................................................................... 3
Veronderstelde leer ................................................................................................................ 4
Beskikbare hulp ..................................................................................................................... 4
Studiemateriaal ...................................................................................................................... 4
Klasbywoning ......................................................................................................................... 4
Werkswyse ............................................................................................................................ 5
Hulp tydens prakties .............................................................................................................. 5
Rugsteun ............................................................................................................................... 5
Evaluering .............................................................................................................................. 6
Studie-ikone ........................................................................................................................... 7
Waarskuwing teen plagiaat .................................................................................................... 8
Leereenheid 1 Die analise van algoritmes – deel 1 ................................................ 9
Leereenheid 2 Die analise van algoritmes – deel 2 .............................................. 11
Leereenheid 3 Skikkings en matrikse ................................................................... 13
Leereenheid 4 Geskakelde lyste ........................................................................... 15
Leereenheid 5 Datatipes en abstraksie – deel 1 ................................................... 17
Leereenheid 6 Datatipes en abstraksie – deel 2 ................................................... 19
Leereenheid 7 Stapels ........................................................................................... 21
Leereenheid 8 Toue ................................................................................................ 23
Leereenheid 9 Geordende lyste ............................................................................ 25
Leereenheid 10 Gesorteerde lyste .......................................................................... 27
Leereenheid 11 Sorteringsalgoritmes - deel 1 ....................................................... 29
Leereenheid 12 Sorteringsalgoritmes - deel 2 ....................................................... 31
Leereenheid 13 Bome en grafieke ........................................................................... 33
Bylaag 1 - Praktiese opdragte ........................................................................................... 35
Bylaag 2 – Klasbesprekings .............................................................................................. 46
Bylaag 3 – Eksamenvraestel ............................................................................................. 74
2

MODULE CONTENTS
Welcome ................................................................................................................................ 3
Computer science and information systems ........................................................................... 3
Time management ................................................................................................................. 3
Module outcomes................................................................................................................... 3
Supposed study ..................................................................................................................... 4
Available help ........................................................................................................................ 4
Study material ........................................................................................................................ 4
Class attendance ................................................................................................................... 4
Work method ......................................................................................................................... 5
Help during practical classes.................................................................................................. 5
Backup ................................................................................................................................... 5
Evaluation .............................................................................................................................. 6
Study icons ............................................................................................................................ 7
Warning against plagiarism .................................................................................................... 8
Study unit 1 Analysis of algorithms – part 1 ....................................................... 9
Study unit 2 Analysis of algorithms – part 2 ..................................................... 11
Study unit 3 Arrays and matrixes ...................................................................... 13
Study unit 4 Linked lists ..................................................................................... 15
Study unit 5 Data types and abstraction – part 1 ............................................. 17
Study unit 6 Data types and abstraction – part 2 ............................................. 19
Study unit 7 Stacks ............................................................................................. 21
Study unit 8 Queues ........................................................................................... 23
Study unit 9 Ordered lists .................................................................................. 25
Study unit 10 Sorted lists ..................................................................................... 27
Study unit 11 Sorting algorithms - part 1 ........................................................... 29
Study unit 12 Sorting algorithms – part 2 .......................................................... 31
Study unit 13 Trees and graphs ........................................................................... 33
Appendix 1 - Practical assignments ................................................................................. 35
Appendix 2 – Class discussions ....................................................................................... 46
Appendix 3– Examination paper ....................................................................................... 74
2

REKENAARWETENSKAP EN INLIGTINGSTELSELS
PU-vlak 2
Nasionale vlak 6
Krediete 16
Kontakperiodes 4
Praktiese periodes 3
TYDVERDELING
Aktiwiteit Weke Ure per week Totaal
Klas (kontaktyd –> lesing + klastoetse) 12 3 36
Praktika in laboratorium 12 2.5 30
Praktiese opdragte 12 4 48
Selfstudie 12 2 24
Semestertoets 1 10 12
Eksamen 1 12 12
Totaal 160
MODULE-UITKOMSTE
Aan die einde van hierdie module het die leerder basiese kennis en insig
verwerf oor:
• Die tydanalise van algoritmes;
• vektore;
• matrikse;
• geskakelde lyste;
• stapels;
• toue;
• gesorteerde lyste;
• bome;
• sorteer-algoritmes; en
• abstrakte datatipes en -klasse.
3

WELCOME
COMPUTER SCIENCE AND INFORMATION SYSTEMS
PU level 2
National level 6
Credits 16
Contact sessions 4
Practical classes 3
TIME MANAGEMENT
Activity Weeks Hours a week Total
Class (contact time –> lecture + class test)12 3 36
Practical in laboratory 12 2.5 30
Practical assignments 12 4 48
Independent study 12 2 24
Semester tests 1 10 12
Exam 1 12 12
Total 160
MODULE OUTCOMES
On completion of this module the learner will have basic knowledge and
insight regarding the following:
• The time analysis of algorithms;
• vectors;
• matrixes;
• linked lists;
• stacks;
• queues;
• sorted lists;
• trees;
• sorted algorithms; and
• abstract data types and classes.
3

Die leerder sal na voltooiing van die kursus kan bewys lewer dat hy/sy:
• Die kennis en insig wat verwerf is, in probleemoplossing met behulp van die rekenaar
kan toepas;
• ’n goeie programmeringstyl gebruik en leesbare programme kan skryf;
• gestruktureerde klasse en -programme kan skryf wat netjiese uitvoer lewer; en
• programme skryf wat gebruikersvriendelik is.
VERONDERSTELDE LEER
Om hierdie module suksesvol te doen, word veronderstel dat ten minste 40% vir ITRW 212
behaal is.
BESKIKBARE HULP
Dosent: Mnr Johan Prinsloo
Kantoor: 102
Telefoon: x 3275
E-pos: Johan.Prinsloo@nwu.ac.za
Groepleiers: Tydens die geskeduleerde praktiese periodes sal daar studente-assistente
beskikbaar wees om met die opdragte te help. Hulle sal ook verantwoordelik
wees vir die evaluering van praktiese opdragte en toetse wat tydens
die geskeduleerde praktiese tye geskryf word.
STUDIEMATERIAAL
HANDBOEK
Titel: Data Structures and Algorithms with Object Oriented Design Patterns in Java
Outeur: Bruno R Preiss
ISBN: 0-471-34613-6
Uitgewer: Wiley
KLASBYWONING
Aangesien klastoetse wel sonder vooraf kennisgewing gegee kan word, is dit noodsaaklik
dat alle klasse bygewoon word, tensy anders gereël.
PRAKTIES
Die module is baie prakties van aard en daarom vorm die praktiese opdragte die kern van
die module. Alle opdragte moet betyds voltooi en ingehandig word vir evaluering.
4

On completion of this course the learner must prove that he/she:
• Is able to use the knowledge and insight gained and apply it in problem solving with the
aid of a computer;
• can use good programming style and is able to write readable programmes;
• is able to write structured classes and programs that are neatly executed; and
• can write programs that are user friendly.
SUPPOSED STUDY
To successfully complete this module, it is assumed that you achieved a mark of at least
40% for ITRW 212.
AVAILABLE HELP
Lecturer: Mr Johan Prinsloo
Office: 102
Telephone: x 3275
Email: Johan.Prinsloo@nwu.ac.za
Group leaders: During the practical classes student assistants will be on hand to help you
with your assignments. They are also responsible for the evaluation of
practical assignments and tests written during the scheduled practical
classes.
STUDY MATERIAL
TEXTBOOK
Title: Data Structures and Algorithms with Object Oriented Design Patterns in Java
Author: Bruno R Preiss
ISBN: 0-471-34613-6
Publisher: Wiley
CLASS ATTENDANCE
Class tests may be written without prior notice. It is therefore very important that you attend
all classes unless other arrangements are made.
PRACTICAL
The assignments are the core of this module due to the practical nature of the course. All
assignments must be completed on time and be submitted for evaluation.
4

WERKSWYSE
• Die doel van die module is om programmeringsvaardighede uit te brei en daarom is dit
noodsaaklik dat jy baie oefening kry om programme te skryf.
• Java word as programmeringstaal gebruik.
• Die praktiese opdrag wat elke week gegee word, is 'n samevatting van sommige van
die tegnieke wat in die klas aangeleer is en dit moet ingeoefen word.
• Al die werk van die week kan egter nie in die praktiese opdrag weergegee word nie en
daarom is dit noodsaaklik om die voorbeelde en werk wat in die klas gedoen is, na
afloop van die klasse (tydens eie tyd) op die rekenaar te oefen. Die praktiese opdragte
dek slegs 'n deel van die werk wat gedoen word.
• Tydens elke praktikum word 'n opdrag gegee, en dit word voltooi en ingehandig en
deur die groepleier geëvalueer.
• Onthou: ’n program wat nie werk nie is niks werd nie!
• As die opdragte nie tydens die geskeduleerde tyd klaar is nie, moet dit in jou eie tyd
gedurende die week voltooi word en vóór die volgende prakties per e-pos aan die
groepleier vir evaluering gestuur word.
• Rugsteun moet van al die programme en opdragte op ’n stiffie gehou word en dit moet
by elke praktiese klas beskikbaar wees.
• As 'n program laat ingehandig word, word punte afgetrek.
• Aan die begin van ’n praktiese sessie word dadelik met die nuwe opdrag begin.
• Afskrywery en kopiëring van ander persone se werk word as 'n baie ernstige oortreding
beskou. Die persoon wat hieraan skuldig is, sowel as die persoon wat sy werk beskikbaar
gestel het, sal hulle punte verbeur en loop ook gevaar om eksamentoelating
geweier te word.
HULP TYDENS PRAKTIES
Al die praktiese sessies vind in die mikro-laboratorium plaas en almal moet teenwoordig
wees.
Studente-assistente sal beskikbaar wees om met die praktiese opdragte gedurende
die praktiese sessies te help.
Geen praktiese opdrag sal vir ’n punt in aanmerking kom as die student nie tydens die
geskeduleerde praktiese periodes teenwoordig was nie.
Die studente-assistente is verantwoordelik vir die evaluering van die opdragte. As ’n
praktiese opdrag voltooi is, sal die studente-assistent ’n punt daarvoor gee.
Die studente-assistent moet al die studente in sy groep se naam en besonderhede
opskryf en die studente moet hulle studente-assistente se naam en e-posadres kry.
RUGSTEUN
Die praktiese werk wat gedoen word, word op die P-skyf van die netwerk gestoor. Elke
student moet egter nog ’n stiffie aanskaf om die opdragte en werkstukke op te stoor sodat dit
op twee plekke gestoor kan word (vir veiligheid/rugsteun).
5

WORK METHOD
• The aim of this module is to expand your programming skills, and practice in writing
programs is therefore essential.
• Java is the programming language used.
• Each week’s practical assignment is a summary of some of the techniques you learned
in class and must be practised.
• All the work of the week cannot be included in the practical assignment. For this reason
it is essential to practise at home the examples and the work done during class. The
practical assignments cover only a part of the work done.
• During each practical class an assignment will be given that must be completed and
submitted for evaluation by the group leader.
• Remember: a program that does not work is worthless!
• Assignments not completed during class must be finished on your own time and sent
by e-mail to the group leader for evaluation before the next practical.
• Backups of all your programs and assignments must be kept and be available
with each practical class.
• Programs submitted late will result in a loss in marks.
• At the start of each practical session a new assignment will be started on.
• Copying another person’s work is a serious offence. Both the person guilty of copying
and the person making his/her work available, will forfeit marks and run the risk of
being denied admission to the examination.
HELP DURING PRACTICAL CLASSES
All practical classes will be in the micro laboratory and all must be in attendance.
Student assistants will be on hand to help you with the assignments during the
practical classes.
A practical assignment will not be evaluated if the student was absent from the
scheduled practical class.
The student assistants are responsible for evaluating the assignments. On
completion of a practical assignment the student assistant will award a mark.
The student assistant must get his/her group’s names and details, and students must
get the name and e-mail address of their student assistant.
BACKUP
The practical work must be saved on the P drive of the network. Each student must create
an extra backup of his/her assignments on a disk to ensure it is stored at two separate
places.
5

EVALUERING
KLASTOETSE
• Praktiese opdragte sowel as teorie-klastoetse sal weekliks gegee word ten einde jou in
staat te stel om jou deelnamebewys te verwerf en om jou vordering na waarde te skat.
• Klastoetse sal handel oor die werk wat die vorige week behandel is, maar kennis van
vorige werk is ook noodsaaklik.
• Klastoetse wat handel oor die vorige periode se werk kan ook sonder vooraf waarskuwing
gegee word.
• Elke gedeelte van die werk veronderstel 'n grondige kennis van die voorafgaande dele.
Elke gedeelte werk wat in die klas behandel word, moet dus onmiddellik bestudeer en
verstaan word. Jy moet dus sorg dat jy alles verstaan en kan gebruik.
• Oneerlikheid tydens klastoetse word as 'n baie ernstige oortreding beskou. Die
persoon wat hieraan skuldig is, sowel as die persoon wat sy werk beskikbaar gestel
het, sal hulle punte verbeur, en loop ook gevaar om eksamentoelating geweier te word.
DEELNAMEPUNT
Jou deelnamepunt word saamgestel uit:
• 50% vir klastoetse (teorie en prakties). Die swakste klastoetspunt sal nie bygereken
word nie en geen mediese sertifikate moet ingedien word indien jy ’n toets mis nie.
• 50% vir semestertoets (teorie en prakties).
VEREISTES VIR EKSAMENTOELATING
• ’n Deelnamebewys wat verkry word deur die skryf van die klastoetse en die
inhandiging van alle praktiese opdragte.
• 'n Deelnamepunt van minstens 40%.
• Die universiteit se regulasies rakende die tweede eksamengeleentheid geld vir hierdie
module.
6

EVALUATION
CLASS TESTS
• Both practical assignments and theory class tests will be written each week to evaluate
your progress and to enable you to obtain your proof of participation.
• Class tests will be on the work done the previous week, but knowledge of previous
work is also essential.
• Class tests on the previous period’s work may also be written without prior warning.
• Each part of the work suggests sound knowledge and understanding of the preceding
parts. It is therefore important to study and understand every piece of the work done in
class immediately. Make sure you understand and are able to use everything.
• Dishonesty during class tests is deemed a serious offence. A person guilty of this and
the person making his/her work available, will both forfeit marks and run the risk of
being denied admission to the examination.
PARTICIPATION MARK
Your participation mark is calculate in the following manner:
• 50% from class tests (theory and practical). The weakest mark is not taken into
account and no medical certificates must be submitted if you missed a test.
• 50% from the semester test (theory and practice).
EXAMINATION ADMISSION REQUIREMENTS
• Writing class tests and submitting all practical assignments give you proof of
participation.
• You must have a participation mark of at least 40%.
• University regulation regarding the second examination opportunity applies to this
module.
6

STUDIE-IKONE
Toets die stand van jou
kennis/insig
Belangrike inligting
Antwoorde / oplossings
Werksopdrag
Skryf die klastoets volgens
skedule
Herskryf hierdie stelling/ konsep
in jou eie woorde sodat jy
verduidelik wat dit beteken
Berei jouself voor vir deelname
oor hierdie onderwerp tydens
die kontaksessie /
groepbyeenkoms Dit is 'n goeie
voorbeeld van 'n eksamenvraag
Uitkomste
Voorbereiding vir die
kontaksessie / groepbyeenkoms
Geskatte studietyd
7

STUDY ICONS
Test your current
knowledge/insight.
Important information.
Answers/solutions.
Assignment.
Write the class test according
to schedule.
Rewrite this statement/ concept
in your own words so that its
meaning is explained.
Prepare yourself for participation
in the group meeting/contact
session on this issue. It is a
good example of an examination
question.
Outcomes.
Preparation for contact
session/group meeting.
Estimated study time.
7

WAARSKUWING TEEN PLAGIAAT
WERKSTUKKE IS INDIVIDUELE TAKE EN NIE GROEPAKTIWITEITE NIE (TENSY DIT
UITDRUKLIK AANGEDUI WORD AS ‘N GROEPAKTIWITEIT)
Kopiëring van teks van ander leerders of uit ander bronne (byvoorbeeld die studiegids,
voorgeskrewe studiemateriaal of direk vanaf die internet) is ontoelaatbaar – net kort
aanhalings is toelaatbaar en slegs indien dit as sodanig aangedui word.
U moet bestaande teks herformuleer en u eie woorde gebruik om te verduidelik wat u
gelees het. Dit is nie aanvaarbaar om bestaande teks/stof/inligting bloot oor te tik en die
bron in 'n voetnoot te erken nie – u behoort in staat te wees om die idee of begrip/konsep
weer te gee sonder om die oorspronklike skrywer woordeliks te herhaal.
Die doel van die opdragte is nie die blote weergee van bestaande materiaal/stof nie, maar
om vas te stel of u oor die vermoë beskik om bestaande tekste te integreer, om u eie
interpretasie en/of kritiese beoordeling te formuleer en om 'n kreatiewe oplossing vir
bestaande probleme te bied.
Wees gewaarsku: Studente wat gekopieerde teks indien sal 'n nulpunt vir die opdrag
ontvang en dissiplinêre stappe mag deur die Fakulteit en/of die Universiteit teen
sodanige studente geneem word. Dit is ook onaanvaarbaar om iemand anders se werk
vir hulle te doen of iemand anders in staat te stel om u werk te kopieer – moet dus nie
u werk uitleen of beskikbaar stel aan ander nie!
8

WARNING AGAINST PLAGIARISM
ASSIGNMENTS ARE INDIVIDUAL TASKS AND NOT GROUP ACTIVITIES. (UNLESS
EXPLICITLY INDICATED AS GROUP ACTIVITIES)
Copying of text from other learners or from other sources (for instance the study guide,
prescribed material or directly from the internet) is not allowed – only brief quotations are
allowed and then only if indicated as such.
You should reformulate existing text and use your own words to explain what you have read.
It is not acceptable to retype existing text and just acknowledge the source in a footnote –
you should be able to relate the idea or concept, without repeating the original author to the
letter.
The aim of the assignments is not the reproduction of existing material, but to ascertain
whether you have the ability to integrate existing texts, add your own interpretation and/or
critique of the texts and offer a creative solution to existing problems.
Be warned: students who submit copied text will obtain a mark of zero for the
assignment and disciplinary steps may be taken by the Faculty and/or University. It is
also unacceptable to do somebody else’s work, to lend your work to them or to make
your work available to them to copy – be careful and do not make your work available
to anyone!
8

1 DIE DIE ANALISE ANALISE ANALISE VAN
VAN
ALGORITMES
ALGORITMES ALGORITMES – DEEL DEEL 1
1
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op Hoofstuk 2 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
Leereenheid 1
• Die aksiomas rakende die gedetailleerde model van die rekenaar te kan weergee en
toepas;
• ’n program met ‘n dubbele lusstruktuur te kan ontleed;
• ’n rekursiewe funksie te kan ontleed;
• gemiddelde looptye te kan bepaal;
• die vereenvoudigde model van die rekenaar te kan verduidelik en toepas;
• ’n rekursiewe funksie met die vereenvoudigde model te kan ontleed; en
• ’n hersieningsoefening oor grafiese koppelvlakke te kan doen.
9

1. ANALYSIS ANALYSIS OF OF ALGORITH
ALGORITHMS
ALGORITH MS –
PART PART 1
1
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is based on Chapter 2 of the textbook.
On completion of this study unit you should be able to:
• Recall and apply the axioms regarding the detailed model of the computer;
• analyse a program with a double loop structure;
• analyse a recursive function;
• determine the average running time;
• explain and apply the simplified model of the computer;
• analyse a recursive function by using the simplified model; and
• do a revision exercise on graphic interfaces.
9

Berei voor in die handboek:
• Paragrawe 2.1.1 tot 2.1.6 – maak seker dat jy die aksiomas verstaan.
• Paragraaf 2.1.7 oor die gemiddelde looptyd van ’n funksie.
• Paragrawe 2.1.8 tot 2.1.9 kan oorgeslaan word.
• Paragraaf 2.1.10 oor die nuutste aksioma.
• Paragrawe 2.2.1 tot 2.2.6 oor die vereenvoudigde model van die rekenaar.
Doen oefeninge 2.1 (a, d, g).
Leereenheid 1
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Die voorbeeld op bladsy 23 en 24 is deurslaggewend. Sekere van die ouer handboeke het
’n drukfout op bl 24. Maak seker dat jou handboek reg is – hierdie fout sal tydens die
klasperiode uitgewys word.
Daar sal ‘n alternatiewe bewysmetode vir die stelling in paragraaf 2.2.2 in die klas bespreek
word. Maak seker dat jy dit verstaan.
Praktiese opdrag
Doen Opdrag 1 agter in die studiegids. Die datum van inhandiging sal aan die begin van die
week aangekondig word. Bestudeer klasbespreking 1 as hersiening van ITRW212 se werk.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
10

Prepare from the textbook:
• Paragraphs 2.1.1 – 2.1.6. Make sure that you understand axioms.
• Paragraph 2.1.7 on the average running time of a function.
• Paragraphs 2.1.8 and 2.1.9 can be skipped.
• Paragraphs 2.1.10 on the latest axioms.
• Paragraphs 2.2.1 – 2.2.6 regarding the simplified model of the computer.
Do exercises 2.1 (a, d, g).
Check your answers by comparing them with those provided by the lecturer. Sort out any
problems that you have with this section by the end of this week.
The example on pages 23 and 24 is significant. Some of the older textbooks have a printing
error on page 24. Make sure that your textbook is correct – the error will be pointed out to
you during class.
An alternative method of proving the premise in paragraph 2.2.2 will be discussed in class.
Make sure that you understand it.
Practical assignment
Do assignment 1 at the back of this study guide. The submission date will be announced at
the start of the week. Study Class Discussion 1 to review the work done in ITRW 212.
Make sure that you attained the outcomes set for this study unit.
10

2 DIE DIE ANALISE ANALISE ANALISE VAN
VAN
ALGORITMES
ALGORITMES ALGORITMES – DEEL DEEL 2
2
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op Hoofstuk 3 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• Die definisies van asimtotiese ontleding met insig te kan verduidelik;
• sekere van die stellings te kan bewys; en
• funksies asimtoties te kan ontleed.
Berei voor in die handboek:
• Paragraaf 3.1. Jy kan die bewyse van stellings 3.6 en 3.7 oorslaan.
• Paragraaf 3.2. Jy kan die bewys van stelling 3.8 oorslaan.
• Paragraaf 3.3. Maak seker dat jy hierdie definisies ken en verstaan.
• Paragraaf 3.4 oor die toepassing van asimtotiese ontleding.
Leereenheid 2
11

Study unit 2
2. ANALYSIS ANALYSIS OF OF ALGORITH
ALGORITHMS
ALGORITH MS –
PART PART 2
2
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is based on Chapter 3 in the textbook.
On completion of this study unit you should be able to:
• Explain with insight the definitions of asymptotic analysis;
• prove some of the premises; and
• analyse functions asymptotically.
Prepare from the textbook:
• Paragraph 3.1. You can skip the proof of Theorems 3.6 and 3.7.
• Paragraph 3.2. You can skip the proof of Theorem 3.8.
• Paragraph 3.3. Make sure you know and understand the definitions.
• Paragraph 3.4 on the application of asymptotic analysis.
11

Doen oefening 3.1.
Leereenheid 2
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Jy moet die stellings se bewyse nie as leerwerk beskou nie, maar eerder as toepassings van
die ander stelllings.
Praktiese opdrag
Doen Opdrag 2 agter in die studiegids. Die datum van inhandiging sal aan die begin van die
week aangekondig word.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
12

Do exercise 3.1.
Study unit 2
Compare your answers with those given to you by your lecturer. Be sure to sort out any
difficulties that you may have with the section by the end of this week.
The proof of the premises must not be regarded as work to be studied, but rather as
applications of the other premises.
Practical assignment
Do Assignment 2 at the back of the study guide. The submission date will be announced at
the start of the week.
Make sure that you attained the outcomes of this study unit.
12

3 SKIKKINGS SKIKKINGS EN EN MATRIKS
MATRIKSE
MATRIKS
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op paragrawe 4.1 en 4.2 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• Skikkings as datastrukture te kan gebruik;
• die “Object”-datatipe van Java te kan gebruik; en
• multidimensionele skikkings te kan gebruik.
Berei voor in die handboek:
Leereenheid 3
• Paragraaf 4.1 oor skikkings – dit is baie belangrike werk en moet verstaan word om die
res van die kursus te kan bemeester.
• Paragraaf 4.2 oor multidimensionele skikkings.
13

3. ARRAYS ARRAYS AND AND AND MATRIXES
MATRIXES
You will need approximately 10 hours to successfully complete this study unit.
This study unit is based on paragraphs 4.1 and 4.2 in the textbook.
At the end of this study unit you should be able to:
• Use arrays and data structures;
• use Java’s Object data type; and
• use multi-dimensional arrays.
Prepare from the textbook:
Study unit 3
• Paragraph 4.1 on arrays – the work is very important, and to master the remainder of
the course, you must understand this section.
• Paragraph 4.2 on multi-dimensional arrays.
13

Doen oefening 4.3.
Leereenheid 3
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Dis van kardinale belang dat jy die “Object”-datatipe/-klas begryp. Jy moet hierdie week se
prakties as die belangrikste van die hele semester beskou, omdat jy die volgende praktiese
opdragte op hierdie een bou.
Praktiese opdrag
Doen Opdrag 3 agter in die studiegids. Die datum van inhandiging sal aan die begin van die
week aangekondig word.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
14

Do exercise 4.3.
Study unit 3
Check your answers by comparing them with those provided by your lecturer. Be sure to sort
out any problems that you have with this section by the end of the week.
It is of absolute importance that you understand the Object data type/class. Consider the
practical work that you do this week as the most important of the semester. This assignment
will be the basis for the assignments that will follow.
Practical assignment
Do Assignment 3 at the back of the study guide. The submission date will be announced in
class at the start of the week.
Make sure you achieved all the outcomes set for this study unit.
14

4 GESKAKELDE GESKAKELDE LYSTE
LYSTE
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op paragraaf 4.3 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• Geskakelde lyste as datastrukture te kan gebruik; en
• die “Object”-datatipe van Java in geskakelde lyste te kan gebruik.
Berei voor in die handboek:
Leereenheid 4
Paragraaf 4.3 oor skikkings – dit is baie belangrike werk en moet verstaan word om die res
van die kursus te kan bemeester.
15

4. LINKED LINKED LISTS
LISTS
Study unit 4
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is based on paragraph 4.3 of the textbook.
At the end of this study unit you should be able to:
• Use linked lists as data structures; and
• use the Java’s Object data type in linked lists.
Prepare from the textbook:
Paragraph 4.3 on arrays. This is very important work and must be understood in order to
master the rest of the course.
15

Doen programmeringsoefening 4.3.
Leereenheid 4
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Dis van kardinale belang dat jy die “Object”-datatipe/-klas begryp. Hierdie week se prakties
gebruik nie die “Object”-klas nie – weet jy waarom nie?
Praktiese opdrag
Doen Opdrag 4 agter in die studiegids. Die datum van inhandiging sal aan die begin van die
week aangekondig word.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
16

Do programming exercise 4.3.
Study unit 4
Check your answers against those provided by your lecturer. Sort out any problems that you
have with this section by the end of the week.
It is of absolute importance that you understand the Object data type/class. The Object class
is not used in this week’s practical work – do you know why?
Practical assignment
Do Assignment 4 at the back of the study guide. The submission date will be announced in
class at the start of the week.
Make sure that you attained all outcomes set for this study unit.
16

Leereenheid 5
5 DATATIPES DATATIPES EN EN ABSTRAK
ABSTRAKSIE
ABSTRAK SIE –
DEEL DEEL 1
1
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op paragrawe 5.1 tot 5.2.4 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• Met insig te kan verduidelik wat abstrakte datatipes is;
• die klashiërargie van die handboek met insig te kan verduidelik;
• ’n koppelvlak te kan ontwerp;
• met insig te kan verduidelik wat “wrapper”-klasse is, en waarom dit nodig is om hulle te
gebruik;
• te weet wat houer-klasse is; en
• die “Object”-datatipe van Java te kan gebruik.
17

5. DATA DATA TYPES TYPES AND
AND
ABSTRACTION ABSTRACTION – PART PART 1
1
You will need approximately 10 hours to successfully complete this study unit.
This study unit is based on paragraphs 5.1 to 5.2.4 in the textbook.
At the end of this study unit you should be able to:
• Explain abstract data types with insight;
• explain the class hierarchy of the textbook with insight;
• design an interface;
• explain wrapper classes with insight and why it is necessary to use them;
• know what container classes are; and
• use Java’s Object data type.
Study unit 5
17

Berei voor in die handboek:
• Paragraaf 5.1 oor abstrakte datatipes.
• Paragraaf 5.2 oor ontwerpspatrone tot en met paragraaf 5.2.4.
• Klasbespreking 2 agter in die studiegids.
Doen oefening 5.3.
Leereenheid 5
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Studente beskou hierdie hoofstuk as die moeilikste van die kursus. Klasbespreking 2 is ’n
poging om die verduideliking van die handboek aan te vul. Werk die program deur en merk
elke program met ’n regmerkie as jy dit verstaan en ’n kruisie indien jy onseker is. Werk die
hele program aan die hand van die klasbespreking op hierdie manier deur. Wanneer jy klaar
is, herhaal dit en kyk of jy van die lyne wat met kruisies gemerk is, nou verstaan. Jy moet
besef dat jy hierdie program drie tot vier keer so op jou eie sal moet deurwerk voordat jy alles
sal verstaan. ’n Addisionele lesing sal geskeduleer word om individuele probleme op te los.
Jy moet egter eers jou probleme op hierdie manier identifiseer voordat jy die lesing bywoon.
Praktiese opdrag
Doen Opdrag 5 agter in die studiegids. Die datum van inhandiging sal aan die begin van die
week aangekondig word.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
18

Prepare from the textbook:
• Paragraph 5.1 on abstract data types.
• Paragraph 5.2 on design patterns up to paragraph 5.2.4.
• Class discussion 2 at the back of the study guide.
Do exercise 5.3.
Study unit 5
Compare your answers with those provided by your lecturer. Sort out all problems that you
have with this section by the end of this week.
This chapter is regarded by students to be the most difficult of the course. Class Discussion
2 attempts to elucidate the explanation that you find in the textbook. Study the program and
tick each one that you understand and make a cross next to the ones that you are unsure of.
Study the whole program with the aid of the Class Discussion in this manner. When you are
finished, repeat the process and check if the lines that you marked with a cross are now clear
to you. You will need to go through the program three to four times in this manner before you
will be able to understand it all. An extra lecture will be scheduled to answer any individual
problems there may be. You must identify your problems in this manner before attending the
lecture.
Practical assignment
Do Assignment 5 at the back of the study guide. The submission date will be announced in
class at the start of the week.
Make sure that you attained the outcomes of this study unit.
18

Leereenheid 6
6 DATATIPES DATATIPES EN EN ABSTRAK
ABSTRAKSIE
ABSTRAK SIE –
DEEL DEEL 2
2
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op paragrawe 5.2.5 tot 5.7 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• Met insig te kan verduidelik wat ontwerpspatrone is;
• die klashiërargie van die handboek met insig te kan verduidelik;
• ‘visitors’ met insig te kan verduidelik;
• ‘enumerations’ met insig te kan verduidelik; en
• te weet wat deursoekbare houerklasse is.
Berei voor in die handboek:
• Paragraaf 5.2.5 wat handel oor ‘visitors’.
• Paragraaf 5.2.6 wat handel oor ‘enumerations’.
• Paragraaf 5.2.7 wat handel oor ‘searchable containers’.
• Klasbespreking 2 agter in die studiegids.
19

6. DATA DATA TYPES TYPES AND
AND
ABSTRACTION ABSTRACTION – PART PART 2
2
Study unit 6
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is based on paragraphs 5.2.5 to 5.7 in the textbook.
At the end of this study unit you should be able to:
• Explain design patterns with insight;
• explain the class hierarchy of the textbook with insight;
• explain visitors with insight;
• explain enumerations with insight; and
• know what searchable container classes are.
Prepare from the textbook:
• Paragraph 5.2.5 regarding visitors.
• Paragraph 5.2.6 regarding enumerations.
• Paragraph 5.2.7 regarding searchable containers.
• Class Discussion 2 at the back of the study guide.
19

Doen oefening 5.3.
Leereenheid 6
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Praktiese opdrag
Gebruik hierdie week om seker te maak dat jy Opdrag 1-5 volledig verstaan.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
20

Do exercise 5.3.
Study unit 6
Compare your answers with those provided by your lecturer. Sort out any problems that you
may have with this section by the end of this week.
Practical assignment
Go through Assignments 1 – 5 this week and make sure that you understand them all
completely.
Make sure that you attained the outcomes of this study unit.
20

7 STAPEL STAPELS STAPEL
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op paragraaf 6.1 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• Stapels as datastrukture met insig te kan verduidelik;
• stapels met behulp van skikkings te kan implementeer; en
• stapels met behulp van geskakelde lyste te kan implementeer.
Berei voor in die handboek:
• Paragraaf 6.1 wat handel oor stapels.
• Paragraaf 6.1.1 wat handel oor stapels met behulp van skikkings.
• Paragraaf 6.1.2 wat handel oor stapels met behulp van geskakelde lyste.
• Paragraaf 6.1.3 wat handel oor die toepassings van stapels.
• Klasbespreking 3 agter in die studiegids.
Leereenheid 7
21

7. STACKS
STACKS
Study unit 7
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is based on paragraph 6.1 in the textbook.
At the end of this study unit you should be able to:
• Explain stacks as data structures with insight;
• implement stacks with the aid of arrays; and
• implement stacks with the aid of linked lists.
Prepare from the textbook:
• Paragraph 6.1 regarding stacks.
• Paragraph 6.1.1 regarding stacks with the aid of arrays.
• Paragraphs 6.1.2 on stack with the aid of linked lists.
• Paragraph 6.1.3 regarding the applications of stacks.
• Class Discussion 3 at the back of the study guide.
21

Doen oefening 6.1.
Leereenheid 7
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Dit is baie belangrik om nie kode te memoriseer nie. Jy sal soortgelyke kode in die eksamen
moet skryf oor vreemde probleme. Jy moet dus die kode verstaan! Jy moet Klasbespreking
3 op dieselfde manier as Klasbespreking 2 deurwerk.
Praktiese opdrag
Doen die stapelgedeelte en die skermuitleg van Opdrag 6.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
22

Do exercise 6.1.
Study unit 7
Check your answers by comparing them with those provided by you lecturer. Make sure that
you sort out any problems that you have with this section by the end of this week.
Please do not memorise code. In the examination you will have to write similar code for
unfamiliar problems. This implies that you have to understand the code! Work through Class
Discussion 3 in the same manner as you did Class discussion 2.
Practical assignment
Do the sections on stacks and screen layout of Assignment 6.
Make sure that you attained the outcomes of this study unit.
22

8 TOUE
TOUE
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op paragraaf 6.2 - 6.3 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• Toue as datastrukture met insig te kan verduidelik;
• toue met behulp van skikkings te kan implementeer;
• toue met behulp van geskakelde lyste te kan implementeer; en
• “dequeues” met insig te kan verduidelik.
Leereenheid 8
23

8. QUEUES
QUEUES
Study unit 8
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is base on paragraph 6.2 and 6.3 of the textbook.
At the end of this study unit you should be able to:
• Explain queues as data structures with insight;
• implement queues with the aid of arrays;
• implement queues with the aid of linked lists; and
• explain dequeues with insight.
23

Berei voor in die handboek:
• Paragraaf 6.2 wat handel oor toue.
• Paragraaf 6.2.1 wat handel oor toue met behulp van skikkings.
• Paragraaf 6.2.2 wat handel oor toue met behulp van geskakelde lyste.
• Paragraaf 6.2.3 wat handel oor die toepassings van toue.
• Paragraaf 6.3 wat handel oor "dequeues".
• Klasbespreking 3 agter in die studiegids.
Doen oefening 6.7.
Leereenheid 8
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Dit is baie belangrik om nie kode te memoriseer nie. Jy sal soortgelyke kode in die eksamen
moet skryf oor vreemde probleme. Jy moet dus die kode verstaan!
Praktiese opdrag
Doen Opdrag 6 volledig.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
24

Prepare from the textbook:
• Paragraph 6.2 regarding queues.
• Paragraph 6.2.1 regarding queues with the aid of arrays.
• Paragraph 6.2.2 regarding queues with the aid of linked lists.
• Paragraph 6.2.3 regarding the applications of queues.
• Paragraph 6.3 on dequeues.
• Class Discussion 3 at the back of the study guide.
Do exercise 6.7.
Study unit 8
Check your answers by comparing them with those provided by you lecturer. Make sure that
you sort out any problems that you have with this section by the end of this week.
Please do not memorise code. You will have to write similar code for unfamiliar problems
during the examination. This implies that you have to understand the code!
Practical assignment
Complete Assignment 6.
Make sure that you attained all the outcomes set for this study unit.
24

9 GEORDENDE GEORDENDE LYSTE
LYSTE
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op paragraaf 7.1 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• Geordende lyste as datastrukture met insig te kan verduidelik;
• geordende lyste met behulp van skikkings te kan implementeer; en
• geordende lyste met behulp van geskakelde lyste te kan implementeer.
Berei voor in die handboek:
• Paragraaf 7.1 wat handel oor geordende lyste.
• Paragraaf 7.1.1 wat handel oor geordende lyste met behulp van skikkings.
Leereenheid 9
• Paragraaf 7.1.2 wat handel oor geordende lyste met behulp van geskakelde lyste.
• Paragraaf 7.1.3 wat handel oor die vergelyking tussen skikkings en geskakelde lyste.
• Paragraaf 7.1.4 wat handel oor die toepassing van geordende lyste.
25

9. ORDERED ORDERED LISTS
LISTS
Study unit 9
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is based on paragraph 7.1 in the textbook.
At the end of this study unit you should be able to:
• Explain ordered lists as data structures with insight;
• implement ordered lists with the aid of arrays; and
• implement ordered lists with the aid of linked lists.
Prepare from the textbook:
• Paragraph 7.1 regarding ordered lists.
• Paragraph 7.1.1 on ordered lists with the aid of arrays.
• Paragraph 7.1.2 on ordered lists with the aid of linked lists.
• Paragraph 7.1.3 on the comparison between arrays and linked lists.
• Paragraph 7.1.4 on the application of ordered lists.
25

Doen oefening 7.2.
Leereenheid 9
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Dit is baie belangrik om nie kode te memoriseer nie. Jy sal soorgelyke kode in die eksamen
moet skryf oor vreemde probleme. Jy moet dus die kode verstaan!
Praktiese opdrag
Doen Opdrag 7.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
26

Do exercise 7.2.
Study unit 9
Check your answers by comparing them with those provided by your lecturer. Sort out any
difficulties that you have with this section by the end of this week.
Please do not memorise code. You will have to write similar code for unfamiliar problems in
the examination. This implies that you have to understand the code!
Practical assignment
Do Assignment 7.
Make sure that you attained all the outcomes of this study unit.
26

10 10 GESORTEERDE GESORTEERDE LYSTE
LYSTE
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op paragraaf 7.2 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• Gesorteerde lyste as datastrukture met insig te kan verduidelik;
• gesorteerde lyste met behulp van skikkings te kan implementeer; en
• gesorteerde lyste met behulp van geskakelde lyste te kan implementeer.
Berei voor in die handboek:
• Paragraaf 7.1 wat handel oor gesorteerde lyste.
• Paragraaf 7.2.1 wat handel oor gesorteerde lyste met behulp van skikkings.
Leereenheid 10
• Paragraaf 7.2.2 wat handel oor gesorteerde lyste met behulp van geskakelde lyste.
• Paragraaf 7.2.3 wat handel oor die vergelyking tussen skikkings en geskakelde lyste.
• Paragraaf 7.2.4 wat handel oor die toepassing van gesorteerde lyste.
27

10. 10. SORTED SORTED SORTED LISTS
LISTS
Study unit 10
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is based on paragraph 7.2 of the textbook.
At the end of this study unit you should be able to:
• Explain sorted lists as data structures with insight;
• implement sorted lists with the aid of arrays; and
• implement sorted lists with the aid of linked lists.
Prepare from the textbook:
• Paragraph 7.1 regarding sorted lists.
• Paragraph 7.2.1 on sorted lists with the aid of arrays.
• Paragraph 7.2.2 on sorted lists with the aid of linked lists.
• Paragraph 7.2.3 on the comparison between arrays and linked lists.
• Paragraphs 7.2.4 on the application of sorted lists.
27

Doen oefening 7.2.
Leereenheid 10
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Dit is baie belangrik om nie kode te memoriseer nie. Jy sal soortgelyke kode in die eksamen
moet skryf oor vreemde probleme. Jy moet dus die kode verstaan!
Praktiese opdrag
Jy moet hierdie week vir jou praktiese toets voorberei.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
28

Do exercise 7.2.
Study unit 10
Check your answers by comparing them with those provided by the lecturer. Sort out any
problems that you have with this section by the end of this week.
Please do not memorise code. You must write similar code for unfamiliar problems during the
examination. This implies that you have to understand the code!
Practical assignment
Prepare for the practical test.
Make sure that you attained the outcomes set for this study unit.
28

Leereenheid 11
11 11 SORTERINGSALGORITMES SORTERINGSALGORITMES -
DEEL DEEL 1
1
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op paragrawe 15.1 tot 15.5 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• ’n Verskeidenheid sorteer-algoritmes te kan implementeer en analiseer; en
• verskillende sorteer-algoritmes met mekaar te kan vergelyk.
29

11. 11. SORTING SORTING ALGORITHMS ALGORITHMS -
PART PART 1
1
Study unit 11
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is based on paragraphs 15.1 to 15.5 in the textbook.
At the end of this study unit you should be able to:
• Implement and analyse a variety of sorting algorithms; and
• compare various sorting algorithms.
29

Berei voor in die handboek:
• Paragrawe 15.1 en 15.2 wat handel oor sortering in die algemeen.
• Paragraaf 15.3 wat handel oor invoeging.
• Paragraaf 15.4 wat handel oor omruiling.
• Paragraaf 15.5 wat handel oor seleksie.
• Paragraaf 15.6 wat handel oor samevoeging.
• Paragraaf 15.7 wat handel oor ’n ondergrens vir sortering.
• Paragraaf 15.8 wat handel oor verspreiding.
Doen oefening 15.5.
Leereenheid 11
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Dit is baie belangrik om nie kode te memoriseer nie. Jy sal soortgelyke kode in die eksamen
moet skryf oor vreemde probleme. Jy moet dus die kode verstaan!
Praktiese opdrag
Jy moet hierdie week vir jou praktiese toets voorberei.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
30

Prepare from the textbook:
• Paragraphs 15.1 and 15.2 on sorting in general.
• Paragraph 15.3 on insertion.
• Paragraph 15.4 on exchange.
• Paragraph 15.5 on selection.
• Paragraph 15.6 on merging.
• Paragraph on a lower bound on sorting.
• Paragraph 15.8 on distribution.
Do exercise 15.5.
Study unit 11
Check your answers by comparing them with those provided by your lecturer. Sort out any
problems that you have with this section by the end of this week.
Please do not memorise code. In the examination you will have to write similar code for
unfamiliar problems. This implies that you have to understand the code!
Practical assignment
Prepare for the practical test.
Make sure that you attained all the outcomes set for this study unit.
30

Leereenheid 12
12 12 SORTERINGSALGORITMES SORTERINGSALGORITMES -
DEEL DEEL 2
2
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Hierdie leereenheid is op paragrawe 15.6 tot 15.9 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• ’n Verskeidenheid sorteer-algorimes te kan implementeer en analiseer; en
• verskillende sorteer-algoritmes met mekaar te kan vergelyk.
Berei voor in die handboek:
• Paragraaf 15.6 wat handel oor samevoeging.
• Paragraaf 15.7 wat handel oor ’n ondergrens vir sortering.
• Paragraaf 15.8 wat handel oor verspreiding.
• Paragraaf 15.9 wat handel oor “performance data.”
31

12. 12. SORTING SORTING ALGORITHMS ALGORITHMS –
PART PART 2
2
Study unit 12
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is based on paragraphs 15.6 to 15.9 in the textbook.
At the end of the study unit you must be able to:
• Analyse and implement a variety of sorting algorithms; and
• compare various sorting algorithms.
Prepare from the textbook:
• Paragraph 15.6 regarding merging.
• Paragraph 15.7 on the lower bound on sorting.
• Paragraph 15.8 on distribution.
• Paragraph 15.9 on performance data.
31

Doen oefening 15.11.
Leereenheid 12
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Dit is baie belangrik om nie kode te memoriseer nie. Jy sal soortgelyke kode in die eksamen
moet skryf oor vreemde probleme. Jy moet dus die kode verstaan! Aan die einde van die
studiegids is ’n voorbeeld van ’n eksamenvraestel vir hierdie module. Gebruik dit om jou
vordering te meet.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
32

Do exercise 15.11.
Study unit 12
Compare your answers with those provided by your lecturer. Sort out any difficulties that you
have with this section by the end of this week.
Please do not memorise code. You will have to write similar code for unfamiliar problems in
the examination. This implies that you have to understand the code! At the end of the study
guide you will find an example of an examination paper for this module. Evaluate your
progress by completing it.
Make sure that you attained the outcomes set for this study unit.
32

13 13 BOME BOME EN EN GRAFIEKE
GRAFIEKE
Jy behoort ongeveer 10 uur te neem om hierdie leereenheid suksesvol deur te werk.
Leereenheid 13
Hierdie leereenheid is op paragrawe 9.1 tot 9.3 en 16.1 tot 16.3 van die handboek gebaseer.
Aan die einde van hierdie leereenheid behoort jy:
• Die basiese teorie oor bome te kan weergee;
• die basiese teorie oor grafieke te ken; en
• die verskillende maniere om deur bome en grafieke te beweeg te ken.
Berei voor in die handboek:
• Paragraaf 9.1 – 9.3 wat handel oor basiese bome en binêre bome.
• Paragraaf 16.1 – 16.3 wat handel oor die basiese teorie oor grafieke.
33

13. 13. TREES TREES AND AND GRAPHS
GRAPHS
Study unit 13
You will need approximately 10 hours to successfully complete the work in this study unit.
This study unit is based on paragraphs 9.1 to 9.3 and 16.1 to 16.3 in the textbook.
At the end of this study unit you should be able to:
• Explain the basic theory regarding trees;
• know the basic theory regarding graphs; and
• know the different ways to move through trees and graphs.
Prepare from the textbook:
• Paragraph 9.1 to 9.3 on basic trees and binary trees.
• Paragraph 16.1 to 16.3 on the basic theory of graphs.
33

Doen oefening 9.1 en 16.4.
Leereenheid 13
Kontroleer jou antwoorde met dié wat deur die dosent beskikbaar gestel word. Maak seker
dat jy hierdie week al jou probleme met hierdie afdeling uitsorteer.
Dit is baie belangrik om die teorie te ken rakende bome en grafieke.
Maak seker dat jy al die uitkomste van hierdie leereenheid bereik het.
34

Do exercise 9.1 and 16.4.
Study unit 13
Check your answers by comparing them with those provided by your lecturer. Sort out any
difficulties that you have with this section by the end of this week.
It is very important to know the theory regarding trees and graphs.
Make sure you have reached the outcomes set for this study unit.
34

BYLAAG 1 - PRAKTIESE Opdragte
Bylaag 2 - Klasbesprekings
35

Appendix 2
APPENDIX 1 - PRACTICAL ASSIGNMENTS
35

OPDRAG 1: INGEEDATUM: ______________________
Bylaag 2 - Klasbesprekings
Skryf ’n Java-applet wat ’n onbekende aantal heelgetalle een na die ander in ’n TextField sal
inlees (die gebruiker druk Enter tussen die getalle). Die applet moet deur middel van ’n
Label die gesorteede lys van getalle vertoon. Let op die volgende:
• Gebruik ’n vektor (array) om die getalle in te stoor. (Onthou om die string van die
TextField na ’n Integer oor te skakel.)
• Sorteer die vektor na elke nuwe getal ingelees is.
• Onthou om die Label vir die vektor vol leë karakters te verklaar.
• Bou die Label van vooraf elke keer vanaf die vektor op.
36

Appendix 2
ASSIGNMENT 1: SUBMISSION DATE: ______________________
Write a Java applet that will read an unknown number of integers one after the other in a
TextField. (The user press Enter in between the numbers). The applet must display the
sorted list of numbers by using a Label. Take note of the following:
• Use a vector (array) to store the numbers in. (Remember to switch the string of the
TextField to an Integer)
• Sort the vector after reading each new number.
• Remember the Label for the vector must be declared full of empty characters.
• Each time rebuild the Label from the vector.
36

Bylaag 2 - Klasbesprekings
OPDRAG 2: INGEEDATUM: ___________________________
Verander Opdrag 1 sodat die gebruiker die keuse het om óf die oorspronklike óf die
gesorteerde vektor te sien. Plaas twee Button-objekte op die applet. Let op die volgende:
• Daar is nou drie objekte wat Events kan genereer, naamlik die TextField en die twee
Buttons.
• Die vektor moet gesorteer word wanneer die TextField die Event genereer.
• Onthou om nou ook ’n tweede vektor te maak om die oorspronklike getalle in te stoor.
• Ek het ’n vlaggie (wat verander word as ’n Button gedruk word) gebruik om vas te stel
watter vektor vertoon moet word.
• Wanneer ‘n Button gedruk word, moet die Label dadelik na die regte vektor verander
word en so bly totdat die ander Button weer gedruk word.
BEGIN BETYDS - Dis meer werk as wat jy dink!!!
37

Appendix 2
ASSIGNMENT 2: SUBMISSION DATE: _________________________
Change Assignment 1 to allow the user to see either the original or sorted vector. Place two
Button objects on the applet. Note the following:
• There are three objects able to generate Events: the TextField and two Buttons.
• The vector must be sorted when the TextfField generates the Event.
• Remember to generate a second vector to store the original numbers in.
• I used a flag (that changes and prints as a Button) to determine which vector must be
displayed.
• When the Button is pressed, the Label must immediately change to the correct vector
and remain so until the Button is pressed again.
START NOW - This is much more work than you think!!
37

Bylaag 2 - Klasbesprekings
OPDRAG 3: INGEEDATUM: _____________________________
HERHAAL OPDRAG 1 deur gebruik te maak van die handboek se Array-klas.
Let op:
• Gestel jy het:
Array arr;
arr = new Array(20);
• Wanneer put geroep word vir ’n drywer wat met heelgetalle werk, doen dit soos volg:
arr.put(i, new Integer (num));
waar i die posisie van die element in ’n vektor is, en
num ’n heelgetal is wat met Integer.parseInt() van die teksveld afgelees is.
• Wanneer get geroep word, doen dit soos volg:
num2 = (Integer)arr.get(k)
Arrstring += num2.toString();
JY MOET ALLES IN HIERDIE OPDRAG VERSTAAN OM HIERDIE VAK TE SLAAG!!!!!
38

Appendix 2
ASSIGNMENT 3: SUBMISSION DATE: _________________________
REPEAT ASSIGNMENT 1 by using the textbook’s Array class.
Take note:
• Suppose you have:
Array arr;
arr = new Array(20);
• When put is called for a drive that operates with integers, you do it like this:
arr.put(i , new Integer (num));
when i is the position of an element in a vector, and
num is an integer read with Integer.parselnet() from the text field.
• When calling get, do it this way:
num2 = (Integer)arr.get(k)
Arrstring += num2.toString();
YOU MUST UNDERSTAND EVERY ASPECT OF THIS
ASSIGNMENT TO PASS THIS SUBJECT!!
38

Bylaag 2 - Klasbesprekings
OPDRAG 4: INGEEDATUM: _____________________________
HERHAAL OPDRAG 1 DEUR GEBRUIK TE MAAK VAN 'N GESKAKELDE LYS
Skryf ’n Java-applet wat ’n onbekende aantal heelgetalle een na die ander in ’n TextField sal
inlees (die gebruiker druk Enter tussen die getalle). Die applet moet deur middel van ’n
Label die gesorteede lys van getalle vertoon. Let op die volgende:
• Gebruik ’n gesorteerde geskakelde lys om die getalle in te stoor. Ontwerp ’n klas
LinkedList wat ‘n gesorteerde geskakelde lys van heelgetalle bestuur. Die klas moet
die volgende bevat:
Ε Datalede vir head en tail die begin en die einde van die lys.
Ε Metodes:
- Purge (maak lys skoon) wat in die constructor geroep word;
- isEmpty wat toets of die lys leeg is;
- insertSorted wat ’n getal op die regte plek in die sorteerde geskakelde lys sal
invoeg;
- toString wat ’n string opbou wat uit die lys se elemente bestaan en ’n string
genereer; en
- Toegangsfunksies vir die datalede.
Ε Volg die gebruik van die handboek om van ’n inner-klas vir die elemente gebruik
te maak. Jou elemente moet int wees en nie Object nie.
• Skryf ’n aandrywer Applet as gebruikerskoppelvlak vir die geskakelde lys.
Ε Die drywer mag nie deur die lys soek nie.
Ε Die drywer mag nie die lys element vir element vertoon nie.
Ε Die drywer bevat ‘n object van die LinkedList klas en roep slegs die metodes van
die klas.
39

Appendix 2
ASSIGNMENT 4: SUBMISSION DATE: _________________________
REPEAT ASSIGNMENT 1 BY MAKING USE OF A LINKED LIST
Write a Java applet that will read an unknown number of integers one after the other in a
Textfield (The user presses Enter in between the numbers). The applet must display the
sorted list of numbers by making use of a Label. Note the following:
• Use a sorted linked list to store the numbers in. Design a class LinkedList that
manages a sorted linked list of integers. The class must have the following:
• Data members for head and tail, the start and end of the list.
• Methods:
- urge (clean the list) that is called in the constructor;
- sEmpty tests if the list is empty;
- nsertSorted will place a number in the correct place in a sorted linked list.
- oString builds up a string consisting list’s elements and generates a string;
- access functions for data members.
• Follow the way in the textbook to make use of an inner class for elements. You
elements must be int, not Object.
• Write an actuator/drive Applet as a user interface for the linked list.
The drive may not search through the list.
The drive may not display the list the elements consecutively.
The drive contains an object from the LinkedList class and calls only the methods of
this class.
39

Bylaag 2 - Klasbesprekings
OPDRAG 5: INGEEDATUM: ____________________________
Hierdie is ‘n generiese opdrag om polymorfisme en oorerwing in Java te toets. Jy moet:
• ’n Interface met die naam Basis skep wat uit vier metodes bestaan, naamlik:
Ε double met01()
Ε double met02()
Ε double met03()
Ε String wie()
• Skep ’n klas met die naam KlasA wat die basis implementeer deur:
Ε Twee double veranderlikes te verklaar (v1 en v2)
Ε met01() hoef slegs v1 terug te stuur en met02() v2
Ε met03() stuur die som van v1 en v2 terug
Ε wie() stuur die string “KlasA” terug
• Skep ’n klas met die naam KlasA1 wat ‘n subklas van KlasA is:
Ε Daar moet nog twee veranderlikes bygevoeg word, naamlik v3,v4
Ε met04() en met05() moet v3 en v4 onderskeidelik terugstuur
Ε wie() stuur die string “KlasA1” terug
Ε met03() stuur die antwoord van die formule v1*v2+v3 terug
• Skep ’n klas met die naam KlasA2 wat ‘n subklas van KlasA is:
Ε Daar moet nog twee veranderlikes bygevoeg word, naamlik v3,v4
Ε met08() en met07() moet v3 en v4 onderskeidelik terugstuur
Ε wie() stuur die string “KlasA2” terug
Ε met03() stuur die antwoord van die formule v1*v2+v4 terug
• Skryf ’n aandrywerprogram wat:
Ε ’n verwysing na basis, naamlik b verklaar
Ε ’n objek van KlasA, naamlik a maak (met waardes: 3,4)
Ε ’n objek van KlasA1, naamlik a1 maak (met waardes: 3,4,2,5)
Ε ’n objek van KlasA2, naamlik a2 maak (met waardes: 2,1,3,2)
40

Appendix 2
ASSIGNMENT 5: SUBMISSION DATE: _________________________
This is a generic assignment to test polymorphism and inheriting in Java. You must:
• Create an Interface with the name Base that consists of 4 methods:
double met01()
double met02()
double met03()
String wie()
• Create a class with the name ClassA the implements the base by:
Declaring two double variables (v1 en v2)
met01() need only send v1 back and met02() v2
met03() sends the sum of v1 and v2 back
wie() sends the string “ClassA” back
• Create a class with the name ClassA1, a sub-class of ClassA:
Two other variables must be added, they are v3, v4
met04() and met05() must respectively send v3 and v4 back
wie() sends the string “ClassA1” back
met03() sends the answer of the formula v1*v2 +v3 back
• Create a class with the name ClassA2, a sub-class of ClassA:
Two other variables must be added, they are v3, v4
met08() and met07() must respectively send v3 and v4 back
wie() sends the string “ClassA2” back
met03() sends the answer of the formula v1*v2+v4 back
• Write a driver program that:
declares a reference to base, namely b
make an object of ClassA, namely a (with values 3,4)
make an object of ClassA1, namely a1 (with values 3,4,2,5)
make an object of ClassA2, namely a2 (with values 2,1,3,2)
40

• Daar moet vir elkeen van die klasse die volgende gedoen word:
Bylaag 2 - Klasbesprekings
Ε Die wie() metode deur static-binding roep en met drawstring vertoon word
Ε Die objek aan b toeken
Ε Roep weer die wie() metode, maar die keer deur die objek b (dynamic binding)
en vertoon die resultaat
Ε Roep die met03() metode ook deur die objek b en vertoon die resultaat.
41

• The following must be done for each of the classes:
Call the wie() method through static binding and be displayed with drawstring.
Award the object to b.
Appendix 2
Call the wie() method again, but this time through object b (dynamic binding) and
display the result.
Also call the met03() method through object b and display the result.
41

Bylaag 2 - Klasbesprekings
OPDRAG 6: INGEEDATUM: _____________________________
Hierdie opdrag behels die volgende:
• Oorerwing
• Polimorfisme
• “BorderLayout”
• “Panels”
• “Radio Buttons”
Bestudeer die volgende twee skermuitdrukke:
42

Appendix 2
ASSIGNMENT 6: SUBMISSION DATE: _________________________
This assignment comprises of the following:
• Inheriting;
• Polymorphism;
• BorderLayout;
• Panels; and
• Radio Buttons.
Study the following screen prints:
42

Hoe werk die Applet?
• Daar is net twee Buttons op die applet: ’n byvoeg en ’n weglaat Button.
Bylaag 2 - Klasbesprekings
• Die Buttons se teks verander na aanleiding van die keuse van die Radio Buttons.
• Buttons se teks word met setLabel() verander bv addButton.setLabel(“Pop”).
• Wanneer Dequeue of Pop gedruk word, verskyn die getal wat uit die lys gehaal word in
die TextBox. Indien die lys leeg is verskyn daar ’n –1.
• Die korrekte lys moet vertoon word na aanleiding van die Radio Button.
• Gebruik BorderLayout vir die Applet-ontwerp.
• Omdat jy meer as een item in die middel wil plaas, moet jy hulle eers op ’n panel sit en
dan die panel in die middel plaas.
• ’n Panel kan sy eie Layout Manager hê. Ek het ‘n (3,1) rooster gebruik.
• Jy moet net drie dinge doen na aanleiding van die Radio Button:
Ε ‘n Indeks veranderlike van die vektor stel;
Ε Die addButton se teks verander;
Ε Die RemoveButton se teks verander.
BELANGRIK - Ons gebruik polimorfisme om die add, remove en die vertoonlys te doen.
• Maak ’n vektor met twee posisies van wysers na die basisklas.
• Stel een van die posisies gelyk aan die een subklas en die ander een gelyk aan die
ander subklas.
• Roep die add-, remove- of list-funksie deur die vektor bv lys[index].add()
Ε As jy totaal verward is, kyk na die Shapes-voorbeeld in die notas op bl 393 wat
voor die vakansie uitgedeel is.
KLASSTRUKTUUR
Basisklas – abstrakte klas LinkedList met innerclas Element
Datalede: head, tail en count
Abstrakte metodes: add() en remove()
Metodes: purge(), getCount(), isEmpty(), toString() en dan die standaard Element-klas
Subklas 1: Stack wat van LinkedList oorerf
Datalede: niks ekstra
Metodes: add() en remove() en die submetodes wat hulle gebruik soos prepend()
Kyk in die handboek vir die kode, herskryf extract()
43

How does the Applet work?
• There are only two Buttons on the applet: an add and an omit Button.
Appendix 2
• The text of the Buttons changes in accordance with the choice made on the Radio
Buttons.
• The text of the Buttons is changed with setLabel(), for example, addButton.setLabel
(“Pop”).
• When Dequeue or Pop is pressed, the number taken from the list is displayed in the
TextBox. If the list is empty, only a 1 will be displayed.
• The correct list must display as a result of the Radio Button.
• Use BorderLayout for the design of the Applet.
• Because you want to place more than on item in the centre, you first need to place the
items in a panel. After this you can place the panel in the centre.
• A Panel can have its own Layout Manager. I used a (3,1) grid.
• There are three things you must do in connection with the Radio Button:
Set an index variable of the vector;
Change the text of the addButton;
Change the text of the RemoveButton.
IMPORTANT - We use polymorphism to do the add, remove and display list.
• Make a vector with two positions of pointers towards the base class.
• Set one of the positions equal to the one subclass and other equal to the other
subclass.
• Use the vector to call the add, remove or list functions, for example, lys[index].add()
If you are completely confused, take a look at the Shapes example in the notes on
page 393 that I handed to you before the holiday.
CLASS STRUCTURE
Base class – abstract class LinkedList with innerclass Element
Data members: head, tail and count
Abstract methods: add() en remove()
Methods: purge(), getCount(), isEmpty(), toString() and the standard Element class.
Subclass 1: Stack inheriting from LinkedList
Data members: nothing extra
Methods: add() and remove() and the sub methods they use, such as prepend()
Look in the textbook for the code, rewrite extract()
43

Subklas 2: Queue wat van LinkedList oorerf
Datalede: niks ekstra
Bylaag 2 - Klasbesprekings
Metodes: add() en remove() en die submetodes wat hulle gebruik soos append()
Kyk in die handboek vir die kode, herskryf extract()
• Die add() en remove() metodes moet natuurlik met Integer-parameters werk en jy moet
self uitwerk hoe dit moet wees!
INDIEN JY HIERDIE OPDRAG SELF REGKRY, BEHOORT JY IN DIE
PRAKTIESE EKSAMEN SUKSESVOL TE WEES!!
ONTHOU JY IS VERONDERSTEL OM TE GENIET WAT JY DOEN!
44

Subclass 2: Queue inherited from LinkedList
Data members: nothing extra
Methods: add() and remove() and the sub methods they use such as append()
Look in your textbook for the code and rewrite extract()
Appendix 2
• Obviously the add() and remove() methods must function with Integer parameters and
you must calculate how it must be!
YOU SHOULD BE SUCCESSFUL IN THE EXAMINATION IF YOU ARE ABLE TO
COMPLETE THIS ASSIGNMENT BY YOURSELF.
REMEMBER, YOU ARE SUPPOSED TO ENJOY WHAT YOU ARE DOING!
44

Bylaag 2 - Klasbesprekings
OPDRAG 7: INGEEDATUM: ____________________________
Hierdie program behels slegs klein veranderings aan Opdrag 6:
• Jy moet exception handling doen in plaas daarvan om ’n –1 terug te stuur wanneer die
stapel of die tou leeg is.
• Jy moet jou eie exception skep.
• Die removeItem() metode moet die uitsondering throw.
• Die try en catch moet in jou drywerprogram gedoen word.
• Jy moet ’n foutboodskap in die vorm van ’n window op die skerm vertoon.
• Onthou die throws in die funksies se opskrifte.
45

Appendix 2
ASSIGNMENT 7: SUBMISSION DATE: _________________________
This program comprises small changes to Assignment 6.
• You must do exception handling instead of sending back a 1 when a stack or queue is
empty.
• You must create your own exception.
• The removeItem() method must throw the exception.
• The try and catch must be done in you drive program.
• You must display an error message in a window on the screen.
• Remember the throws in the headings of the functions.
45

BYLAAG 2 – KLASBESPREKINGS
Bylaag 2 - Klasbesprekings
46

APPENDIX 2 – CLASS DISCUSSIONS
Appendix 2
46

KLASBESPREKING 1
Bylaag 2 - Klasbesprekings
Ontwikkel ’n klas en toepassing om studente se punte te hanteer. Jou program moet uit
twee lêers bestaan:
1. ’n Volledige klas vir studente met:
• Datalede (attributes) vir naam, punt1, punt2 en gemiddeld.
• Daar moet twee “constructors” wees. Een moet waardes van die gebruiker aan die
datalede toeken. Die ander “constructor” ontvang geen parameters nie en roep die
eerste “constructor” met nul datavelde.
• Die “constructor” moet die stelfunksies gebruik om die waardes van die datalede te
inisieer.
• Daar moet toegangsfunksies (methods) vir elke datalid wees.
• Die stelfunksies vir die punte moet die punte toets om seker te maak dat dit tussen
0 en 100 is (validate).
• Daar moet ’n funksie wees om die gemiddeld te bereken.
• Compile die klas met javac, maar aangesien dit nie ’n program of applet is nie, kan
jy dit nie uitvoer nie.
2. ’n Applet wat:
• Die gebruikerskoppelvlak van die studenteklas is om die datalede van die klas te
stel.
• Jy moet ’n vektor van 5 studente-objekte skep. Dit is baie belangrik om die objekte
een vir een in ’n for-lus te skep, sodoende word daar geheue vir elkeen toegewys.
• Gebruik drie Buttons om onderskeidelik die datalede te stel, die volgende vektorposisie
te vertoon en die vorige vektorposisie te vertoon.
• Die posisie in vektor moet ook op die skerm vertoon word.
• Dit is baie belangrik om seker te maak dat die Buttons nie toegang buite die grense
van die vektor veroorsaak nie.
47

CLASS DISCUSSION 1
Appendix 2
Develop a class and application to handle student marks. Your program must consist of two
files:
1. A complete class for students with:
• Data members (attributes) for name, mark1, mark2 and average.
• There must be two constructors. One must allocate values of the user to the data
members. The other constructor receives no parameters and calls the first constructor
with zero data fields.
• The constructor must use the set functions to initiate the values of the data members.
• There must be access functions (methods) for each data member.
• The set functions for the marks must test them to ensure that they are between 0 and
100 (validate).
• There must be a function that calculates the average.
• Compile the class with java, you cannot carry this out though, because it is neither a
program nor an applet.
2. An Applet that:
• Is the user interface of the student class to set the data members of the class.
• You must create a vector of five student objects. It is very important to create the
objects one by one in a for loop. By doing this, memory is allocated to each.
• Use three Buttons to set the data members severally, display the next vector position
and display the previous vector position.
• The position of the vector must also be displayed on the screen.
• It is very important to ensure that the Buttons do not create access outside the borders
of the vector.
47

public class Student
{
private String name;
private double mark1, mark2, average;
Student(String n, double m1, double m2)
{
}
setName(n);
setMark1(m1);
setMark2(m2);
computeAverage();
Student()
{
}
this(" ",0,0);
public void setName(String studentName)
{
}
name = studentName;
public void setMark1(double studentMark1)
{
}
if (studentMark1>=0 && studentMark1 =0 && studentMark2

public class Student
{
private String name;
private double mark1, mark2, average;
Student(String n, double m1, double m2)
{
}
setName(n);
setMark1(m1);
setMark2(m2);
computeAverage();
Student()
{
}
this(" ",0,0);
public void setName(String studentName)
{
}
name = studentName;
public void setMark1(double studentMark1)
{
}
if (studentMark1>=0 && studentMark1 =0 && studentMark2

}
public double computeAverage()
{
}
average = (mark1+mark2)/ (double) 2;
return average;
public String getName()
{
}
return name;
public double getMark1()
{
}
return mark1;
public double getMark2()
{
}
return mark2;
public double getAvg()
{
}
return average;
Bylaag 2 - Klasbesprekings
49

}
public double computeAverage()
{
}
average = (mark1+mark2)/ (double) 2;
return average;
public String getName()
{
}
return name;
public double getMark1()
{
}
return mark1;
public double getMark2()
{
}
return mark2;
public double getAvg()
{
}
return average;
Appendix 2
49

import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
//NB Import Class Definition and implementation of class Student
import Student;
Bylaag 2 - Klasbesprekings
// This program keep track of count students. count Empty positions are created
// and can be filled by entering data in the TextFields and pressing the
// the Save Student button.
public class StudentsDriver extends Applet
{
Label promptName, promptMark1, promptMark2, promptAvg, labelAvg;
Label showAvg, counter, promptCounter, blank;
TextField inputName,inputMark1,inputMark2;
Button nextStudent,previousStudent,saveStudent;
int position = 0;
double stuAvg;
Student stuArr[];
int count = 5;
public void init()
{
stuArr = new Student[count]; //Constructor Not called
//The elements in this array are reference types, that is, each element contains a
//reference to a Student object. At this point, enough memory has been allocated to
//contain the Student references, but no memory has been allocated for the Students
//themselves. If you attempted to access one of stuArrs elements at this point,
//you would get a NullPointerException because the array is empty and contains no
//Students and no Student objects. This is often a source of some confusion for
50

import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
//NB Import Class Definition and implementation of class Student
import Student;
// This program keep track of count students. count Empty positions are created
// and can be filled by entering data in the TextFields and pressing the
// the Save Student button.
public class StudentsDriver extends Applet
{
Label promptName, promptMark1, promptMark2, promptAvg, labelAvg;
Label showAvg, counter, promptCounter, blank;
TextField inputName,inputMark1,inputMark2;
Button nextStudent,previousStudent,saveStudent;
int position = 0;
double stuAvg;
Student stuArr[];
int count = 5;
public void init()
{
stuArr = new Student[count]; //Constructor Not called
//The elements in this array are reference types, that is, each element contains a
//reference to a Student object. At this point, enough memory has been allocated to
//contain the Student references, but no memory has been allocated for the Students
//themselves. If you attempted to access one of stuArrs elements at this point,
//you would get a NullPointerException because the array is empty and contains no
//Students and no Student objects. This is often a source of some confusion for
Appendix 2
50

programmers new to the Java lang
for (int i = 0; i

programmers new to the Java lang
for (int i = 0; i

}
add(showAvg); //Not a TextField, computed field
add(saveStudent);
add (blank);
add(nextStudent);
add(previousStudent);
add(promptCounter);
add(counter);
counter.setText(Integer.toString(position+1));
public boolean action(Event e, Object arg)
{
Button pressed;
double m1,m2; //temp variables to compute avg
if (e.target instanceof TextField)
{
}
m1 = Double.parseDouble(inputMark1.getText());
m2 = Double.parseDouble(inputMark2.getText());
stuAvg = ((m1+m2)/2 = 0) ? (m1+m2)/2 : 0;
showAvg.setText(Double.toString(stuAvg));
if (e.target instanceof Button)
{
pressed = (Button)e.target;
if (pressed == saveStudent)
{
}
stuArr[position].setName(inputName.getText());
stuArr[position].setMark1(Double.parseDouble(inputMark1.getText()));
stuArr[position].setMark2(Double.parseDouble(inputMark2.getText()));
stuAvg = stuArr[position].computeAverage();
showAvg.setText(Double.toString(stuAvg));
pressed = nextStudent;
Bylaag 2 - Klasbesprekings
52

}
add(showAvg); //Not a TextField, computed field
add(saveStudent);
add (blank);
add(nextStudent);
add(previousStudent);
add(promptCounter);
add(counter);
counter.setText(Integer.toString(position+1));
public boolean action(Event e, Object arg)
{
Button pressed;
double m1,m2; //temp variables to compute avg
if (e.target instanceof TextField)
{
}
m1 = Double.parseDouble(inputMark1.getText());
m2 = Double.parseDouble(inputMark2.getText());
stuAvg = ((m1+m2)/2 = 0) ? (m1+m2)/2 : 0;
showAvg.setText(Double.toString(stuAvg));
if (e.target instanceof Button)
{
pressed = (Button)e.target;
if (pressed == saveStudent)
{
}
stuArr[position].setName(inputName.getText());
stuArr[position].setMark1(Double.parseDouble(inputMark1.getText()));
stuArr[position].setMark2(Double.parseDouble(inputMark2.getText()));
stuAvg = stuArr[position].computeAverage();
showAvg.setText(Double.toString(stuAvg));
pressed = nextStudent;
Appendix 2
52

}
}
}
if (pressed ==previousStudent)
{
}
if (position > 0)
{
}
position--;
else
position = count-1;
counter.setText(Integer.toString(position+1));
inputName.setText(stuArr[position].getName());
inputMark1.setText(Double.toString(stuArr[position].getMark1()));
inputMark2.setText(Double.toString(stuArr[position].getMark2()));
showAvg.setText(Double.toString(stuArr[position].getAvg()));
if (pressed == nextStudent)
{
}
if (position < count-1 )
{
}
position++;
else
position = 0;
counter.setText(Integer.toString(position+1));
inputName.setText(stuArr[position].getName());
inputMark1.setText(Double.toString(stuArr[position].getMark1()));
inputMark2.setText(Double.toString(stuArr[position].getMark2()));
showAvg.setText(Double.toString(stuArr[position].getAvg()));
return true;
Bylaag 2 - Klasbesprekings
53

}
}
}
if (pressed ==previousStudent)
{
}
if (position > 0)
{
}
position--;
else
position = count-1;
counter.setText(Integer.toString(position+1));
inputName.setText(stuArr[position].getName());
inputMark1.setText(Double.toString(stuArr[position].getMark1()));
inputMark2.setText(Double.toString(stuArr[position].getMark2()));
showAvg.setText(Double.toString(stuArr[position].getAvg()));
if (pressed == nextStudent)
{
}
if (position < count-1 )
{
}
position++;
else
position = 0;
counter.setText(Integer.toString(position+1));
inputName.setText(stuArr[position].getName());
inputMark1.setText(Double.toString(stuArr[position].getMark1()));
inputMark2.setText(Double.toString(stuArr[position].getMark2()));
showAvg.setText(Double.toString(stuArr[position].getAvg()));
return true;
Appendix 2
53

Bylaag 2 - Klasbesprekings
KLASBESPREKING 2: HOE OM HOOFSTUK 5 AAN TE PAK
DIE SKRYF VAN ’N KLAS: ARRAY WAT ’N SKIKKING VAN ENIGE DATATIPE OF OBJEK
VAN ENIGE KLAS KAN BEVAT EN WAAR DIE SKIKKING IN DIE KLAS: ARRAY
GESORTEER KAN WORD.
• Hierdie klasbespreking volg op Opdrag 3: die Array-klas met Object-datatipe. Maak
seker dat jy dit verstaan voordat jy dit aanpak.
• Hierdie werk is moeilik; moenie verwag om alles dadelik te verstaan nie.
• Verstaan eers die oorhoofse doel:
Ε Om ’n klas Array te maak sodat daar ’n ingeboude datatipe Array is wat ’n
skikking van enige data bevat. Wanneer mens die skikking wil gebruik, dui mens
net die grootte aan en as jy wil, die basis-indeksposisie.
Ε KYK NA DIE AANDRYWERPROGRAM – Lyn 159 – 214
Ε Lyn 175 – maak ‘n objek van die klas Array.
Ε Lyn 199 – wanneer elemente in die skikking geplaas word, moet die datatipe
aangedui word – ons het in Opdrag 3 die Integer-klas gebruik, nou gebruik ons
die Int (ons eie) klas. Waarom? (Lees eers verder, jy sal later verstaan)
Ε Lyn 205 – Hierdie nuwe datatipe wat skikkings stoor het ’n ingeboude sorteerfunksie
– oulik nê, kom ons gebruik dit!
Ε Lyn 206 – Soos elke goeie klas in Java, het die Array-klas ook ’n toString() om
die inhoud van die skikking in ‘n string te plaas, sodat dit maklik is om dit te
vertoon.
• Die vrae wat jy behoort te vra indien iemand jou net die aandrywer wys is:
Ε Hoe kry mens dit reg om enige datatipe in ’n skikking te stoor?
- Soos jy nou al moet verstaan is die antwoord die “Object”-datatipe.
Ε Soos ek tot nou toe geleer het, kan ek nie veranderlikes van die Object- datatipe
met mekaar vergelyk nie. Hoe kry mens dit dan reg om die skikking vol Objectveranderlikes
te sorteer?
- Indien jy ook by hierdie vraag uitkom, verstaan jy nou al baie!
- Die antwoord is om van die Comparable() interface (koppelvlak) gebruik te
maak.
• Hoe gebruik ons die Comparable interface om Object-veranderlikes met mekaar te
vergelyk? Die antwoord in een woord is polimorfisme, maar hoe werk dit?
Ε Kyk na die Comparable interface – Lyne 1 tot 10.
Ε Daar is geen implementering van die funksies nie, want dit is net ’n interface – al
die funksies is ABSTRACT.
Ε Kan ek ’n objek van ’n interface maak? NEE.
Ε Kan ek ’n wyser na ’n interface maak? JA – hoekom? Jy sal later verstaan.
Ε Kom ons kyk na ’n klas wat hierde interface implementeer: AbstractObject.
54

Appendix 2
CLASS DISCUSSION 2: HOW TO GET TO GRIPS WITH CHAPTER 5
WRITING A CLASS: AN ARRAY THAT CAN CONTAIN AN ARRAY OF ANY DATA TYPE
OR OBJECT OF ANY CLASS AND WHERE THE ARRAY IN THE CLASS: ARRAY CAN
BE SORTED.
• This class discussion follows on Assignment 3 – the Array class with Object data type.
Make sure that you understand it before starting with it.
• This is difficult work; do not expect to understand everything immediately.
Ε First understand the general purpose:
Ε To make a class Array in such a way that there is a built-in data type Array that
can contain an array with any data. When you want to use the array, you indicate
the size and if you like, the base index position.
Ε LOOK AT THE DRIVE PROGRAM – Line 159 – 214
Ε Line 175 – make an object of the class Array.
Ε Line 199 – when elements are placed in the array, the data type must be
indicated – in Assignment 3 we used the Integer class, now we use the Int (our
own) class. Do you know why? (Keep reading, it will become clear to you later
on.)
Ε Line 205 – The new data type storing the arrays has a built-in sorting function – is
that not that smart? Let us use it!
Ε Line 206 – As with every good class in Java, the Array class also has a toString()
that allows the contents of the array to be placed in a string. This makes it easier
to display.
• The questions you should be asking if someone only shows you the drive:
Ε How do you go about storing any data type in an array?
- by now you should understand the answer is the Object data type.
Ε Like I told you in class, the variables of the Object data type cannot be compared
with one another. How do you go about sorting and array of Object variables?
- if you asked yourself this question, you already understand a lot!
- the answer is to use a Comparable() interface.
• How do we use the Comparable interface to compare Object variables with one
another? The answer is polymorphism. But how does this work?
Ε Take a look at the Comparable interface. Lines 1 to 10.
Ε There is no implementation of the functions because it is only an interface – all
the functions are ABSTRACT.
Ε Can I make an object from an interface? NO.
Ε Can I make a pointer from an interface? YES – why? You will understand this
later.
Ε Let us take a look at the class that will implement this interface: AbstractObject.
54

• Kyk na die klas AbstractObject lyne 11-51.
Ε Verstaan lyn 12
Ε Lyn 14 dui die ABSTRAKTE funksie ComparTo() aan
- Hierdie klas is dus abstrak.
- Kan ek ’n objek van hom maak? NEE.
Bylaag 2 - Klasbesprekings
- Alle klasse wat van hom erf (inherit) sal ook abstrak wees TENSY HULLE DIE
compareTo() metode implementeer (kode verskaf).
Ε Meeste van die funksies van die klas gebruik die compare()-metode.
Ε Die compare()-metode kontroleer of die objekte wat sorteer moet word van
dieselfde datatipe is, indien wel, roep hy die abstrakte funksie CompareTo()
(sien lyn 46).
Ε Om te verstaan hoedat twee getalle met mekaar vergelyk word in hierdie
hiërargie, kyk gou eers na die compareTo() funksie van die Int klas lyn 68.
- Lyn 68 is die parameter ’n Comparable – hoekom nie ’n Int nie? Die funksie
moet dieselfde opskrif hê as in die ouerklas (parent) waar dit gedefinieer word
- sien lyn 14. Jy kan ook daar sien dat dit ’n gewone primitiewe Int terugstuur.
- Lyn 70 verander die Comparable parameter ook na ’n Int.
- Kyk na die Int-klas – dit het value-veranderlike wat ’n primitiewe Int is – lyn 55.
- Onthou die CompareTo()-metode sou in die algemeen so in ‘n program
gebruik word:
• Int a = new Int(5);
• Int b = new Int(4);
• int c = a.compareTo(b);
- b is dan die argument.
- In lyn 72 word b se value van a s’n afgetrek. Onthou a is die veranderlike wat
die funksie roep (die this-veranderlike).
- Afhangende van die verskil tussen die twee getalle, word daar nou in lyne 72-
77 ’n Int teruggestuur.
- Kom ons kyk terug deur die hiërargie vir die geval wat ons hierbo het, naamlik
5 en 4. Lyn 75 sal ’n 1 terugstuur. Waarheen? Watter metode roep
compareTo()? Dis natuurlik compare() lyn 46.
- compare() stuur nou ’n 1 terug vir wie?
- Dit hang af watter van die funksies van die klas dit geroep het. Kyk nou na lyn
149 (dis ’n sorteerfunksie – moenie nou oor die res van die kode bekommer
nie). Ons gebruik die isLT() funksie uit die AbstractObject-klas. Kyk daarna in
lyn 17. Dit return ’n Boolean (True of False). In hierdie geval false want
compare het ’n 1 teruggestuur. Dit is heeltemal reg dat ’n is “less than”funksie
false is as ek 5 met 4 vergelyk.
- Kom ons kyk hoekom ons die isLT() geroep het.
55

• Look at the class AbstractObject lines 11-51.
Ε Understand line 12.
Ε Line 14 indicates the ABSTRACT function ComparTo().
- this class is abstract.
- can I make an object from it? NO.
Appendix 2
- all classes inheriting from it will also be abstract, UNLESS they implement
the compareTo() method (code given).
• Most of the functions in this class use the compare() method.
• The compare() method checks if the objects that must be sorted are the same. If
they are, it calls the abstract function CompareTo() (see line 46).
• In order to understand how two numbers can be compared in this hierarchy, you must
first take a look at the compareTo() function of the Int class in line 68.
- In line 68 is the parameter a Comparable – why not an Int? The function
must have the same heading as the parent class where it is defined - see
line 14. Take note that it sends back a simple, primitive Int.
- in line 70 the Comparable parameter changes to an Int.
- look at the Int class – it has a value variable that is a primitive Int – line 55.
- remember the CompareTo() method will in general be used like this in a
program:
Ε Int a = new Int(5);
Ε Int b = new Int(4);
Ε int c = a.compareTo(b);
- b is the argument.
- in line 72, b’s value is subtracted from the value of a. Remember a is the
variable calling the function (the this variable)
- depending on the difference between the two numbers, an Int is now sent
back in lines 72-77.
- let us have a look at the hierarchy for the situation we have above, namely
5 and 4. Line 75 will send back a 1. Where to will it be sent? What
method calls compareTo()? It is compare() in line 46.
- compare() sends a 1 back - to whom?
- it depends on which functions of class it called. Look at line 149 (it is a
sorting function – do not worry about the rest of the code right now). We
use the isLT() function of the AbstractObject class. Then look at line 17. It
returns a Boolean (True or False). In this case false because compare sent
back a 1. It is correct that a less than function is false when you compare 5
with 4.
- let us look at why we called the isLT().
55

Bylaag 2 - Klasbesprekings
Ε Wat jy nou moet verstaan is: Om twee Object-verandelikes met mekaar te vergelyk
moet daar iewers in die heel onderste klas in die hiërargie ’n implementering
van die funksie compareTo() wees. Dit beteken die volgende vir ons aanvanklike
probleem:
- Wat is ons probleem? Om ’n skikking van Object-veranderlikes te sorteer.
- Ons het reeds in Opdrag 3 en lyn 199 gesien dat wanneer ons iets in die
skikking sit (met put()), ons die datatipe moet aandui. Nou voeg ons nóg ’n
vereiste by.
- Om die sort()-funksie van die skikking te mag gebruik moet die datatipe wat
ons in die skikking sit, ’n implementering van die compareTo() abstrakte
funksie bevat. Hoekom? Sodat die sort()-funksie weet hoe om objekte in die
skikking met mekaar te vergelyk.
- Het die primitiewe Int of die ingeboude Java Integer-klasse ’n implementering
van die compareTo()-funksie? NEE. Kan ons objekte van hierdie klasse in die
skikking insit? NEE. Wat moet ons dan doen?
- Ons moet ons eie Integer-klas maak. Kom ons noem hom Int wat slegs
bestaan uit ’n int veranderlike en ’n implementering van die compareTo()funksie.
(Natuurlik sit ons altyd ‘n toString() in). Kan ons dan objekte van
hierdie klas in die skikking sorteer? JA!
- So ’n klas word ’n wrapper-klas genoem. Dit is ’n klas wat ‘n primitiewe dataelement
bevat en enkele funksies byvoeg om in polimorfisme te gebruik.
• Hoekom sê ons hierdie klas gebruik polimorfisme?
• Kyk nou na die Array-klaslyn 80:
Ε Ek neem aan julle verstaan alles behalwe die sorteer()-funksie.
Ε Kyk na lyn 139 – ek kan nie objekte van ’n abstrakte klas maak nie, maar wel
verwysings (references of addresses) daarna.
Ε My skikking is vol Objects - nou verander ek spesifieke elemente na
Comparables lyne 147 en 148. Hoekom? Ek wil hulle met mekaar vergelyk.
Ε Nou kan ek die isLT()-metode uitvoer?
Ε Hoe weet die Java watter funksies om te roep?
Ε In die aandrywer in lyn 199 het ek gewys dat dit Int.-objekte is wat ek in die Array
sit. Put-lyn 108 het daardie Int na ’n Object verander (deur die parameter se tipe),
maar Java onthou nog dat dit eintlik ’n Int was. Nou wanneer ek die Object (wat
‘n Int was) na ’n Comparable verander in lyn 147, weet Java dat hierdie
Comparable eintlik ’n Int is.
Ε Die funksie wat in lyn 149 geroep word is die funksie van lyn 3. Daar is nie ’n
implementering nie, daarom soek Java een en kry een in lyn 17. Dan word die
funksie Compare() van lyn 43 geroep. In lyn 46 word CompareTo() geroep. Nou
is dit ’n dinamiese binding, want dit is ’n verwysing van die basisklas
(Comparable) wat ’n abstrakte funksie van die subklas Int roep. Java weet dat
die Comparable wat die funksie roep, eintlik ’n Int is en voer Int se compareTo()
uit!!
Ε As dit nie vir jou “cool” is nie, swot jy dalk die verkeerde rigting!
56

Appendix 2
Ε What you must understand at this point: In order to compare two Object variables
with one another, somewhere in the bottom class of the hierarchy the
compareTo() function must be implemented. This implies the following for our
initial problem:
- what is our problem? To sort an array of Object variables.
- during Assignment 3 and line 199 it became clear that when we put
something in the array (with put() ) we must indicate the data type. Now we
add another requirement.
- in order to use the sort() function of the array, the data type we put in the
array must contain an implementation of the compareTo() abstract function.
Why? It lets the sort() function know how to compare the objects in the
array with one another.
- does the primitive Int or built-in Java Integer classes have an
implementation of the compareTo() function? NO. Can we place objects of
these classes in the array? NO. What must we do?
- we must make our own Integer class. Let us call it Int and it consists only of
the int variable and the implementation of the compareTo() function.
(Obviously we add a toString()). Can we now sort objects of this class in
the array? YES!
- this kind of class is called a wrapper class. It is a class containing a
primitive data element and adds several functions to be used in
polymorphism.
• Why does this class use polymorphism?
• Take a look at Array class in line 80:
Ε I assume you understand everything except the sort() function.
Ε Look at line 139 – I cannot make objects from an abstract class, but I can make
references or addresses.
Ε My array filled with Objects – now I change specific elements to Comparables
(lines 147 and 148). Why? I want to compare them with one another.
Ε Am I now able to perform the isLT() method?
Ε How does Java know which functions to call?
Ε In the drive in line 199 I showed that I put Int objects in the Array. Put line 108
changed that Int to an Object (through the type of the parameter), but Java still
remembers that it is actually an Int. When at this point I change the Object
(which was an Int) into a Comparable in line 147, Java knows that the
Comparable is in fact an Int.
Ε The function called in line 149 is the function in line 3. There is no
implementation and Java seeks one and finds one in line 17. Then the
Compare() function of line 43 is called. In line 46 CompareTo() is called. Now it
is a dynamic link, because it is a reference of the base class (Comparable) calling
an abstract function of the subclass Int. Java knows that the Comparable calling
the function is in fact an Int and performs Int’s compareTo()!
Ε If you do not think this is cool, you may be studying the wrong course!
56

Bylaag 2 - Klasbesprekings
• Daar is egter drie ander dinge van die Array-klas wat anders is as in die handboek.
Mens kom dit op die harde manier (meer as 10 uur se gesukkel) agter:
Ε Die Array-klas extend ook van AbstractObject, so om ’n konkrete klas te wees
moet dit ’n implementering van compareTo() bevat. Logies sal hierdie funksie
verduidelik hoe ’n mens een objek van die Array-klas (’n hele skikking) met ‘n
ander een vergelyk. Dit is nie eintlik ’n logiese ding om te doen nie, daarom word
net ’n o teruggestuur. Kyk lyne 115 –117.
Ε Ek het vir die Array-klas ’n cont bygesit wat die aantal vol posisies in die skikking
aandui, sodat ek nie nulposisies sorteer nie. Hoekom nie? In lyn 149 sou ’n
mens dan die funksie vanaf ‘n nul-veranderlike roep en dan kry jy ’n Nul –pointer
exception.
Ε Ek het natuurlik ook ’n toString() bygesit.
EK HOOP WERKLIK HIERDIE VERDUIDELIKING HELP JULLE OM HOOFSTUK 5
TE VERSTAAN.
57

Appendix 2
• There are three things that are different to the Array class than in the textbook. You
learn this the hard way – after trying for more than 10 hours!
Ε The Array class also extends from AbstractObject, this means that for it to be a
concrete class, it must contain the implementation of compareTo(). Logically it
follows that this function explains how one object of the Array class (a complete
array) is compared with another. Actually it is not a logical thing to do and
therefore only a 0 is sent back. Look at lines 115 - 117.
Ε I added to the Array class a cont to indicate the number of full positions in the
array and prevent me from sorting zero positions. Why not? In line 149 you
would call the function from a zero variable and get a Null pointer exception.
Ε I naturally also added a toString().
I HOPE THIS EXPLANATION HELPS YOU TO UNDERSTAND CHAPTER 5.
57

Programkode
//pr 5.1
1 Public interface Comparable
2 {
3 Boolean isLT (Comparable object);
4 Boolean isLE (Comparable object);
5 Boolean isGT (Comparable object);
6 Boolean isGE (Comparable object);
7 Boolean isEQ (Comparable object);
8 Boolean isNE (Comparable object);
9 Int compare (Comparable object);
10 }
//Pr5.2+pr5.3
11 Public abstract class AbstractObject
12 Implements Comparable
13 {
14 Protected abstract int compareTo (Comparable arg);
15
16
17 public final boolean isLT (Comparable object)
18 { return compare (object) < 0; }
19
20 public final boolean isLE (Comparable object)
21 { return compare (object) 0; }
25
26 public final boolean isGE (Comparable object)
27 { return compare (object) >= 0; }
28
29 public final boolean isEQ (Comparable object)
30 { return compare (object) == 0; }
Bylaag 2 - Klasbesprekings
58

Program code
//pr 5.1
1 Public interface Comparable
2 {
3 Boolean isLT (Comparable object);
4 Boolean isLE (Comparable object);
5 Boolean isGT (Comparable object);
6 Boolean isGE (Comparable object);
7 Boolean isEQ (Comparable object);
8 Boolean isNE (Comparable object);
9 Int compare (Comparable object);
10 }
//Pr5.2+pr5.3
11 Public abstract class AbstractObject
12 Implements Comparable
13 {
14 Protected abstract int compareTo (Comparable arg);
15
16
17 public final boolean isLT (Comparable object)
18 { return compare (object) < 0; }
19
20 public final boolean isLE (Comparable object)
21 { return compare (object) 0; }
25
26 public final boolean isGE (Comparable object)
27 { return compare (object) >= 0; }
28
29 public final boolean isEQ (Comparable object)
30 { return compare (object) == 0; }
Appendix 2
58

31
32 public final boolean isNE (Comparable object)
33 { return compare (object) != 0; }
34
35 public final boolean equals (Object object)
36 {
37 if (object instanceof Comparable)
38 return isEQ ((Comparable) object);
39 Else
40 return false;
41 }
42
43 public final int compare (Comparable arg)
44 {
45 if (getClass () == arg.getClass ())
46 return compareTo (arg);
47 Else
48 return getClass ().getName ().compareTo (
49 arg.getClass ().getName ());
50 }
51 }
//pr 5.5
52 public class Int
53 extends AbstractObject
54 {
55 Protected int value;
56
57 public Int (int value)
58 { this.value = value; }
59
60 public int intValue ()
61 { return value; }
62
Bylaag 2 - Klasbesprekings
59

31
32 public final boolean isNE (Comparable object)
33 { return compare (object) != 0; }
34
35 public final boolean equals (Object object)
36 {
37 if (object instanceof Comparable)
38 return isEQ ((Comparable) object);
39 Else
40 return false;
41 }
42
43 public final int compare (Comparable arg)
44 {
45 if (getClass () == arg.getClass ())
46 return compareTo (arg);
47 Else
48 return getClass ().getName ().compareTo (
49 arg.getClass ().getName ());
50 }
51 }
//pr 5.5
52 public class Int
53 extends AbstractObject
54 {
55 Protected int value;
56
57 public Int (int value)
58 { this.value = value; }
59
60 public int intValue ()
61 { return value; }
62
Appendix 2
59

63 public String toString()
64 {
65 Return Integer.toString(value);
66 }
67
68 Protected int compareTo (Comparable object)
69 {
70 Int arg = (Int) object;
71 Long diff = (long) value - (long) arg.value;
72 if (diff < 0)
73 return -1;
74 Else if (diff > 0)
75 return +1;
76 Else
77 return 0;
78 }
79 }
80 public class Array extends AbstractObject
81 {
82 protected Object[] data;
83 protected int base, count;
84
85
86 public Array (int n, int m)
87 {
88 data = new Object[n];
89 base = m;
90 count = 0;
91 }
92
Bylaag 2 - Klasbesprekings
60

63 public String toString()
64 {
65 Return Integer.toString(value);
66 }
67
68 Protected int compareTo (Comparable object)
69 {
70 Int arg = (Int) object;
71 Long diff = (long) value - (long) arg.value;
72 if (diff < 0)
73 return -1;
74 Else if (diff > 0)
75 return +1;
76 Else
77 return 0;
78 }
79 }
80 public class Array extends AbstractObject
81 {
82 protected Object[] data;
83 protected int base, count;
84
85
86 public Array (int n, int m)
87 {
88 data = new Object[n];
89 base = m;
90 count = 0;
91 }
92
Appendix 2
60

93 public Array()
94 {
95 this(0,0);
96 }
97
98 public Array(int n)
99 {
100 this(n,0);
101 }
102
103
104 public Object get (int position)
105 { return data[position-base];}
106
107
108 public void put(int position, Object object)
109 {
110 data[position-base]= object;
111 count++;
112 }
113
114
115 protected int compareTo (Comparable object)
116 {
117 return 0;
118 }
119
120 public String toString()
121 {
122 String returnString;
123 int k;
124
125 ReturnString = "";
126 for (k = 0; k

93 public Array()
94 {
95 this(0,0);
96 }
97
98 public Array(int n)
99 {
100 this(n,0);
101 }
102
103
104 public Object get (int position)
105 { return data[position-base];}
106
107
108 public void put(int position, Object object)
109 {
110 data[position-base]= object;
111 count++;
112 }
113
114
115 protected int compareTo (Comparable object)
116 {
117 return 0;
118 }
119
120 public String toString()
121 {
122 String returnString;
123 int k;
124
125 ReturnString = "";
126 for (k = 0; k

132 }
133
134
135 public void sort()
136 {
137 int j,k,smallpos,n;
138 Object smallest,temp;
139 Comparable g1,g2;
140
141
142 for (j=0;j

132 }
133
134
135 public void sort()
136 {
137 int j,k,smallpos,n;
138 Object smallest,temp;
139 Comparable g1,g2;
140
141
142 for (j=0;j

163 public class Sorteerints extends Applet
164 {
165 Label prompt,iValue,resultString;
166 TextField input;
167 Array arr;
168 int i,j, flag;
169
170
171
172
173 public void init()
174 {
175 arr = new Array(20);
176 prompt = new Label("Enter an Integer and press return");
177 input = new TextField(10);
178 iValue = new Label(" ") ;
179 ResultString = new Label(" ");
180 i = 0;
181 flag = 0;
182 add(prompt);
183 add(input);
184 add(iValue);
185 add(resultString);
186 }
187
188
189 public boolean action(Event e, Object arg)
190
191 {
192 int k,num;
193 String arrString = new String(" ");
194
195
196 if (e.target instanceof TextField)
197 {
198 num = Integer.parseInt(input.getText());
199 arr.put(i, new Int(num));
200
201 i++;
Bylaag 2 - Klasbesprekings
63

163 public class Sorteerints extends Applet
164 {
165 Label prompt,iValue,resultString;
166 TextField input;
167 Array arr;
168 int i,j, flag;
169
170
171
172
173 public void init()
174 {
175 arr = new Array(20);
176 prompt = new Label("Enter an Integer and press return");
177 input = new TextField(10);
178 iValue = new Label(" ") ;
179 ResultString = new Label(" ");
180 i = 0;
181 flag = 0;
182 add(prompt);
183 add(input);
184 add(iValue);
185 add(resultString);
186 }
187
188
189 public boolean action(Event e, Object arg)
190
191 {
192 int k,num;
193 String arrString = new String(" ");
194
195
196 if (e.target instanceof TextField)
197 {
198 num = Integer.parseInt(input.getText());
199 arr.put(i, new Int(num));
200
201 i++;
Appendix 2
63

202 input.setText("");
203 iValue.setText(Integer.toString(i));
204
205 arr.sort();
206 ArrString = arr.toString();
207 ResultString.setText(arrString);
208
209 return true;
210 }
211 return false;
212 }
213
214 }
Bylaag 2 - Klasbesprekings
JY MOET ALLES IN HIERDIE BESPREKING VERSTAAN OM HIERDIE VAK TE
KAN SLAAG!
64

202 input.setText("");
203 iValue.setText(Integer.toString(i));
204
205 arr.sort();
206 ArrString = arr.toString();
207 ResultString.setText(arrString);
208
209 return true;
210 }
211 return false;
212 }
213
214 }
Appendix 2
YOU MUST UNDERSTAND EVERYTHING IN THIS DISCUSSION IN ORDER TO
PASS THIS SUBJECT!
64

KLASBESPREKING 3:
’n DRYWERPROGRAM VIR HOOFSTUK 5 EN 6
Wat doen hierdie program?
• Dit is ’n poging om die klasse van hoofstukke 5 en 6 te gebruik.
Bylaag 2 - Klasbesprekings
• Op die boek se tuisblad (kyk op bl xi voor die inhoudsopgawe vir die adres) is daar ’n
demoprogram (demo2) wat die klasse gebruik.
• Die demo gebruik Containers en ander goed wat ons nie gedoen het nie, gevolglik het
ek dit aangepas.
Wat is die metode wat gevolg is?
• Ek het eers al die klasse afgelaai en die lêername na die klasname toe verander.
• Van die klasse is in meer as een lêer en ek het hulle toe bymekaar gestoor in een lêer.
• Ek het toe al die klasse ge-“compile.”
• Die exception handling het probleme geskep en ek het toe al die exceptions na
ArrayIndexOutOf Bounds verander wat ’n ingeboude Java-fout is.
Die Drywerprogram
• Dis rofweg gegrond op Demo2 van die tuisblad.
• Indien jy dit probeer aflaai: Dit kan nie in Notepad gelees word nie, maar DOS se EDIT
maak dit oop.
• Ek probeer om met Int-datatipe ’n stapel as ’n vektor (array) te implementeer.
• Die klasse werk almal met Object en mens moet, wanneer jy iets in die stapel
voeg, die datatipe aandui.
• Wanneer ek dit uit die stapel haal, verander ek dit weer na Int en vertoon dit met die
toString()-funksie wat ek by Int bygesit het.
Die probleem
• My program het heeltemal reg gewerk behalwe dat die data wat op die skerm verskyn
het die adresse van die veranderlikes was en nie die waardes nie!
• Die probleem is dus dat Object se toString() nie die waardes wil druk nie. Die fout kom
in AbstractContainer se toString() voor.
• Kyk na die tweede uitvoerskerm. Ek sien toe die woord Int, en na vele ander pogings
sit ek toe net vir die klas Int ’n toString() by. Dit werk!!!!
• Die rede is dat Object se toString() nie weet wat die data is en hoe om dit te
vertoon nie. Dit is eintlik maar net ’n wyser na die objek – in ons geval Int.
Wanneer Object se toString() geroep word soos wat dit indirek in lyn 100 gedoen
word, word daar in die hiërargie afgesoek na die heel onderste klas in die boom –
in hierdie geval die Int-klas. Die Int-klas se toString() word dan gebruik.
• Ek gee al my lêers vir julle – dan kan julle sien wat is bymekaar gesit ens.
65

CLASS DISCUSSION 3:
A DRIVER PROGRAM FOR CHAPTER 5 AND 6
What does the program do?
• It is an attempt to use the classes of chapters 5 and 6.
Appendix 2
• On the webpage of the book (take a look on p xi of the table of contents for the
address) there is a demo program (demo2) that uses the classes.
• The demo uses Containers and other things we do not focus on, therefore I adapted it.
What is the method being followed?
• I first downloaded all the classes and changed the file names to class names.
• Some of the classes are in more than one file and I stored them together in one file.
• Then I compiled all the classes.
• The exception handling created problems and I changed all the exceptions to
ArrayIndexOutOf Bounds – this is a built-in error in Java.
The Driver program
• It is broadly based on Demo2 of the homepage.
• If you try to download it: It cannot be read in Notepad, but DOS’s EDIT opens it.
• I attempted to implement a stack as a vector (array) with an Int data type.
• All the classes work with Object and you must indicate the data type when you
add something to the stack.
• When I remove it from the stack, I change it back to an Int and display it with the
toString() function I added to the Int.
The problem
• My program functioned correctly except that the data displayed on the screen was the
addresses of the variables instead of the values!
• This means that the Object’s toString() would not print the values. The error originates
from the toString() in the AbstractContainer.
• Look at the second output screen. I then saw the word Int and after several attempts
only added to the Int class a toString(). It works!!!!
• The reason is the toString() of the Object does not know what the data is or how
to display it. In fact, it is just a pointer to the object – in this case Int. When the
toString() of the Object is called as it is indirectly done in line 100, a search is
done all the way down the hierarchy to the class at the very bottom of the tree –
in this case the Int class. The toString() of the Int class is then used.
• I am giving all my files to you so can you see what is grouped together, etc.
65

Die een wat werk:
Die een wat die adresse wys:
Bylaag 2 - Klasbesprekings
66

The one that works:
The one showing the addresses:
Appendix 2
66

pr 5.1
public interface Comparable
{
}
boolean isLT (Comparable object);
boolean isLE (Comparable object);
boolean isGT (Comparable object);
boolean isGE (Comparable object);
boolean isEQ (Comparable object);
boolean isNE (Comparable object);
int compare (Comparable object);
//Pr5.2+pr5.3
public abstract class AbstractObject
{
implements Comparable
protected abstract int compareTo (Comparable arg);
public final boolean isLT (Comparable object)
{ return compare (object) < 0; }
public final boolean isLE (Comparable object)
{ return compare (object) 0; }
public final boolean isGE (Comparable object)
{ return compare (object) >= 0; }
public final boolean isEQ (Comparable object)
{ return compare (object) == 0; }
public final boolean isNE (Comparable object)
{ return compare (object) != 0; }
public final boolean equals (Object object)
Bylaag 2 - Klasbesprekings
67

pr 5.1
public interface Comparable
{
}
boolean isLT (Comparable object);
boolean isLE (Comparable object);
boolean isGT (Comparable object);
boolean isGE (Comparable object);
boolean isEQ (Comparable object);
boolean isNE (Comparable object);
int compare (Comparable object);
//Pr5.2+pr5.3
public abstract class AbstractObject
{
implements Comparable
protected abstract int compareTo (Comparable arg);
public final boolean isLT (Comparable object)
{ return compare (object) < 0; }
public final boolean isLE (Comparable object)
{ return compare (object) 0; }
public final boolean isGE (Comparable object)
{ return compare (object) >= 0; }
public final boolean isEQ (Comparable object)
{ return compare (object) == 0; }
public final boolean isNE (Comparable object)
{ return compare (object) != 0; }
public final boolean equals (Object object)
Appendix 2
67

}
{
}
if (object instanceof Comparable)
else
return isEQ ((Comparable) object);
return false;
public final int compare (Comparable arg)
{
}
if (getClass () == arg.getClass ())
else
// Prog 5.8
return compareTo (arg);
return getClass ().getName ().compareTo (
public interface Container
{
}
extends Comparable
int getCount ();
boolean isEmpty ();
boolean isFull ();
void purge ();
void accept (Visitor visitor);
arg.getClass ().getName ());
// Enumeration getEnumeration ();
// pr5.9 + 5.12
public abstract class AbstractContainer
{
extends AbstractObject
implements Container
protected int count;
public int getCount ()
{ return count; }
Bylaag 2 - Klasbesprekings
68

}
{
}
if (object instanceof Comparable)
else
return isEQ ((Comparable) object);
return false;
public final int compare (Comparable arg)
{
}
if (getClass () == arg.getClass ())
else
// Prog 5.8
return compareTo (arg);
return getClass ().getName ().compareTo (
public interface Container
{
}
extends Comparable
int getCount ();
boolean isEmpty ();
boolean isFull ();
void purge ();
void accept (Visitor visitor);
arg.getClass ().getName ());
// Enumeration getEnumeration ();
// pr5.9 + 5.12
public abstract class AbstractContainer
{
extends AbstractObject
implements Container
protected int count;
public int getCount ()
{ return count; }
Appendix 2
68

}
public boolean isEmpty ()
{ return getCount () == 0; }
public boolean isFull ()
{ return false; }
public String toString ()
{
}
final StringBuffer buffer = new StringBuffer ();
Visitor visitor = new AbstractVisitor ()
{
};
// Pr 5.10
private boolean comma;
public void visit (Object object)
{
if (comma)
buffer.append (", ");
buffer.append(object);
comma = true;
}
accept (visitor);
return "{" + buffer + "}";
public interface Visitor
{
}
void visit (Object object);
boolean isDone ();
//pr 5.11
public abstract class AbstractVisitor
implements Visitor
Bylaag 2 - Klasbesprekings
69

}
public boolean isEmpty ()
{ return getCount () == 0; }
public boolean isFull ()
{ return false; }
public String toString ()
{
}
final StringBuffer buffer = new StringBuffer ();
Visitor visitor = new AbstractVisitor ()
{
};
// Pr 5.10
private boolean comma;
public void visit (Object object)
{
if (comma)
buffer.append (", ");
buffer.append(object);
comma = true;
}
accept (visitor);
return "{" + buffer + "}";
public interface Visitor
{
}
void visit (Object object);
boolean isDone ();
//pr 5.11
public abstract class AbstractVisitor
implements Visitor
Appendix 2
69

{
}
public void visit (Object object)
{}
public boolean isDone ()
//pr 6.1
{ return false; }
public interface Stack
{
}
extends Container
Object getTop ();
void push (Object object);
Object pop ();
// Pr 6.2+6.3 +6.4 +6.5
public class StackAsArray
{
extends AbstractContainer
implements Stack
protected Object[] array;
public StackAsArray (int size)
{ array = new Object [size]; }
public void purge ()
{
}
while (count > 0)
array [--count] = null;
public void push (Object object)
{
}
if (count == array.length)
throw new ArrayIndexOutOfBoundsException ();
array [count++] = object;
Bylaag 2 - Klasbesprekings
70

{
}
public void visit (Object object)
{}
public boolean isDone ()
//pr 6.1
{ return false; }
public interface Stack
{
}
extends Container
Object getTop ();
void push (Object object);
Object pop ();
// Pr 6.2+6.3 +6.4 +6.5
public class StackAsArray
{
extends AbstractContainer
implements Stack
protected Object[] array;
public StackAsArray (int size)
{ array = new Object [size]; }
public void purge ()
{
}
while (count > 0)
array [--count] = null;
public void push (Object object)
{
}
if (count == array.length)
throw new ArrayIndexOutOfBoundsException ();
array [count++] = object;
Appendix 2
70

pr 5.5
public class Int
{
}
extends AbstractObject
protected int value;
public Int (int value)
{ this.value = value; }
public int intValue ()
{ return value; }
public String toString()
{
}
return Integer.toString(value);
protected int compareTo (Comparable object)
{
}
Int arg = (Int) object;
long diff = (long) value - (long) arg.value;
if (diff < 0)
return -1;
else if (diff > 0)
else
return +1;
return 0;
//Drywer Program
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class StackDriver extends Applet
{
Label prompt,resultString;
TextField input;
Bylaag 2 - Klasbesprekings
71

pr 5.5
public class Int
{
}
extends AbstractObject
protected int value;
public Int (int value)
{ this.value = value; }
public int intValue ()
{ return value; }
public String toString()
{
}
return Integer.toString(value);
protected int compareTo (Comparable object)
{
}
Int arg = (Int) object;
long diff = (long) value - (long) arg.value;
if (diff < 0)
return -1;
else if (diff > 0)
else
return +1;
return 0;
//Drywer Program
import java.applet.Applet;
import java.awt.*;
import java.awt.event.*;
public class StackDriver extends Applet
{
Label prompt,resultString;
TextField input;
Appendix 2
71

Button pushButton, popButton;
StackAsArray myStack;
//Stack is a abstractContainer p 6.2 p122
//AbstracContainer extends abstractObject p 5.2 p 101
//and is a Container p5.9 p107
//AbstarctObject p102 implements comparable pr 5.1p100
public void init()
{
}
prompt = new Label("Enter an Integer and press return");
pushButton = new Button("Push");
popButton = new Button("Pop");
input = new TextField(10);
resultString = new Label(" ");
myStack = new StackAsArray(10);
add(prompt);
add(input);
add(pushButton);
add(popButton);
add(resultString);
public boolean action(Event e, Object arg)
{
int num;
Int number;
String listString;
Button b;
if (e.target instanceof Button)
{
b = (Button) e.target;
if (b==pushButton)
{
}
num = Integer.parseInt(input.getText());
myStack.push(new Int(num));
if (b==popButton)
Bylaag 2 - Klasbesprekings
72

Button pushButton, popButton;
StackAsArray myStack;
//Stack is a abstractContainer p 6.2 p122
//AbstracContainer extends abstractObject p 5.2 p 101
//and is a Container p5.9 p107
//AbstarctObject p102 implements comparable pr 5.1p100
public void init()
{
}
prompt = new Label("Enter an Integer and press return");
pushButton = new Button("Push");
popButton = new Button("Pop");
input = new TextField(10);
resultString = new Label(" ");
myStack = new StackAsArray(10);
add(prompt);
add(input);
add(pushButton);
add(popButton);
add(resultString);
public boolean action(Event e, Object arg)
{
int num;
Int number;
String listString;
Button b;
if (e.target instanceof Button)
{
b = (Button) e.target;
if (b==pushButton)
{
}
num = Integer.parseInt(input.getText());
myStack.push(new Int(num));
if (b==popButton)
Appendix 2
72

}
}
}
{
}
number = (Int) myStack.pop();
input.setText(number.toString());
//ons het mos ‘n toString bygesit vir Int
//pr5.12 p111, pr5.11 p110, use p5.10 p107
listString = myStack.toString(); //pr5.12 p111
resultString.setText(listString);
return true;
Bylaag 2 - Klasbesprekings
73

}
}
}
{
}
number = (Int) myStack.pop();
input.setText(number.toString());
//ons het mos ‘n toString bygesit vir Int
//pr5.12 p111, pr5.11 p110, use p5.10 p107
listString = myStack.toString(); //pr5.12 p111
resultString.setText(listString);
return true;
Appendix 2
73

BYLAAG 3 – EKSAMENVRAESTEL
Bylaag 3 - Eksamenvraestel
74

APPENDIX 3– EXAMINATION PAPER
Appendix 3
74

Requirements for this paper:
Bylaag 3 - Eksamenvraestel
Multiple choice cards: Non-programmable calculator: Open book examination
Graphic paper: Laptop:
EKSAMEN/
EXAMINATION:
VAKKODE/
SUBJECT CODE:
JANUARIE 2003
JANUARY 2003
GRADE/DEGREE/
/ DIPLOMA:
BSc BCom
RKW211 / ITRW212 DUUR/
DURATION:
VAK / SUBJECT: MAKS / MAX: 70
EKSAMINATOR(E)/
EXAMINER(S):
R Goede
MODERATOR: Prof GR Drevin
Vraag 1 / Question 1
DATUM /
DATE:
2 uur
2 hours
Bepaal die totale looptyd van hierdie programdeel deur van die vereenvoudigde model gebruik te
maak.
Determine the total running time of this program segment by using the simplified model.
Maak gebruik van die volgende gelykheid:
Use the following equation:
n
∑
i=
1
n(
n + 1)
i =
2
1 public class Question 1
2 {
3 public static int numbers (int n)
4 {
5 int prod = 1;
6 for (int i=0; i

Requirements for this paper:
Multiple choice cards: Non-programmable calculator: Open book examination
Graphic paper: Laptop:
EKSAMEN/
EXAMINATION:
VAKKODE/
SUBJECT CODE:
JANUARIE 2003
JANUARY 2003
GRADE/DEGREE/
/ DIPLOMA:
BSc BCom
RKW211 / ITRW212 DUUR/
DURATION:
VAK / SUBJECT: MAKS / MAX: 70
EKSAMINATOR(E)/
EXAMINER(S):
R Goede
MODERATOR: Prof GR Drevin
Vraag 1 / Question 1
DATUM /
DATE:
Appendix 3
2 uur
2 hours
Bepaal die totale looptyd van hierdie programdeel deur van die vereenvoudigde model gebruik te
maak.
Determine the total running time of this program segment by using the simplified model.
Maak gebruik van die volgende gelykheid:
Use the following equation:
n
∑
i=
1
n(
n + 1)
i =
2
1 public class Question 1
2 {
3 public static int numbers (int n)
4 {
5 int prod = 1;
6 for (int i=0; i

Vraag 2 / Question 2
2.1 Gee die definisie van die asimtotiese bo-grens - O().
Bylaag 3 - Eksamenvraestel
Give the definition of the asymptotic upper bound - O(). (4)
2.2 Gee ‘n volledige asimptotiese ontleding van die volgende klas:
Give a complete asymptotic analysis of the following class: (6)
1 public class Question 2
2 public static int numbers (int n)
3 {
4 int prod = 1;
5 for (int i=0; i

Vraag 2 / Question 2
2.1 Gee die definisie van die asimtotiese bo-grens - O().
Appendix 3
Give the definition of the asymptotic upper bound - O(). (4)
2.2 Gee ‘n volledige asimptotiese ontleding van die volgende klas:
Give a complete asymptotic analysis of the following class: (6)
1 public class Question 2
2 public static int numbers (int n)
3 {
4 int prod = 1;
5 for (int i=0; i

}
{
}
data[position-base]= object;
count++;
protected int compareTo (Comparable object)
{
return 0;
}
Bylaag 3 - Eksamenvraestel
Skryf ‘n metode vir die klas: Array, genaamd deleteSmallest() wat die kleinste element uit
die skikking verwyder. Die metode moet die waarde van die kleinste getal aan die roepende
program terugstuur en die kleinste getal uit die skikking verwyder.
Write a method for the class Array called deleteSmallest() that removes the smallest number from the
array. The method should return the value of the smallest number to the calling program, and remove
the smallest number from the array.
(10)
Vraag 4 / Question 4
Bestudeer die volgende skermuitdruk en die meegaande program:
Study the following screen printout and the associated program:
1 import java.applet.Applet;
2 import java.awt.*;
3 import java.awt.event.*;
4 public class Driver extends Applet
5 {
6 public void init()
7 {
8 LinkedList list = new LinkedList();
9 }
10 public boolean action(Event e, Object arg)
11 {
12 String s;
13 char in;
14 Button pressed;
15 if (e.target instanceof Button)
77

}
{
}
data[position-base]= object;
count++;
protected int compareTo (Comparable object)
{
return 0;
}
Appendix 3
Skryf ‘n metode vir die klas: Array, genaamd deleteSmallest() wat die kleinste element uit die
skikking verwyder. Die metode moet die waarde van die kleinste getal aan die roepende
program terugstuur en die kleinste getal uit die skikking verwyder.
Write a method for the class Array called deleteSmallest() that removes the smallest number
from the array. The method should return the value of the smallest number to the calling
program, and remove the smallest number from the array.
Vraag 4 / Question 4
Bestudeer die volgende skermuitdruk en die meegaande program:
Study the following screen printout and the associated program:
1 import java.applet.Applet;
2 import java.awt.*;
3 import java.awt.event.*;
4 public class Driver extends Applet
5 {
6 public void init()
7 {
8 LinkedList list = new LinkedList();
9 }
10 public boolean action(Event e, Object arg)
11 {
12 String s;
13 char in;
14 Button pressed;
15 if (e.target instanceof Button)
(10)
77

16 {
17 pressed = (Button)e.target;
18 if (pressed == sort)
19 {
20 list.sort();
21 }
22 if (pressed == prepend)
23 {
24 s =input.getText();
25 in = s.charAt(0);
26 list.prepend(new Char(in));
27 }
28 if (pressed == append)
29 {
30 s = input.getText();
31 in = s.charAt(0);
32 list.append(new Char(in));
33 }
34 showString = list.toString();
35
36 resultString.setText(showString);
37 return true;
38 }
39 return false;
40 }
41 }
Bylaag 3 - Eksamenvraestel
4.1 Skryf die Java-kode om die skermuitleg te doen deur die kode van die init()-metode te
skryf. Hou die res van die kode in gedagte wanneer name van veranderlikes gekies
word.
Write the Java code to do the screen layout by writing the code of the init() method.
Keep the rest of the code in mind when choosing variable names. (5)
4.2 Verduidelik die werking van lyne 15 tot 21 in jou eie woorde.
Explain the operation of lines 15 to 21 in your own words. (5)
4.3 Verduidelik die werking van lyne 34 tot 39 in jou eie woorde.
Explain the operation of lines 34 to 39 in your own words. (5)
78

16 {
17 pressed = (Button)e.target;
18 if (pressed == sort)
19 {
20 list.sort();
21 }
22 if (pressed == prepend)
23 {
24 s =input.getText();
25 in = s.charAt(0);
26 list.prepend(new Char(in));
27 }
28 if (pressed == append)
29 {
30 s = input.getText();
31 in = s.charAt(0);
32 list.append(new Char(in));
33 }
34 showString = list.toString();
35
36 resultString.setText(showString);
37 return true;
38 }
39 return false;
40 }
41 }
Appendix 3
4.1 Skryf die Java-kode om die skermuitleg te doen deur die kode van die init() metode te
skryf. Hou die res van die kode in gedagte wanneer name van veranderlikes gekies
word.
Write the Java code to do the screen layout by writing the code of the init() method.
Keep the rest of the code in mind when choosing variable names. (5)
4.2 Verduidelik die werking van lyne 15 tot 21 in jou eie woorde.
Explain the operation of lines 15 to 21 in your own words. (5)
4.3 Verduidelik die werking van lyne 34 tot 39 in jou eie woorde.
Explain the operation of lines 34 to 39 in your own words. (5)
78

Vraag 5 / Question 5
Bestudeer die volgende klas:
Study the following class:
public class LinkedList extends AbstractObject
{
protected Element head;
protected Element tail;
}
public LinkedList()
{
purge();
}
public void purge()
{
head = null;
tail = null;
}
public boolean isEmpty()
{
return head == null;
}
public final class Element
{
public Object datum;
public Element next;
}
Element (Object userDatum, Element userNext)
{
datum = userDatum;
next = userNext;
}
public Object getDatum()
{
return datum;
}
public Element getNext()
{
return next;
}
Bylaag 3 - Eksamenvraestel
Gestel hierdie geskakelde lys word soos ‘n tou bestuur. Skryf ‘n metode vir die klas:
LinkedList genaamd dequeue(), wat ‘n element uit die tou verwyder. Jy mag nie die
bestaan van enige ander behalwe die bogenoemde metodes van die klas LinkedList
aanvaar nie.
Assume this linked list is managed as a queue. Write a method for the class LinkedList called dequeue() that
removes an element from the queue. You may not assume the existence of any other than the above given
methods in the class LinkedList
(8)
79

Vraag 5 / Question 5
Bestudeer die volgende klas:
Study the following class:
public class LinkedList extends AbstractObject
{
protected Element head;
protected Element tail;
public LinkedList()
{
purge();
}
public void purge()
{
head = null;
tail = null;
}
public boolean isEmpty()
{
return head == null;
}
public final class Element
{
public Object datum;
public Element next;
}
}
Element (Object userDatum, Element userNext)
{
datum = userDatum;
next = userNext;
}
public Object getDatum()
{
return datum;
}
public Element getNext()
{
return next;
}
Appendix 3
Gestel hierdie geskakelde lys word soos ‘n tou bestuur. Skryf ‘n metode vir die klas:
LinkedList genaamd dequeue(), wat ‘n element uit die tou verwyder. Jy mag nie die
bestaan van enige ander behalwe die bogenoemde metodes van die klas LinkedList
aanvaar nie.
Assume this linked list is managed as a queue. Write a method for the class LinkedList
called dequeue() that removes an element from the queue. You may not assume the
existence of any other than the above given methods in the class LinkedList. (8)
79

Vraag 6 / Question 6
Bylaag 3 - Eksamenvraestel
Verduidelik die gebruik van die throw en throws sleutelwoorde in Java. Jy moet ‘n voorbeeld gebruik
om jou verduideliking toe te lig.
Explain the use of the throw and throws keywords in Java. You must use an example to elucidate
your explanation.
Vraag 7 / Question 7
7.1 Verduidelik die verskil tussen ‘n objek en ‘n klas. Jy moet ‘n voorbeeld gebruik om jou
verduideliking toe te lig.
Explain the difference beteen an object and a class. You must use an example to elucidate your
explanation.
7.2 Verduidelik wat oorerwing is en verwys spesifiek na die nut daarvan. Jy moet ‘n voorbeeld gebruik
om jou verduideliking toe te lig.
Explain inheritance and refer specifically to its benefit. You must use an example to elucidate your
explanation.
Vraag 8 / Question 8
Verduidelik die volgende terme ten opsigte van bome:
Explain the following termimology with regard to trees:
8.1 Graad van ‘n node / Degree of a node
8.2 Hoogte van ‘n boom / Height of a tree
8.3 Voorouer van ‘n node / Ancestor of a node
TOTAAL
TOTAL 70
(6)
(3)
(3)
(6)
80

Vraag 6 / Question 6
Appendix 3
Verduidelik die gebruik van die throw en throws sleutelwoorde in Java. Jy moet ‘n voorbeeld gebruik
om jou verduideliking toe te lig.
Explain the use of the throw and throws keywords in Java. You must use an example to elucidate
your explanation.
Vraag 7 / Question 7
7.1 Verduidelik die verskil tussen ‘n objek en ‘n klas. Jy moet ‘n voorbeeld gebruik om jou
verduideliking toe te lig.
Explain the difference beteen an object and a class. You must use an example to
elucidate your explanation.
7.2 Verduidelik wat oorerwing is en verwys spesifiek na die nut daarvan. Jy moet ‘n
voorbeeld gebruik om jou verduideliking toe te lig.
Explain inheritance and refer specifically to its benefit. You must use an example to
elucidate your explanation.
Vraag 8 / Question 8
Verduidelik die volgende terme ten opsigte van bome:
Explain the following termimology with regard to trees:
8.1 Graad van ‘n node / Degree of a node
8.2 Hoogte van ‘n boom / Height of a tree
8.3 Voorouer van ‘n node / Ancestor of a node
(6)
(3)
(3)
(6)
TOTAAL
TOTAL 70
80