Lecturer in Charge:		Changwei Zou
Office:		K17-501E
Consults:		non-technical/personal issue - by appointments ...
		technical/course contents - Use CSE Help, or Course Forum

Course admin:		Mingqin Yu
A team of tutors:		... who are they?
Email address to use:		cs9024@cse.unsw.edu.au

Tutors:		Deniz Dilsiz
		Ziming Gong
		Janhavi Jain
		Joffrey Ji
		Leman Kirme
		Ziting Li
		Kisaru Liyanage
		Thirasara Beruwawela Pathiranage
		Adiyat Rahman
		Fritz Rehde
		Finn Xu
		Oliver Xu
		Sijia Xu
		Nimish Ukey
		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, 6pm-7pm)				--		|
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 6-8pm (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 late 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, 6-7pm).

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)
• using your own laptop with locked-down browser
• some multiple-choice questions
• (maybe) some descriptive/analytical questions

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), 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

#include <stdio.h>

int f(int m, int n) {

   while (m != n) {
      if (m > n) {
	 m = m-n;
      } else {
	 n = n-m;
      }
   }
   return m;
}

int main(void) {

   printf("%d\n", f(30,18));
   return 0;
}

Insertion Sort algorithm (in Pseudo Code):

insertionSort(A):
|  Input array A[0..n-1] of n elements
|
|  for all i=1..n-1 do
|  |  element=A[i], j=i-1
|  |  while j≥0 and A[j]>element do
|  |     A[j+1]=A[j]
|  |     j=j-1
|  |  end while
|  |  A[j+1]=element
|  end for

#include <stdio.h> // include standard I/O library defs and functions

#define SIZE 6     // define a symbolic constant

void insertionSort(int array[], int n) {  // function headers must provide types
   int i;                                 // each variable must have a type
   for (i = 1; i < n; i++) {              // for-loop syntax
      int element = array[i];                                                    
      int j = i-1;
      while (j >= 0 && array[j] > element) {  // logical AND
         array[j+1] = array[j];
         j--;                                 // abbreviated assignment j=j-1 
      }
      array[j+1] = element;                   // statements terminated by ;
   }                                          // code blocks enclosed in { } 
}

int main(void) {                              // main: program starts here
   int numbers[SIZE] = { 3, 6, 5, 2, 4, 1 };  /* array declaration
                                                 and initialisation */
   int i;
   insertionSort(numbers, SIZE);
   for (i = 0; i < SIZE; i++)
      printf("%d\n", numbers[i]);             // printf defined in <stdio>

   return 0;           // return program status (here: no error) to environment
}

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

gcc prog.c

To run the program, type:

./a.out

Command line options:

• The default with gcc is not to give you any warnings about potential problems
• Good practice is to be tough on yourself:

  gcc -Wall prog.c
  

  which reports all warnings to anything it finds that is potentially wrong or non ANSI compliant

• The -o option tells gcc to place the compiled object in the named file rather than a.out

  gcc -o prog prog.c
  

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.

• Can also use width and precision:

  printf("%8.3f\n", 3.14159);
  

     3.142
  

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)
  • It is recommended to put the increment or decrement operator after the variable:

    
             // suppose k=6 initially
    k++;     // increment k by 1; afterwards, k=7
    n = k--; // first assign k to n, then decrement k by 1
             // afterwards, k=6 but n=7
    

  • It is also possible (but NOT recommended) to put the operator before the variable:

    
             // again, suppose k=6 initially
    ++k;     // increment k by 1; afterwards, k=7
    n = --k; // first decrement k by 1, then assign k to n
             // afterwards, k=6 and n=6
    

C assignment statements are really expressions

• they return a result: the value being assigned
• the return value is generally ignored

• to combine the test with collecting the next value
• to make the expression of such loops more concise

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

is often written as

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

1. 
   a = 1; b = 5;
   while (a < b) {
      a++;
      b--;
   }
   

2. 
   a = 1; b = 5;
   while ((a += 2) < b) {
      b--;
   }
   

1. a == 3, b == 3
2. a == 5, b == 4

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 b
a < b		a less than b
a <= b		a less than or equal 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); }

int i, j;
for (i = 8; i > 1; i /= 2) {
    for (j = i; j >= 1; j--) {
        printf("%d%d\n", i, j);
    }
    printf("\n");
}

88
87
..
81

44
..
41

22
21

Functions have the form

return-type function-name(parameters) {

    declarations

    statements

    return …;
}

• 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

