It consists of two parts:

1. The C Programming Language

2. Data Structures and Algorithms

Together, we have Data Structures and Algorithms in C.

But we don’t have the luxury of learning the C programming language through traditional methods (like those used in COMP1511).

It means:

On one hand, you pay for one course but get the content of two.

On the other hand, COMP9024 has a steep learning curve.

Please work hard in Week 1 and harder after that.

To aid understanding, most of the algorithms (e.g., Bubble Sort) have been visualized in COMP9024.

A picture is more than a thousand words.

Please follow the steps in Introduction to CSE VLAB

Make sure that you know how to use CSE VLAB in Week 1.

Make sure that you understand the C program in Bubble Sort by the end of Week 2.

Lecturer in Charge:		Changwei Zou
Course admin:		Mingqin Yu
A team of tutors:		... who are they?
Getting Help (technical/course contents):		Use Help Sessions, or Course Forum
Email address to use (personal/non-technical issue):		cs9024@cse.unsw.edu.au

When illness or circumstances beyond your control:

Use UNSW Special Consideration

Tutors:		John Chen
		Deniz Dilsiz
		Fangfei Fan
		Ziming Gong
		Janhavi Jain
		Joffrey Ji
		Leman Kirme
		Ziting Li
		Kisaru Liyanage
		Thirasara Beruwawela Pathiranage
		Adiyat Rahman
		Nimish Ukey
		Finn Xu
		Oliver Xu
		Sijia Xu
		Mingqin Yu

Week		Lectures		Weekly Prac/Quiz		Weekly Tut		Assignment
1		Introduction, C language		--				Large Assignment
2		Dynamic data structures		prac/quiz		Tutorial		|
3		Analysis of algorithms		prac/quiz		Tutorial		|
4		Graph data structures		prac/quiz		Tutorial		|
5		Graph algorithms		prac/quiz		Tutorial		|
6		Mid-term test (online) (Thursday, 4pm-5pm)				--		|
7		Search tree data structures		prac/quiz		Tutorial		|
8		Search tree algorithms		prac/quiz		Tutorial		|
9		String algorithms		prac/quiz		Tutorial		|
10		Randomised algorithms, Review		prac/quiz		Tutorial		| due
Exam Week (Central)		Final Exam (on campus)						--

• On Lectures: Tuesdays/Thursdays 4-6pm (recording release soon after the lecture via Echo360)
• Weekly help sessions - check the homepage

weekly_lab   = mark for weekly practicals/quizzes (out of 2*8) 
mid_term     = mark for mid-term test    (out of 12)
large_assn   = mark for large assignment (out of 12)
exam         = mark for final exam       (out of 60)


total = weekly_lab + mid_term + large_assn + exam

To pass the course, you must achieve:

• at least 50/100 for total

In weeks 2-5, 7-10 :

Practical exercises are provided at the bottom of tutorial web pages (e.g., Tutorial in Week 2).

After completing each weekly practical exercise, please proceed to the weekly quiz on Moodle.

Weekly Quizzes (practical exercises) contribute 16% to overall mark ( 2 marks each x 8 weeks).

Do them yourself!   and   Don't fall behind!

Quizzes on Moodle

The large assignment gives you experience applying tools/techniques
(but to a larger programming problem than weekly practical exercises)

The assignment will be carried out individually.

The assignment will be released in Week 1 and is due in week 10.

The assignment contributes 12% to overall mark.

Large Assignment on Github

Submit your answers in week 10 on Moodle

1-hour online test in Week 6 (Thursday, 4-5pm) on Moodle.

Format:

• some multiple-choice questions
• (maybe) some descriptive/analytical questions with open answers

2-hour written exam during the exam period.

Format:

• current plan is to have it on campus (invigilated, on Inspera, organized by UNSW Exams)
• using your own laptop with locked-down browser
• some multiple-choice questions
• (maybe) some descriptive/analytical questions

If you have any queries about your final exam on Inspera, please contact the UNSW Exams Centre on exams@unsw.edu.au

Answers to the quizzes and the large assignment (assessed online via Moodle) will be released to students on completion.

For some assessment items, a late penalty may not be appropriate.

Such assessments will receive a mark of zero if not completed by the specified date. Examples include:

