Course Overview and Introduction

Algorithms and Data Structures

COMP3506/7505
 Course Staff

Course Coordinator / Lecturer:

➢ Richard Thomas (richard.thomas@uq.edu.au)

Tutors:
➢ Ben Martin
➢ Paul Haley
➢ Henry O’Brien
➢ Dylan Kidd
➢ Emily Bennett
 Course Details
• 3 lectures and 1 tutorial per week
• Prerequisites
– MATH1061 (MATH7861) or (CSSE2010 + STAT2202)
– CSSE2002 (CSSE7023)
 Background Knowledge
• High school maths
– Logarithms
– Basic algebra
• Discrete mathematics (e.g. MATH1061)
– Graphs
– Set theory and relations

Why the math?

 Background knowledge
• CSSE 1001: Introduction to Software Engineering I
– Control flow (loops; if-then)
– Arrays
– Methods
– Classes and Objects How is a Java

– Inheritance program not an

algorithm?

– Exceptions
– Data Structures
 Background Knowledge
• CSSE 2002 – Programming in the Large OR
CSSE 7023 – Advanced Software Engineering
• Larger-scale programming issues
• Inter-object cooperation
• Unit testing
• Java programming language
• Eclipse IDE
The Art of Computer Programming

“If you think you’re a really good

programmer […] read (Knuth’s) Art of
Computer Programming […] You
should definitely send me a résumé if
you can read the whole thing.”
– Bill Gates
The Art of Computer Programming
• This course tries to teach you some
of this “art”
• How to think about problems
algorithmically
• Problem ➔ Algorithm ➔ Program
 Course Aims
Students should develop an understanding of
1. How data structures impact performance of complex
systems
2. Fundamental algorithms and data-structures,
including their time and space requirements
3. How to select appropriate data structures and
algorithms to solve practical problems
4. Mathematical techniques for designing and analysing
algorithms with performance guarantees
 Learning Objectives
After successfully completing this course you should be able
to:
1. Understand the internal workings of fundamental data
structures and algorithms
2. Determine the running time and memory space usage of
common algorithms
3. Adapt or invent new algorithms and data structures for
software engineering problems
4. Analyse the performance of algorithms built on fundamental
data structures
5. Select and justify appropriate combinations of data structures
and algorithms to solve software engineering problems
Learning Resources (Textbook)

M.T. Goodrich, R. Tamassia and M.H.

Goldwasser (2014)
Data Structures and Algorithms in Java.
6th ed. John Wiley and Sons, Inc.

Almost every lecture corresponds to a

chapter or a section in the book.

Useful for reviewing and extending

the topics discussed in lectures and
tutorials.
Learning Resources (Reference)

T.H. Cormen, C.E. Leiserson, R.L. Rivest

and C. Stein (2009)
Introduction to Algorithms.
3rd ed. MIT Press.

Good, in-depth, coverage of algorithms

and interacting with data structures.

Extends the topics discussed in lectures

and tutorials, and covers more
advanced topics.
 Assessment

Assessment Due Weighting

Assignment 1 27 August 20%
Assignment 2 15 October 30%
Final Exam Exam Period 50%

• COMP7505 Students will have a research component in

the second assignment
 Assessment
• Assignment 1 – 20%
– Demonstrate understanding of abstract data types,
simple data structures, and their implementation details
• Assignment 2 – 30%
– Design and implement a system to solve a specific
problem, using and implementing appropriate
algorithms and data structures
• Final exam (50%)
– Short answer and problem solving questions
– Covers all course material
 Grade Cutoffs
Grade Course Mark Final Exam Cutoff
7 85+ 75%
6 75-84 65%
5 65-74 55%
4 50-64 40%
3 45-49 35%
2 20-45
1 0-19
 Plagiarism
Plagiarism is the act of misrepresenting as one’s own original
work the ideas, interpretations, words or creative works of
another. These include published and unpublished documents,
designs, music, sounds, images, photographs, computer codes
and ideas gained through working in a group. These ideas,
interpretations, words or works may be found in print and/or
electronic media.

Students are encouraged to read the UQ Academic Integrity and

Plagiarism policy (http://ppl.app.uq.edu.au/content/3.60.04-
student-integrity-and-misconduct) which makes a
comprehensive statement about the University’s approach to
plagiarism, including the approved use of plagiarism detection
software, the consequences of plagiarism and the principles
associated with preventing plagiarism.
 Plagiarism is Serious