// Euclid's GCD (the Greatest Common Divisor) algorithm (recursive version)
int euclid_gcd(int m, int n) {
    if (n == 0) {
        return m;
    } else {
        return euclid_gcd(n, 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 generic data types:

  char		character		'A', 'e', '#', …
  short, int, long		integer		2, 17, -5, …
  float		floating-point number		3.14159, …
  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[30]; 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 i;           // integer value used as index
int fact[MAX];   // array of 20 integer values

fact[0] = 1;
for (i = 1; i < MAX; i++) {
    fact[i] = i * fact[i-1];
}

We can define a symbolic constant at the top of the file

#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

Style considerations that do matter for your COMP9024 assignments:

• use proper layout, including consistent indentation
  • 3 spaces throughout, or 4 spaces throughout
    do not use TABs
• keep functions short and break into sub-functions as required
• use meaningful names (for variables, functions etc)
• use symbolic constants to avoid burying "magic numbers" in the code
• comment your code

"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 s[11] contains the string "hello", this is how it would look in memory:

  0   1   2   3   4   5   6   7   8   9   10
---------------------------------------------
| h | e | l | l | o | \0|   |   |   |   |   |
---------------------------------------------

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, …);

Converting string into integer

int value = atoi(string);

Example:

#include <stdio.h>   // includes definition of BUFSIZ (usually =512) and scanf()
#include <stdlib.h>  // includes definition of atoi()

...

char str[BUFSIZ];
int n;

printf("Enter a string: ");
scanf("%s", str);
n = atoi(str);
printf("You entered: \"%s\". This converts to integer %d.\n", str, n);

Enter a string: 9024
You entered: "9024". This converts to integer 9024.

When an array is passed as a parameter to a function

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

int total, vec[20];
…
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

int total, vec[20];
…
total = sum(vec,20);

Also, since the function doesn't know the array size, it can't check whether we've written an invalid subscript (e.g. in the above example 100 or 20).

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

Use the prototype

int sum(int[], int)

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

   for (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   (documentation)
  • is a given number Temperature, Dollars, Volts, …?
• 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
  • many examples to follow; Matrix is a simple example

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
• exposes the connection between data within an entity
• is defined using the struct keyword

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

One structure can be nested inside another:

typedef struct {
	int day, month;
} DateT;

typedef struct {
	int hour, minute;
} TimeT;

typedef struct {
	char   plate[7];   // e.g. "DSA42X"
	double speed;
        DateT  d;
	TimeT  t;
} TicketT;

Possible memory layout produced for TicketT object:

---------------------------------
| D | S | A | 4 | 2 | X | \0|   |    7 bytes + 1 padding
---------------------------------
|                          68.4 |    8 bytes
---------------------------------
|             2 |             6 |    8 bytes
---------------------------------
|            20 |            45 |    8 bytes
---------------------------------

Don't normally care about internal layout, since fields are accessed by name.

Defining a structured data type itself does not allocate any memory

We need to declare a variable in order to allocate memory

DateT christmas;

The components of the structure can be accessed using the "dot" operator

christmas.day   =   25;
christmas.month =   12;

With the above TicketT type, we declare and use variables as …

#define NUM_TICKETS 1500

typedef struct {…} TicketT;

TicketT tickets[NUM_TICKETS];  // array of structs

// Print all speeding tickets in a readable format
for (i = 0; i < NUM_TICKETS; i++) {
    printf("%s %6.2f %d/%d at %d:%d\n", tickets[i].plate,
                                        tickets[i].speed,
                                        tickets[i].d.day,
                                        tickets[i].d.month,
                                        tickets[i].t.hour,
                                        tickets[i].t.minute);
}

// Sample output:
//
// DSA42X  68.40 2/6 at 20:45

A structure can be passed as a parameter to a function:

void print_date(DateT d) {

	printf("%d/%d\n", d.day, d.month);
}

int is_winter(DateT d) {

	return ( (d.month >= 6) && (d.month <= 8) );
}

A data type is …

• a set of values   (atomic or structured values)     e.g. integer stacks
• a collection of operations on those values   e.g. push, pop, isEmpty?

• is a logical description of how we view the data and operations
• without regard to how they will be implemented
• creates an encapsulation around the data
• is a form of information hiding

Users of the ADT see only the interface

Builders of the ADT provide an implementation

ADT interface provides

• a user-view of the data structure
• function signatures (prototypes) for all operations
• semantics of operations (via documentation)
• ⇒  a "contract" between ADT and its clients

• concrete definition of the data structures
• function implementations for all operations

ADT interfaces are opaque

• clients cannot see the implementation via the interface

• facilitate decomposition of complex programs
• make implementation changes invisible to clients
• improve readability and structuring of software
• allow for reuse of modules in other systems

Queue, aka FIFO data structure (first in, first out)

Insert and delete are called enqueue and dequeue

Applications:

• the checkout at a supermarket
• people queueing to go onto a bus
• objects flowing through a pipe (where they cannot overtake each other)
• chat messages
• web page requests arriving at a web server
• printing jobs arriving at a printer
• …

Compilers are programs that

• convert program source code to executable form
• "executable" might be machine code or bytecode

• applies source-to-source transformation (pre-processor)
• compiles source code to produce object files
• links object files and libraries to produce executables

Compilation/linking with gcc

gcc -c Stack.c
produces Stack.o, from Stack.c and Stack.h

gcc -c brackets.c
produces brackets.o, from brackets.c and Stack.h

gcc -o rbt brackets.o Stack.o
links brackets.o, Stack.o and libraries
producing executable program called rbt

Note that stdio,assert included implicitly.

gcc is a multi-purpose tool

• compiles (-c), links, makes executables (-o)

• Introduction to Algorithms and Data Structures
• C programming language, compiling with gcc
  • Basic data types (char, short, int, long, float, double)
  • Basic programming constructs (if … else conditionals, while loops, for loops)
  • Basic data structures (atomic data types, arrays, structures)
• Introduction to ADTs
• Compilation