• Weekly online tests or laboratory work worth a small proportion of the subject mark;
• Exams, peer feedback and team evaluation surveys;
• Online quizzes where answers are released to students on completion;
• Professional assessment tasks, where the intention is to create an authentic assessment that has an absolute submission date;
• Pass/Fail assessment tasks.

For more details, see COMP9024 Course Outline.

• use weekly practicals to practise programming in C
• practise programming outside classes
• utilise the tutorials and help sessions with the tutors

COMP9021 …

• solving problems by developing programs
• expressing your ideas in the language Python
• Python provides a higher-level abstraction (e.g., garbage collection)

• knowing fundamental data structures/algorithms
• able to reason about their applicability/effectiveness
• able to analyse the efficiency of programs
• able to code in C
• C remains a cornerstone in system programming (e.g., Linux Kernel and Python Interpreter)

• how to store data inside a computer for efficient use

• step-by-step process for solving a problem  (within finite amount of space and time)

There are no prerequisites for this course.

However we will move at fast pace through the necessary programming fundamentals. You may find it helpful if you are able to:

• produce correct programs from a specification
• understand the state-based model of computation
  (variables, assignment, function parameters)
• use fundamental data structures
  (characters, numbers, strings, arrays)
• use fundamental control structures   (if, while, for)
• know fundamental programming techniques   (recursion)
• fix simple bugs in incorrect programs

At the end of this course you should be able to:

• choose/develop effective data structures (DS)
  (graphs, search trees, …)
• choose/develop algorithms (A) on these DS
  (graph algorithms, tree algorithms, string algorithms, …)
• analyse performance characteristics of algorithms
• package a set of DS+A as an abstract data type
• develop and maintain C programs

• COMP9024

Ideas for the COMP9024 material are drawn from

• slides by Helen Paik (COMP9024 24T1), Aditya Joshi (COMP9024 23T3), Michael Thielscher (COMP9024 19T3,20T2), John Shepherd (COMP1927 16s2), Hui Wu (COMP9024 16s2) and Alan Blair (COMP1917 14s2)
• Robert Sedgewick's and Alistair Moffat's books, Goodrich and Tamassia's Java book, Skiena and Revilla's programming challenges book

Textbook

• Algorithms in C, Parts 1-4, Robert Sedgewick
• Algorithms in C, Part 5, Robert Sedgewick

Good books, useful beyond COMP9024 (but coding style …)

Supplementary textbook:

• Alistair Moffat
  Programming, Problem Solving, and Abstraction with C
  Pearson Educational, Australia, Revised edition 2013, ISBN 978-1-48-601097-4

Also, numerous online C resources are available.

Lectures will:

• present theory
• demonstrate problem-solving methods
• give practical demonstrations

Lecture documents (e.g., programs, notes or slides) will be made available before lecture each week

The weekly tutorials/classes, with tutors, aims to:

• analyze one C program
• clarify any problems with lecture material
• give practice with algorithm design skills

You may bring your own laptop to access materials or take notes

Important - tutorials provide an opportunity for a more intimate classroom experience where you can interact more closely with the tutors and other students.

We get very annoyed by people who plagiarise.

Examples of Plagiarism (student.unsw.edu.au/plagiarism):

1. Copying

   Using same or similar idea without acknowledging the source
   This includes copying ideas from a website, internet

2. Collusion

   Presenting work as independent when produced in collusion with others
   This includes students providing their work to another student

   • which includes using any form of publicly readable code repository

Your submissions will be checked for and will be reported to the Academic Integrity Unit at UNSW.

The goal is for you to become a better programmer

• more confident in your own ability to choose data structures
• more confident in your own ability to develop algorithms
• able to analyse and justify your choices
• producing a better end-product
• ultimately, enjoying the software design and development process

• good example of an imperative language
• gives the programmer great control
• produces fast code
• many libraries and resources
• main language for writing operating systems and compilers; and commonly used for a variety of applications in industry (and science)

C and UNIX operating system share a complex history …

• C was originally designed for and implemented on UNIX
• Dennis Ritchie was the author of C (around 1971)
• In 1973, UNIX was rewritten in C
• B (author: Ken Thompson, 1970) was the predecessor to C, but there was no A
• American National Standards Institute (ANSI) C standard published in 1988
  • this greatly improved source code portability