• If you have read something related reference it.
• If you copy something “quote it” and reference it.
• If you do not reference or quote when necessary
you have plagiarised it.
• Excessive referencing or quoting is not plagiarism
but may not demonstrate any understanding on
your part.
• If in doubt, ask.
Individual Assignments – Rules of Thumb
• Don’t show someone else your code
• Don’t tell someone how to do the assignment

We check for excessive collaboration/plagiarism

using sophisticated tools.
 This Course Is this what you thought
you signed up for?

• Considers the fundamental data structures and

algorithms that form the basis of large, complex
software systems
• Builds an understanding of the storage and processing
mechanisms of computers and how to manage
storage and processing in order to create efficient
programs
• Instills knowledge to guide the selection of an
appropriate structure for large, complicated systems
 Overarching Aim
The goal of this course is to build an understanding
of data structures and their associated algorithms
so that you can select an appropriate set when
designing software.
 But Why?
Why do we care so much about scalability?

Throwing more machines at a problem is often

cheaper than spending precious developer time.
But Why?
 Motivation
• Why study algorithms & data structures?
– Algorithms and data-structures are fundamental to the
software in computational devices
– Intelligent use of new and existing data structures and
algorithms is a competitive advantage for top
technology companies
Web Search

Why? What’s so hard

about search?
 Web Search
• Algorithms
– Crawl the web (web crawlers)
– Process web pages for keywords
– “Page-rank” algorithm to rank pages
• Data structures
– Cache web pages
– Store keywords and page URLs
– Indices of keywords, URLs and cached site content
 Bioinformatics
• High throughput technologies generates enormous
quantities of genomics/proteomics data
• Data integration and automated analysis issues
• Storage and management issues
 CERN Data Centre
• > 200 Petabytes permanent storage
• > 12 Petabytes processing memory
• Large Hadron Collider
▪ generates 1 Petabyte of data per second
▪ 7.5M seconds of experiments in 2016
• increased in 2017
▪ not only source of data at CERN
• Data must be filtered
▪ efficiently
 CERN Data Centre
• Uses tiered grid computing
▪ near real-time data access
• Main DC has > 100,000 processing cores
▪ 1 Petabyte data processed per day
▪ 1M jobs per day
▪ 6000 DB changes per second
• Grid
▪ > 170 sites
▪ > 2M jobs per day
▪ up to 10 Gigabyte data transferred per second
 Databases

• How does Oracle maintain its position when its

competitors provide their offerings for free?
– Optimisation
• Minimise query response time
– Reliability
• Maximise server uptime
– Redundancy
• Develop support for database clusters
– Security
• Authentication, Access Control, etc.
 What You’ll Learn
• Commonly used data structures and algorithms
– What will employers expect you to know?
• How do you compare them?
• How to adapt or create algorithms to solve a new
problems
 ADT Definition
• Formal model of a data structure that specifies
– type of data stored
– operations supported
– types of parameters of the operations
• Specifies what each operation does
– not how it does it
 Purpose
• Behavioural contract with user
• Encapsulation
– Implementation details are hidden
• Isolation
– User code and ADT implementation can both be
changed without affecting each other
• Flexibility
– Alternative implementations are interchangeable
– Optimised for specific purpose
 ADTs in Java
• Interface specifies abstract methods that an
implementing class must implement
• Interfaces may extend other interfaces to add
functionality
 Generics
• Parameterised type specified by user code when
the ADT is used
– i.e. type of the class is passed in as a parameter
• Added in Java 5 (aka 1.5)
– 2004
 Stack ADT
1 package au.edu.uq.itee.comp3506.adt;
2
3 import java.util.NoSuchElementException;
4
5 public interface IStack<T> {
6 public void push(T element);
7 public T pop() throws NoSuchElementException;
8
9 public T top() throws NoSuchElementException;
10 public int size();
11 public boolean isEmpty();
12 }
 Using Stack ADT
1 public class Example {
2
3 public static void main(String[] args) {
4 IStack<String> stack = new StackImpl<String>();
5 stack.push("A String");
6 stack.push("Another String"); Concrete Data Type
7
8 String str = stack.pop();
9 }
10 }
 ADTs Covered
• Linear Structures • Heap
– Stack (FILO) • Priority Queue
– Queue (FIFO) • Hash-Table
– Deque (Double-ended)
• Map / Dictionary
– List
• Set
– Sequence
• String
• Tree
• Graph