Understanding reference types

[comp1110-1U]
  • Liam O'Connor, Fabian Muehlboeck

Example 1. A puzzling question

[comp1110-1P]
  • Liam O'Connor, Fabian Muehlboeck

Without running this program, try to deduce what it will output:

void fun1(int[] arr) { arr[0] = 100; } void fun2(int[] arr) { arr = new int[]{5,4,3,2,1}; } void fun3(int i) { i = 200; } void main() { int[] arr = new int[]{1,2,3,4,5,6}; int i = arr[0]; fun1(arr); IO.println(arr[0]); IO.println(i); fun2(arr); IO.println(arr[0]); IO.println(i); fun3(i); IO.println(arr[0]); IO.println(i); }

You will only get the answer correct if you understand what happens in Java when values are passed to functions.

Definition 2. Passing by value (or copy)

[comp1110-1R]
  • Liam O'Connor, Fabian Muehlboeck

A function's variables, including its parameters, are local to that invocation of the function. When we invoke a function, some memory is set aside for a frame: storage space for the local variables in the function. The values of the arguments given in the function invocation are copied into the function's frame. This is called pass by value. When the function returns, the frame is no longer needed and destroyed.

This is why the function fun3 has no effect on its arguments in example Example 1.

Definition 3. Value types and reference types

[comp1110-1Q]
  • Liam O'Connor

Variables of type int and char (for example) are called value types. This means that a variable declared of type, say int:

int x;

Will contain a value, a single integer. When left uninitialised as above, they are initialised to a default value of 0.

By contrast, array types like int[] and char[] are what's called reference types. This means that a variable declared of an array type will not contain the array data itself, but instead will contain the location in memory where the data may be found. This location is called a reference or pointer.

Any type name that begins with a capital letter (e.g. String) is also a reference type. This is why Strings should not be compared with == — it would compare locations, not contents.

Definition 3 combined with Definition 2 tells us that when we call a function like fun1 or fun2 in Example 1, the array data itself is not copied into the function's frame, but instead just the reference is. When fun1 or fun2 are called, the variable arr in their frame has the same value as the variable arr in the frame of main — they both point to the same array. This means that when we call fun1, the contents of the array in main are observably changed, as the array indexing arr[0] follows the same pointer that is in main.

When we call fun2, however, nothing changes in the function main, because we don't follow the pointers, but instead just change the value of the local variable arr to point to a new array, then immediately discard it.

4. The Waterloo Java Visualizer

[comp1110-1S]
  • Liam O'Connor

The Waterloo Java Visualizer is a great way to visualise what's going on in these examples. Here's a link to Example 1 being visualised in it. Click "forward" to step through the program's execution.

Note that it doesn't support Java 25, so I had to include some cruft that Java 25 has since made obsolete like (a method-free) class, public static etc. We will learn about these things later in the course but they are not relevant for now.

5. Reference vs. Value Equality

[comp1110-1T]
  • Liam O'Connor, Fabian Muehlboeck

The difference between value types and reference types explains the differences between == and other methods to decide equality.

For value types, == happens to capture regular equality - for example, there are no two int values that represent the number 32 but are somehow different.

On the other hand, for reference types, == describes reference equality, identifying whether two references point to the same object in memory. Since there may be two different objects representing the same value, == is too strict in many cases. We have seen this for String equality and Array equality. It is the same way in general for objects of arbitrary classes, except that for those, by default, no other notion of equality comparison exists. We'll see later how to define our own equality comparison.

Finally, Enums are a special case: they are a reference type, but with a guarantee that each case of a Enum refers to the same object in memory. As such, comparing the references to Enum values using == is fine - as for ints, there are no two distinct values representing the same case.