To compile a program prog.c, you type the following:

gcc prog.c -o prog

To report all warnings, type:

gcc -Wall prog.c -o prog

To run the program, type:

./prog

Formatted output written to standard output (e.g. screen)

int printf(const char *formatString, ...);

formatString can use the following placeholders:

Examples:

int num = 3;
printf("The cube of %d is %d.\n", num, num*num*num);

The cube of 3 is 27.

char ch  = 'z';
int num = 1234567;
printf("Your \"login ID\" will be in the form of %c%d.\n", ch, num);

Your "login ID" will be in the form of z1234567.

Algorithms are built using

• assignments
• conditionals
• loops
• function calls/return statements

• In C, each statement is terminated by a semicolon ;
• Curly brackets { } used to enclose statements in a block
• Usual arithmetic operators: +, -, *, /, %
• Usual assignment operators: =, +=, -=, *=, /=, %=
• The operators ++ and -- can be used to increment a variable (add 1) or decrement a variable (subtract 1)

Example: The pattern

v = getNextItem();
while (v != 0) {
   process(v);
   v = getNextItem();
}

can be written as

while ((v = getNextItem()) != 0) {
   process(v);
}

if (expression) {
   some statements;
}

if (expression) {
   some statements1;
} else {
   some statements2;
}

• some statements executed if, and only if, the evaluation of expression is non-zero
• some statements1 executed when the evaluation of expression is non-zero
• some statements2 executed when the evaluation of expression is zero
• Statements can be single instructions or blocks enclosed in { }

Indentation is very important in promoting the readability of the code

Each logical block of code is indented:

// Style 1 if (x) { statements; }

// Style 2 (my preference) if (x) { statements; }

// Preferred else-if style if (expression1) { statements1; } else if (exp2) { statements2; } else if (exp3) { statements3; } else { statements4; }

Relational and logical operators

a > b		a greater than b
a >= b		a greater than or equal to b
a < b		a less than b
a <= b		a less than or equal to b
a == b		a equal to b
a != b		a not equal to b
a && b		a logical and b
a || b		a logical or b
! a		logical not a

A relational or logical expression evaluates to 1 if true, and to 0 if false

C has two different "while loop" constructs

// while loop         
while (expression) {
    some statements; 
}

// do .. while loop
do {
   some statements;   
} while (expression);

The  do .. while  loop ensures the statements will be executed at least once

The "for loop" in C

for (expr1; expr2; expr3) {
   some statements;
}

• expr1 is evaluated before the loop starts
• expr2 is evaluated at the beginning of each loop
  • if it is non-zero, the loop is repeated
• expr3 is evaluated at the end of each loop

 

Example:

for (i = 1; i < 10; i++) { printf("%d %d\n", i, i * i); }

Functions have the form

return-type function-name(parameters) {

    declarations

    statements

    return …;
}

int square(int n) {
   int s;
   s = n * n;
   return s;
}

• if return_type is void then the function does not return a value
• if parameters is void then the function has no arguments

When a function is called:

1. memory is allocated for its parameters and local variables
2. the parameter expressions in the calling function are evaluated
3. C uses "call-by-value" parameter passing …
   • the function works only on its own local copies of the parameters, not the ones in the calling function
4. local variables need to be assigned before they are used   (otherwise they will have "garbage" values)
5. function code is executed, until the first return statement is reached

When a return statement is executed, the function terminates:

return expression;

1. the returned expression will be evaluated
2. all local variables and parameters will be thrown away when the function terminates
3. the calling function is free to use the returned value, or to ignore it

int add(int m, int n) {
    return m + n;    
}

The return statement can also be used to terminate a function of return-type void:

return;

• In C each variable must have a type
• C has the following data types:

  char		character		'A', 'e', '#', …
  short, int, long		integer		2, 17, -5, …
  float		floating-point number		3.14159f, …
  double		double precision floating-point		3.14159265358979, …

  There are other types (e.g., unsigned long), which are variations on these

• Variable declaration must specify a data type and a name; they can be initialised when they are declared:

  float x;
  char  ch = 'A';
  int   j = i;
  

Families of aggregate data types:

