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.

Context

    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.

      Backlinks

        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 }

        Complexity cases

        [comp1110-2D]
        • Liam O'Connor

        Often the running time of an algorithm depends on the arrangement of the input (such as in insertion sort). For this reason we talk about best-case, average-case worst-case complexity. Worst-case complexity is usually the most useful, because it gives a guarantee that the algorithm will never take longer than that bound.

        Space complexity

        [comp1110-2E]
        • Liam O'Connor

        We can also analyse how much memory an algorithm uses. This is called space complexity. Algorithms like insertion sort and selection sort operate directly on the array and use only a few extra variables, so their space complexity is \(\mathrm {O}(1)\). Merge sort, however, needs an additional temporary array during the merge step, so it requires \(\mathrm {O}(n)\) extra space.

        Example. Time complexity of searching and sorting

        [comp1110-2F]
        • Liam O'Connor
        • Linear search through an array of \(n\) elements: If the target happens to be the first element, the algorithm stops immediately; this is the best case and takes constant time, \(\mathrm {O}(1)\). In the worst case the element is last or not present, so the algorithm must check all \(n\) elements. The worst-case running time is therefore \(\mathrm {O}(n)\).
        • Binary search on a sorted array. Each comparison eliminates half of the remaining elements. After one step at most \(\frac {n}{2}\) elements remain, then \(\frac {n}{4}\), then \(\frac {n}{8}\), and so on. After about \(\log _2 n\) steps only one element remains. Thus binary search runs in \(\mathrm {O}(\log n)\) time in the worst case.
        • Selection sort repeatedly scans the remaining part of the array to find the smallest element. Even if the array is already sorted, it still performs the same number of comparisons, roughly \(\frac {n(n-1)}{2}\). Its running time therefore grows like \(n^2\), so it is \(\mathrm {O}(n^2)\) in both the best and worst cases.
        • Insertion sort behaves differently. If the array is already sorted, each new element is compared once and left in place, so the running time grows linearly: \(\mathrm {O}(n)\). But if the array is in reverse order, each insertion shifts many elements and the total work grows like \(n^2\). Thus the best case is \(\mathrm {O}(n)\) and the worst case is \(\mathrm {O}(n^2)\).
        • Bubble sort with early exit is similar. If the list is already sorted, it finishes after one pass, which is \(\mathrm {O}(n)\). In the worst case — where one small element appears out of order towards the end of the list — it performs many passes and becomes \(\mathrm {O}(n^2)\).
        • Merge sort works differently. It divides the list in half, sorts each half, and then merges them. The list can be halved only about \(\log _2 n\) times, and each level of this process requires work proportional to \(n\) to perform the merges. The total work therefore grows like \(n \log n\). Unlike some previous sorts, this running time does not depend on the initial order of the input: both the best and worst cases are \(\mathrm {O}(n \log n)\).
        bars magnifying-glass caret-down plus minus arrow-right xmark