Context

    Lecture. Classes and Sorting

    [comp1110-2026s2-lec03a]
    • August 11, 2026
    • Fabian Muehlboeck

    A Brief Intro to Classes and Objects

    [comp1110-79]
    • Fabian Muehlboeck

    The core concept in object-oriented programming is that of an object. An object combines data and behaviour, though this is something we will discuss later in the course. For now, we introduce some basic ideas that you will see more of very soon.

    Construction. Class Definitions

    [comp1110-80]
    • Fabian Muehlboeck

    In Java, objects are instances of classes. A class definition is a kind of data definition, similar to what we have seen before for enums. However, classes are much more powerful, and they are used to model pretty much everything in our programs that cannot be modeled by a simpler data type. The core parts we will deal with for now are fields, which contain an object's data, and methods, which define an object's behaviour. The basic definition of a class consists of the keyword class and a class name, followed by curly braces, like so:

    class Person { //this is where the fields and methods of a class go }

    This does define a new type Person. To create a new instance of it (i.e. an object), you could write something simliar to what we did for arrays, using the keyword new:

    Person p = new Person();

    This is not very useful, because the Person class above has no data or behaviour, but you can add those.

    By convention, class names in Java should be nouns that start with a capital letter, and use capital letters to mark the start of any word internal to the name. For example: LectureNote .

    Construction. Fields

    [comp1110-81]
    • Fabian Muehlboeck

    Every class can have arbitrarily many fields. At the very least, each field has a type and name, just like a local variable. There are some other properties that fields can have, which we'll see later. To define a field, you declare it just like a local variable:

    String name;

    You can also give the field a default value, just like a local variable definitions:

    String name = "Unknown";

    By convention, in Java, field names are camelCased. That is, they start with a lower-case letter and otherwise contain only letters and digits, with uppercase letters indicating the start of a new combined word, as in sumOfAllParts.

    In principle, you can read and write the fields of an object similar to how you can read and write individual array elements, though the syntax is more like when you ask an array for its length:

    String oname = obj.name; if(oname.equals("Unknown")) { obj.name = "Timmy"; }

    Warning. 

    • Fabian Muehlboeck
    Note that array.length has the special property that you cannot assign values to it.

    Example. Fields

    [comp1110-82]
    • Fabian Muehlboeck

    Say we want our Person class from earlier to have two fields: one representing the name of the person, and one representing their age. Names would typically be represented as Strings, and in our case, we only care about completed years of age, so we use int as the type for that field.

    class Person { int age; String name; }

    We can then create a new Person value and write to its fields:

    Person p = new Person(); p.name = "Timmy"; p.age = 5;

    Warning. 

    • Fabian Muehlboeck
    This is not how you would typically do this; we'll learn about the right way to do this later.

    Construction. Methods

    [comp1110-83]
    • Fabian Muehlboeck

    So far, we have sometimes written code in separate functions from the main function. But in every case so far, we had to give those functions all the arguments that they were supposed to work with.

    Methods defined in a class implicitly have access to the fields defined in that class. This is because methods always need to be called on a specifc object, whose field values can then be used within the method.

    So in principle, writing a method is just like writing a function, except inside a class. Within the class, you can all other methods within the class just like we called functions before.

    By convention, in Java, method names are camelCased. That is, they start with a lower-case letter and otherwise contain only letters and digits, with uppercase letters indicating the start of a new combined word, as in sumOfAllParts.

    class MyClass { int myMethod() { return 42; } }

    Example. Methods

    [comp1110-84]
    • Fabian Muehlboeck

    Building on our example from Example [comp1110-82], imagine we want to just have a way to print a nice description for any of our basic Person objects.

    To do this, we'll add a printDescription method to the class:

    class Person { int age; String name; void printDescription() { IO.println(name + " (Age " + age + ")"); } }

    We can try this with the following main function:

    void main() { Person p = new Person(); p.name = "Timmy"; p.age = 5; p.printDescription(); }

    This will print:

    Timmy (Age 5)

    Have we seen Objects before?

    [comp1110-85]
    • Fabian Muehlboeck

    Yes! Every string and array is an object. When we wrote guess.charAt(5), we were calling a method of the String class on the particular String object referred to by guess.

    Similarly, the difference between arr.length for arrays and str.length() for strings is that the former is a field that we can access, and the latter is a method we have to call.

    Understanding reference types

    [comp1110-1U]
    • Liam O'Connor, Fabian Muehlboeck

    Example. A puzzling question

    [comp1110-1P]
    • Liam O'Connor, Fabian Muehlboeck

    Without running this program, try to deduce what it will output:

    void fun1(int[] arr) { arr[0] = 100; } void fun2(int[] arr) { arr = new int[]{5,4,3,2,1}; } void fun3(int i) { i = 200; } void main() { int[] arr = new int[]{1,2,3,4,5,6}; int i = arr[0]; fun1(arr); IO.println(arr[0]); IO.println(i); fun2(arr); IO.println(arr[0]); IO.println(i); fun3(i); IO.println(arr[0]); IO.println(i); }

    You will only get the answer correct if you understand what happens in Java when values are passed to functions.

    Definition. Passing by value (or copy)

    [comp1110-1R]
    • Liam O'Connor, Fabian Muehlboeck

    A function's variables, including its parameters, are local to that invocation of the function. When we invoke a function, some memory is set aside for a frame: storage space for the local variables in the function. The values of the arguments given in the function invocation are copied into the function's frame. This is called pass by value. When the function returns, the frame is no longer needed and destroyed.

    This is why the function fun3 has no effect on its arguments in example Example [comp1110-1P].

    Definition. Value types and reference types

    [comp1110-1Q]
    • Liam O'Connor

    Variables of type int and char (for example) are called value types. This means that a variable declared of type, say int:

    int x;

    Will contain a value, a single integer. When left uninitialised as above, they are initialised to a default value of 0.

    By contrast, array types like int[] and char[] are what's called reference types. This means that a variable declared of an array type will not contain the array data itself, but instead will contain the location in memory where the data may be found. This location is called a reference or pointer.

    Any type name that begins with a capital letter (e.g. String) is also a reference type. This is why Strings should not be compared with == — it would compare locations, not contents.

    Definition [comp1110-1Q] combined with Definition [comp1110-1R] tells us that when we call a function like fun1 or fun2 in Example [comp1110-1P], the array data itself is not copied into the function's frame, but instead just the reference is. When fun1 or fun2 are called, the variable arr in their frame has the same value as the variable arr in the frame of main — they both point to the same array. This means that when we call fun1, the contents of the array in main are observably changed, as the array indexing arr[0] follows the same pointer that is in main.

    When we call fun2, however, nothing changes in the function main, because we don't follow the pointers, but instead just change the value of the local variable arr to point to a new array, then immediately discard it.

    The Waterloo Java Visualizer

    [comp1110-1S]
    • Liam O'Connor

    The Waterloo Java Visualizer is a great way to visualise what's going on in these examples. Here's a link to Example [comp1110-1P] being visualised in it. Click "forward" to step through the program's execution.

    Note that it doesn't support Java 25, so I had to include some cruft that Java 25 has since made obsolete like (a method-free) class, public static etc. We will learn about these things later in the course but they are not relevant for now.

    Reference vs. Value Equality

    [comp1110-1T]
    • Liam O'Connor, Fabian Muehlboeck

    The difference between value types and reference types explains the differences between == and other methods to decide equality.

    For value types, == happens to capture regular equality - for example, there are no two int values that represent the number 32 but are somehow different.

    On the other hand, for reference types, == describes reference equality, identifying whether two references point to the same object in memory. Since there may be two different objects representing the same value, == is too strict in many cases. We have seen this for String equality and Array equality. It is the same way in general for objects of arbitrary classes, except that for those, by default, no other notion of equality comparison exists. We'll see later how to define our own equality comparison.

    Finally, Enums are a special case: they are a reference type, but with a guarantee that each case of a Enum refers to the same object in memory. As such, comparing the references to Enum values using == is fine - as for ints, there are no two distinct values representing the same case.

    Back to Search

    [comp1110-86]
    • Fabian Muehlboeck

    Example. CLI driver for search procedures

    [comp1110-1M]
    • Liam O'Connor

    To make manual testing easier, we'll make a suitable main function that reads a certain number of inputs one number at a time using IO.readln() and then calls our search function.

    void main() { int length = 10; int[] a1 = new int[length]; int i = 0; while(i < length) { a1[i] = Integer.parseInt(IO.readln()); i = i + 1; } assert(binarySearch(a1, 5)); assert(binarySearch(a1, 1)); assert(binarySearch(a1, 10)); assert(binarySearch(a1, 9)); assert(!binarySearch(a1, 0)); assert(!binarySearch(a1, 15)); }

    The flexibility is nice, by but running this and manually entering a bunch of numbers every time can be a bit of a slog. You can therefore create a file, say "numbers.txt" (the file extension does not really matter), that contains those numbers:

    1 2 3 4 5 6 7 8 9 10

    You can of course create several different files with different lists of numbers.

    To use those files, you can call your program in a special way. If you normally start the program by writing:

    java BinarySearch

    You can instead write:

    java BinarySearch < numbers.txt

    The combination of a less-than sign < with a filename after it tells your terminal emulator to read that file and use it as the standard input for the program, instead of prompting the user. We use the same idea in Homework 1.

    Example. Sortedness Checker

    [comp1110-1K]
    • Liam O'Connor, Fabian Muehlboeck
     boolean isSorted(int[] haystack) { int i = 0; while(i < haystack.length - 1) { if(haystack[i] > haystack[i + 1]) { return false; } } return true; }

    Searching Arbitrary Arrays

    [comp1110-87]
    • Fabian Muehlboeck

    Binary Search is very efficient, but depends on the array being sorted. This may not be true of any array you might encounter. So, as a first attempt, you might want to use the sortedness checker from Example [comp1110-1K] to see if the array is sorted, and then depending on that either use binary search or the linear search procedure we saw in Example [comp1110-16].

    boolean search(int[] haystack, int needle) { if(isSorted(haystack)) { return binarySearch(haystack, needle); } else { return linearSearch(haystack, needle); } }

    The problem with the above approach is that when we are checking whether the array is sorted, we have to go through every element of the array. At that point, we might just check whether those elements are equal to needle right away.

    The general idea is more reasonable if there are several things that we want to search for. In that case, we only have to go through the array once, and if it happens to be sorted, we can then use binarySearch many times, efficiently finding each element.

    But better yet, in that case, we might just want to sort the array to guarantee that we can do those later searches efficiently.

    Understanding sorting

    [comp1110-1V]
    • Liam O'Connor

    Definition. A spec and a test suite for sorting

    [comp1110-1W]
    • March 10, 2026
    • Liam O'Connor

    Any in-place sorting algorithm, no matter how it is implemented, should satisfy the following spec:

    /** Sort an array in-place. There are two postconditions: - After executing, the array must be sorted. - After executing, the array must be some permutation of the values that existed before. (many programmers will get the former but forget the latter) @param arr the array to sort */ void sort(int[] arr)

    Assuming we had such a function, we might test it (using proper array comparison) as follows:

    void sortAndCheck (int[] toSort, int[] toCheck) { sort(toSort); assert Arrays.equal(toSort, toCheck); } void main (String[] args) { // already sorted sortAndCheck(new int[]{1,2,3,4,5,6,7,8,9}, new int[]{1,2,3,4,5,6,7,8,9}); // inversely sorted sortAndCheck(new int[]{9,8,7,6,5,4,3,2,1}, new int[]{1,2,3,4,5,6,7,8,9}); // random order sortAndCheck(new int[]{6,-5,212,42,19,0,0,5,9718}, new int[]{-5,0,0,5,6,19,42,212,9718}); // negative and inverse sortAndCheck(new int[]{-1,-2,-3,-4,-5}, new int[]{-5,-4,-3,-2,-1}); // empty sortAndCheck(new int[]{}, new int[]{}); // singleton sortAndCheck(new int[]{0}, new int[]{0}); // two sortAndCheck(new int[]{100,100}, new int[]{100,100}); }

    Definition. Quadratic sorting methods

    [comp1110-1X]
    • August 11, 2026
    • Liam O'Connor, Fabian Muehlboeck

    We demonstrated two sorting algorithms in the lecture:

    • Selection sort: We divide the array into an "unsorted zone" and a "sorted zone". The sorted zone begins empty at the start of the array, and the unsorted zone begins by occupying the whole array. Each loop iteration, we look through the unsorted zone, find the minimum, and swap it with the first element of the unsorted zone (right next to the sorted zone). This means that the sorted zone can be expanded by one element. Repeat until the unsorted zone is of size zero.
    • Bubble sort: Here, the "sorted zone" grows from the end of the array rather than the beginning. Loop through the unsorted zone comparing adjacent elements. If they are not in order, swap them. This will result in the highest element reaching the top. This means we can increase the size of the sorted zone. Repeat until all sorted.

      If we go through the unsorted zone without doing any swaps, we can immediately stop — the array is sorted. This is called an early exit trick.

    I briefly mentioned another one at the start of the workshop:

    • Insertion sort: The most popular of these three, and somewhat similar to selection sort, in that the sorted zone begins empty and grows from the left. Instead of finding the minimum, however, we take the first element from the unsorted zone and remember it (call it X) and shift everything greater than X in the sorted zone to the right one spot. Then we place X in the slot left over.

    These algorithms are called "quadratic" because they take a quadratic amount of key operations (in terms of the size of the array), in this case comparisons and moves/swaps to perform.

    While insertion sort is generally the most popular of the three, each of them have their own advantages, depending on your particular situation. On arrays:

    • Selection sort minimizes the number of times you have to move an array element.
    • Bubble sort only swaps adjacent elements and has an easy way to exit early on sorted arrays.
    • Insertion sort can minimize the number of comparisons that you do (these can become expensive on more complex data types).

    Which of these you actually get depends on the particulars of your implementation, and minor variations (say starting from the other direction) can make a huge difference for certain scenarios.

    Example. Selection sort

    [comp1110-1Y]
    • August 11, 2026
    • Liam O'Connor, Fabian Muehlboeck
     void selectionSort(int[] arr) { int i = 0; while(i < arr.length) { //INV : arr[0..i-1] is sorted AND for every j in // [i..arr.length-1], arr[j] >= every element // in arr[0..i-1] int currentMin = arr[i]; // could as well be always referred // to as arr[currentPos] int currentPos = i; int j = i + 1; while(j < arr.length) { //INT: arr[currentPos] is the minimum element in arr[i..j-1] if(arr[j] < currentMin) { currentMin = arr[j]; currentPos = j; } j = j + 1; } //arr[currentPos] is the minimum element in arr[i..arr.length-1] // from above, we know that it is greater than or equal to every // element in arr[0..i-1] int swap = arr[i]; arr[i] = arr[currentPos]; arr[currentPos] = swap; //therefore, swapping arr[currentPos] with arr[i] makes arr[0..i] // still sorted, and every element in arr[i+1..arr.length-1] // is >= every element in arr[0..i] . i = i + 1; } }

    Example. Bubble sort

    [comp1110-1Z]
    • August 11, 2026
    • Liam O'Connor

    Bubble sort swaps a lot of elements, but the key idea is that once it finds the maximum element in the unsorted part of the array, it keeps "bubbling" it up further and further, until we reach the end of the unsorted part, where a sorted array of elements larger than the new element is waiting. In that sense, it works like selection sort (either one of them could also just work in the other direction), but with more elements being moved around. We include the "early exit" trick mentioned by Definition [comp1110-1X]:

    void bubbleSort(int[] arr) { int i = arr.length - 1; while(i > 0) { // INV: arr[i..arr.length-1] is sorted, and // for every j in [0..i], arr[j] <= every element // in arr[i+1..arr.length-1] int j = 0; boolean swapped = false; while(j < i) { // INV: for every k < j, arr[k] < arr[j] // and if swapped == false, then arr[0..j-1] is sorted if(arr[j] > arr[j + 1]) { int swap = arr[j]; arr[j] = arr[j + 1]; arr[j+1] = swap; swapped = true; } j = j + 1; } // for every k < i, arr[k] < arr[i], and if // swapped == false, then arr[0..i-1] is sorted if(!swapped) { // at this point, both arr[0..i-1] and arr[i..arr.length-1] // are sorted, and we know that every element in // arr[0..i-1] is less than or equal to every element in // arr[i..arr.length-1]. hence, the whole array is sorted i = 0; } i = i - 1; } // arr[0..arr.length-1] is sorted }

    Definition. In-place

    [comp1110-20]

      An algorithm is in-place if only modifies existing structures, rather than create new ones. For example, for sorting an in-place function returns void, as they don't produce a new array, they just modify an old one. All our sorting algorithms in this section are in-place.

      Lecture. Sorting; Allocation

      [comp1110-1O]
      • March 13, 2026
      • Liam O'Connor

      Understanding reference types

      [comp1110-1U]
      • Liam O'Connor, Fabian Muehlboeck

      Example. A puzzling question

      [comp1110-1P]
      • Liam O'Connor, Fabian Muehlboeck

      Without running this program, try to deduce what it will output:

      void fun1(int[] arr) { arr[0] = 100; } void fun2(int[] arr) { arr = new int[]{5,4,3,2,1}; } void fun3(int i) { i = 200; } void main() { int[] arr = new int[]{1,2,3,4,5,6}; int i = arr[0]; fun1(arr); IO.println(arr[0]); IO.println(i); fun2(arr); IO.println(arr[0]); IO.println(i); fun3(i); IO.println(arr[0]); IO.println(i); }

      You will only get the answer correct if you understand what happens in Java when values are passed to functions.

      Definition. Passing by value (or copy)

      [comp1110-1R]
      • Liam O'Connor, Fabian Muehlboeck

      A function's variables, including its parameters, are local to that invocation of the function. When we invoke a function, some memory is set aside for a frame: storage space for the local variables in the function. The values of the arguments given in the function invocation are copied into the function's frame. This is called pass by value. When the function returns, the frame is no longer needed and destroyed.

      This is why the function fun3 has no effect on its arguments in example Example [comp1110-1P].

      Definition. Value types and reference types

      [comp1110-1Q]
      • Liam O'Connor

      Variables of type int and char (for example) are called value types. This means that a variable declared of type, say int:

      int x;

      Will contain a value, a single integer. When left uninitialised as above, they are initialised to a default value of 0.

      By contrast, array types like int[] and char[] are what's called reference types. This means that a variable declared of an array type will not contain the array data itself, but instead will contain the location in memory where the data may be found. This location is called a reference or pointer.

      Any type name that begins with a capital letter (e.g. String) is also a reference type. This is why Strings should not be compared with == — it would compare locations, not contents.

      Definition [comp1110-1Q] combined with Definition [comp1110-1R] tells us that when we call a function like fun1 or fun2 in Example [comp1110-1P], the array data itself is not copied into the function's frame, but instead just the reference is. When fun1 or fun2 are called, the variable arr in their frame has the same value as the variable arr in the frame of main — they both point to the same array. This means that when we call fun1, the contents of the array in main are observably changed, as the array indexing arr[0] follows the same pointer that is in main.

      When we call fun2, however, nothing changes in the function main, because we don't follow the pointers, but instead just change the value of the local variable arr to point to a new array, then immediately discard it.

      The Waterloo Java Visualizer

      [comp1110-1S]
      • Liam O'Connor

      The Waterloo Java Visualizer is a great way to visualise what's going on in these examples. Here's a link to Example [comp1110-1P] being visualised in it. Click "forward" to step through the program's execution.

      Note that it doesn't support Java 25, so I had to include some cruft that Java 25 has since made obsolete like (a method-free) class, public static etc. We will learn about these things later in the course but they are not relevant for now.

      Reference vs. Value Equality

      [comp1110-1T]
      • Liam O'Connor, Fabian Muehlboeck

      The difference between value types and reference types explains the differences between == and other methods to decide equality.

      For value types, == happens to capture regular equality - for example, there are no two int values that represent the number 32 but are somehow different.

      On the other hand, for reference types, == describes reference equality, identifying whether two references point to the same object in memory. Since there may be two different objects representing the same value, == is too strict in many cases. We have seen this for String equality and Array equality. It is the same way in general for objects of arbitrary classes, except that for those, by default, no other notion of equality comparison exists. We'll see later how to define our own equality comparison.

      Finally, Enums are a special case: they are a reference type, but with a guarantee that each case of a Enum refers to the same object in memory. As such, comparing the references to Enum values using == is fine - as for ints, there are no two distinct values representing the same case.

      Understanding sorting

      [comp1110-1V]
      • Liam O'Connor

      Definition. A spec and a test suite for sorting

      [comp1110-1W]
      • March 10, 2026
      • Liam O'Connor

      Any in-place sorting algorithm, no matter how it is implemented, should satisfy the following spec:

      /** Sort an array in-place. There are two postconditions: - After executing, the array must be sorted. - After executing, the array must be some permutation of the values that existed before. (many programmers will get the former but forget the latter) @param arr the array to sort */ void sort(int[] arr)

      Assuming we had such a function, we might test it (using proper array comparison) as follows:

      void sortAndCheck (int[] toSort, int[] toCheck) { sort(toSort); assert Arrays.equal(toSort, toCheck); } void main (String[] args) { // already sorted sortAndCheck(new int[]{1,2,3,4,5,6,7,8,9}, new int[]{1,2,3,4,5,6,7,8,9}); // inversely sorted sortAndCheck(new int[]{9,8,7,6,5,4,3,2,1}, new int[]{1,2,3,4,5,6,7,8,9}); // random order sortAndCheck(new int[]{6,-5,212,42,19,0,0,5,9718}, new int[]{-5,0,0,5,6,19,42,212,9718}); // negative and inverse sortAndCheck(new int[]{-1,-2,-3,-4,-5}, new int[]{-5,-4,-3,-2,-1}); // empty sortAndCheck(new int[]{}, new int[]{}); // singleton sortAndCheck(new int[]{0}, new int[]{0}); // two sortAndCheck(new int[]{100,100}, new int[]{100,100}); }

      Definition. Quadratic sorting methods

      [comp1110-1X]
      • August 11, 2026
      • Liam O'Connor, Fabian Muehlboeck

      We demonstrated two sorting algorithms in the lecture:

      • Selection sort: We divide the array into an "unsorted zone" and a "sorted zone". The sorted zone begins empty at the start of the array, and the unsorted zone begins by occupying the whole array. Each loop iteration, we look through the unsorted zone, find the minimum, and swap it with the first element of the unsorted zone (right next to the sorted zone). This means that the sorted zone can be expanded by one element. Repeat until the unsorted zone is of size zero.
      • Bubble sort: Here, the "sorted zone" grows from the end of the array rather than the beginning. Loop through the unsorted zone comparing adjacent elements. If they are not in order, swap them. This will result in the highest element reaching the top. This means we can increase the size of the sorted zone. Repeat until all sorted.

        If we go through the unsorted zone without doing any swaps, we can immediately stop — the array is sorted. This is called an early exit trick.

      I briefly mentioned another one at the start of the workshop:

      • Insertion sort: The most popular of these three, and somewhat similar to selection sort, in that the sorted zone begins empty and grows from the left. Instead of finding the minimum, however, we take the first element from the unsorted zone and remember it (call it X) and shift everything greater than X in the sorted zone to the right one spot. Then we place X in the slot left over.

      These algorithms are called "quadratic" because they take a quadratic amount of key operations (in terms of the size of the array), in this case comparisons and moves/swaps to perform.

      While insertion sort is generally the most popular of the three, each of them have their own advantages, depending on your particular situation. On arrays:

      • Selection sort minimizes the number of times you have to move an array element.
      • Bubble sort only swaps adjacent elements and has an easy way to exit early on sorted arrays.
      • Insertion sort can minimize the number of comparisons that you do (these can become expensive on more complex data types).

      Which of these you actually get depends on the particulars of your implementation, and minor variations (say starting from the other direction) can make a huge difference for certain scenarios.

      Example. Selection sort

      [comp1110-1Y]
      • August 11, 2026
      • Liam O'Connor, Fabian Muehlboeck
       void selectionSort(int[] arr) { int i = 0; while(i < arr.length) { //INV : arr[0..i-1] is sorted AND for every j in // [i..arr.length-1], arr[j] >= every element // in arr[0..i-1] int currentMin = arr[i]; // could as well be always referred // to as arr[currentPos] int currentPos = i; int j = i + 1; while(j < arr.length) { //INT: arr[currentPos] is the minimum element in arr[i..j-1] if(arr[j] < currentMin) { currentMin = arr[j]; currentPos = j; } j = j + 1; } //arr[currentPos] is the minimum element in arr[i..arr.length-1] // from above, we know that it is greater than or equal to every // element in arr[0..i-1] int swap = arr[i]; arr[i] = arr[currentPos]; arr[currentPos] = swap; //therefore, swapping arr[currentPos] with arr[i] makes arr[0..i] // still sorted, and every element in arr[i+1..arr.length-1] // is >= every element in arr[0..i] . i = i + 1; } }

      Example. Bubble sort

      [comp1110-1Z]
      • August 11, 2026
      • Liam O'Connor

      Bubble sort swaps a lot of elements, but the key idea is that once it finds the maximum element in the unsorted part of the array, it keeps "bubbling" it up further and further, until we reach the end of the unsorted part, where a sorted array of elements larger than the new element is waiting. In that sense, it works like selection sort (either one of them could also just work in the other direction), but with more elements being moved around. We include the "early exit" trick mentioned by Definition [comp1110-1X]:

      void bubbleSort(int[] arr) { int i = arr.length - 1; while(i > 0) { // INV: arr[i..arr.length-1] is sorted, and // for every j in [0..i], arr[j] <= every element // in arr[i+1..arr.length-1] int j = 0; boolean swapped = false; while(j < i) { // INV: for every k < j, arr[k] < arr[j] // and if swapped == false, then arr[0..j-1] is sorted if(arr[j] > arr[j + 1]) { int swap = arr[j]; arr[j] = arr[j + 1]; arr[j+1] = swap; swapped = true; } j = j + 1; } // for every k < i, arr[k] < arr[i], and if // swapped == false, then arr[0..i-1] is sorted if(!swapped) { // at this point, both arr[0..i-1] and arr[i..arr.length-1] // are sorted, and we know that every element in // arr[0..i-1] is less than or equal to every element in // arr[i..arr.length-1]. hence, the whole array is sorted i = 0; } i = i - 1; } // arr[0..arr.length-1] is sorted }

      Definition. In-place

      [comp1110-20]

        An algorithm is in-place if only modifies existing structures, rather than create new ones. For example, for sorting an in-place function returns void, as they don't produce a new array, they just modify an old one. All our sorting algorithms in this section are in-place.

        Related

          Example. A puzzling question

          [comp1110-1P]
          • Liam O'Connor, Fabian Muehlboeck

          Without running this program, try to deduce what it will output:

          void fun1(int[] arr) { arr[0] = 100; } void fun2(int[] arr) { arr = new int[]{5,4,3,2,1}; } void fun3(int i) { i = 200; } void main() { int[] arr = new int[]{1,2,3,4,5,6}; int i = arr[0]; fun1(arr); IO.println(arr[0]); IO.println(i); fun2(arr); IO.println(arr[0]); IO.println(i); fun3(i); IO.println(arr[0]); IO.println(i); }

          You will only get the answer correct if you understand what happens in Java when values are passed to functions.

          Definition. Passing by value (or copy)

          [comp1110-1R]
          • Liam O'Connor, Fabian Muehlboeck

          A function's variables, including its parameters, are local to that invocation of the function. When we invoke a function, some memory is set aside for a frame: storage space for the local variables in the function. The values of the arguments given in the function invocation are copied into the function's frame. This is called pass by value. When the function returns, the frame is no longer needed and destroyed.

          This is why the function fun3 has no effect on its arguments in example Example [comp1110-1P].

          Definition. Value types and reference types

          [comp1110-1Q]
          • Liam O'Connor

          Variables of type int and char (for example) are called value types. This means that a variable declared of type, say int:

          int x;

          Will contain a value, a single integer. When left uninitialised as above, they are initialised to a default value of 0.

          By contrast, array types like int[] and char[] are what's called reference types. This means that a variable declared of an array type will not contain the array data itself, but instead will contain the location in memory where the data may be found. This location is called a reference or pointer.

          Any type name that begins with a capital letter (e.g. String) is also a reference type. This is why Strings should not be compared with == — it would compare locations, not contents.

          bars magnifying-glass caret-down plus minus arrow-right xmark