• homogeneous … all elements have same base type
  • arrays (e.g. char s[50], int v[100])
• heterogeneous … elements may combine different base types
  • structures (e.g. struct student { char name[32]; int zID; })

An array is

• a collection of same-type variables
• arranged as a linear sequence
• accessed using an integer subscript
• for an array of size N, valid subscripts are 0..N-1

int  a[20];    // array of 20 integer values/variables
char b[10];    // array of 10 character values/variables

Larger example:

#define MAX 20

int numbers[MAX];   // array of 20 integer values


for (int i = 0; i < MAX; i++) {
   numbers[i] = i * i;
}

We can define a macro in C (i.e., a symbolic constant)

#define SPEED_OF_LIGHT 299792458.0
#define ERROR_MESSAGE "Out of memory.\n"

Symbolic constants make the code easier to understand and maintain

#define NAME replacement_text

• The compiler's pre-processor will replace all occurrences of NAME with replacement_text
• it will not make the replacement if NAME is inside quotes ("…") or part of another name

UNSW Computing provides a style guide for C programs:

Not strictly mandatory for COMP9024, but very useful guideline

"String" is a special word for an array of characters

• end-of-string is denoted by '\0' (of type char and always implemented as 0)

If a character array t[6] contains the string "hello", this is how it would look in memory:

char t[6] = "hello";

 
-------------------------
| h | e | l | l | o | \0| 
-------------------------
  0   1   2   3   4   5  

Arrays can be initialised by code, or you can specify an initial set of values in declaration.

Examples:

char s[6]   = {'h', 'e', 'l', 'l', 'o', '\0'};

char t[6]   = "hello";

int arr[5]   = {5, 4, 3, 2, 1};

int vec[]   = {5, 4, 3, 2, 1};

In the last case, C infers the array length   (as if we declared vec[5]).

Formatted input read from standard input (e.g. keyboard)

scanf(format-string, expr1, expr2, …);

Example: InputOutput.c

#include <stdio.h>   //  printf() and scanf()
int main(void) {
    int number;
    printf("Enter an integer: \n");
    scanf("%d", &number);
    printf("You entered: %d \n", number);
    return 0;
}

$ gcc InputOutput.c -o InputOutput
$ ./InputOutput 
Enter an integer: 
30
You entered: 30 

When an array is passed as a parameter to a function

• the address of the start of the array is actually passed

int total;
int vec[10] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
…
total = sum(vec);

Within the function …

• the types of elements in the array are known
• the size of the array is unknown

Since functions do not know how large an array is:

• pass in the size of the array as an extra parameter, or
• include a "termination value" to mark the end of the array

#define N 10
int total;
int vec[N] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
…
total = sum(vec,N);

Implement a function that sums up all elements in an array.

Use the prototype

int sum(int[], int)

or

int sum(int *, int)

int sum(int vec[], int dim) { 
   int total = 0;

   for (int i = 0; i < dim; i++) {
      total += vec[i];
   }
   return total;
}

or

int sum(int *vec, int dim) { 
   int total = 0;

   for (int i = 0; i < dim; i++) {
      total += vec[i];
   }
   return total;
}

Examples:

Note:   q[0][1]==2.7    r[1][3]==8

Multi-dimensional arrays can also be initialised (must provide # of columns):

float q[][2] = {
   { 0.5, 2.7 },
   { 3.1, 0.1 }
};

C allows us to define new data type (names) via typedef:

typedef ExistingDataType NewTypeName;

Examples:

typedef float Temperature;

typedef int Matrix[20][20];

Reasons to use typedef:

• give meaningful names to value types

  typedef float Temperature;
  

• allow for easy changes to underlying type

typedef float Real;
Real complex_calculation(Real a, Real b) {
	Real c = log(a+b); … return c;
}

• "package up" complex type definitions for easy re-use

  typedef int Matrix[20][20];
  Matrix m;
  

A structure

• is a collection of variables, perhaps of different types, grouped together under a single name
• helps to organise complicated data into manageable entities
• is defined using the struct keyword

typedef struct {
   char name[32];
   int  zID;
} StudentT;

StudentT neo;

or

struct Student {
   char name[32];
   int  zID;
};

struct Student neo;