Selection Sort: Comparing Each Adjacent Item

The next sorting algorithm in this series is the selection sort. Selection sort is also one of the easiest algorithms to understand and translate into functioning code.

A basic example of a selection sort would be to line up ten people(all having varying heights) in a row. Find the shortest person in the line and switch them with the person in position one. Then, find the next shortest person and swap them with the person in position two. Repeat until all ten people are sorted from shortest to tallest.

If we have a list with six items, we will need to make a comparison on the first element five times, the second element four times, the third element three times, etc.(5+4+3+…) From this, we can generalize that that worst-case runtime is 0(n²). Also, we will be using two for loops which also hints to a n² runtime.

Here is a basic example of a selection sort in Java.

/**
 * @author Anthony Jones
 * @version 1.01
 *
 * This is the selection sort method. specifically
 * an in place comparison sort
 *
 * @param A
 * int array
 */
public static void selectionSort(int[] A) {
  int temp;
  for (int i = 0; i < A.length; i++) {
    int n = i;
    for (int j = i + 1; j < A.length; j++) {
      if (A[j] < A[n])
        n = j;
    }
    temp = A[i];
    A[i] = A[n];
    A[n] = temp;
  }
}

Lastly, don’t forget to test your code. Here is a JUnit test case I wrote to test if my result arrays were sorted.

/**
* The test for selection sort method three for large array
*
* @author Anthony Jones
* @version 1.01
*/
@Test
public void selectionSortTestThree_Large() {
  System.out.println();
  System.out.println("Selection Sort Test Three");
  int[] arr = { 1, 4, 2, 9, 7, 3, 10, 20, 11, 13, 19 };
  System.out.println("intital array to be sorted");
  for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i]);
  }
  System.out.println();
  int[] expected = { 1, 2, 3, 4, 7, 9, 10, 11, 13, 19, 20 };
  System.out.println("expected array to be compared to");
  for (int i = 0; i < expected.length; i++) {
    System.out.print(expected[i]);
  }
  System.out.println();
  System.out.println("intital array after the sort");
  sortingAlgorithms.selectionSort(arr);
  for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i]);
    assertEquals(arr[i], expected[i]);
  }
}

Bubble Sort: Comparing Each Adjacent Item

The first sorting algorithm that we will discuss in this series is the bubble sort. Bubble sort is one of the simplest algorithms to understand and translate into functioning code.

A basic analogy of a bubble sort would be to line up ten people(all have varying heights) in a row. Moving from left to right, if the current person’s height is greater than the next person’s height, swap them around. Repeat until all ten people are sorted from shortest to tallest.

In the code, we would simply write a method for swapping two elements of an array and then with for loops, traverse the array until all items are sorted.

The array will need to be traversed at least n-1(n is the number of objects in the array) times to ensure that all objects are sorted. While the bubble sort is useful as a learning tool, it is not one of the most efficient sorting algorithms. It’s worst case runtime is 0(n²), because we need to make n iterations through a list checking all n elements each pass through.

Below is a basic example of a bubble sort in Java.

/**
 * @author Anthony Jones
 * @version 1.01
 *
 * This method repeatedly steps through the list
 * and compares each adjacent item and sorts.
 * @param A
 * int array
 */
public static void bubbleSort(int[] A) {
  boolean isSwapped;
  int temp;
  for (int i = 0; i < A.length; i++) { isSwapped = false; for (int j = A.length - 1; j >= i + 1; j--) {
      if (A[j] < A[j - 1]) {
        // Lines 19-22 can be replaced with a swap method
        temp = A[j];
        A[j] = A[j - 1];
        A[j - 1] = temp;
        isSwapped = true;
      }
    }
    if (isSwapped != true)
      break;
  }
  return;
}

This code can be further optimized. Please give it a try yourself and post a link to your solution in the comments. Here are some hints on how to improve the performance of your code.

Method 1:

After one iteration through the array, we don’t need to check the rightmost element because we already know that it is sorted. After two iterations, the last two elements in the array will be sorted. If we follow this pattern, we can generalize that after k iterations through the full array, checking the last k elements is redundant.

Method 2:

Check if the list is sorted after each iteration.

Lastly, don’t forget to test your code. Here is a JUnit test case I wrote to test if my result arrays were sorted.

/**
 * The test class bubbleSort method three.
 *
 * @author Anthony Jones
 * @version 1.01
 */
@Test
public void bubbleSortTestThree_Large() {
  System.out.println();
  System.out.println("Bubble Sort Test Three");
  int[] arr = { 1, 5, 9, 2, 4, 3, 10, 20, 13, 15, 11 };
  System.out.println("intital array to be sorted");
  for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i]);
  }
  System.out.println();
  int[] expected = { 1, 2, 3, 4, 5, 9, 10, 11, 13, 15, 20 };
  System.out.println("expected array to be compared to");
  for (int i = 0; i < expected.length; i++) {
    System.out.print(expected[i]);
  }
  System.out.println();
  System.out.println("intital array after the sort");
  sortingAlgorithms.bubbleSort(arr);
  for (int i = 0; i < arr.length; i++) {
    System.out.print(arr[i]);
    assertEquals(arr[i], expected[i]);
  }
}

Phil Weaver, Eve Andersson, Casey Burkhardt, Hugh Oh, and Mark Riccobono presented at Google IO on Android accessibility and how we can remove and replace assumptions about users and how they interact with Android apps.

I will briefly cover three means of achieving this and the assumptions that come along with each technology.

TalkBack: this is a screen reader that adds spoken, audible, and vibration feedback to your device. It helps blind and vision-impaired users interact with their devices. It makes the assumption that users can hear but not see.

Enable TalkBack

BrailleBack: BrailleBack allows users to connect a refreshable braille device via Bluetooth. Users can navigate using their display and input text using the braille keyboard. This tool assumes that users can’t hear or see.

Enable BrailleBack

Switch Access: this enables users to interact with a device using one or more buttons/switches that work like keyboard keys. This removes that assumption that a user can touch and interact with a screen with their hands.

Enable Switch Access

Developers have the important task of making sure application code can properly interact with these devices. Phil Weaver noted that the World Health Organization estimates 15% of people have some disability (1 billion people).

Catching accessibility bugs as early as possible using automated testing(Android Lint, etc.) and manually testing are essential to making sure our Android applications can be using by everyone.

The basic solutions making your apps accessible on Android are the following:

1. Adding descriptions to all image that convey meaning

contentDescription="@string/desc"

2. Give users immediate feedback on view updates.

android:accessibilityLiveRegion="polite"

3. Remove redundant text

android:contentDescription="7 Button" // incorrect as screen reader reads "7 Button Button"
android:contentDescription="7" // correct as screen reader reads "7 Button"

4. Remove extraneous clickable views on the screen

android:clickable="true" // Region 1
android:clickable="true" // Region 2
android:clickable="true" // Region 3

When using a tool such as Switch Access, users will have to scan through all regions that are clickable, so having extraneous clickable regions hinders the overall user experience.

In comes Accessibility Checker For Android!

Accessibility Checker is a new Google Research project and it looks specifically for accessibility defects. It will help us automatically find issues like: missing speakable descriptions and incorrectly labeled views. This is available today in both the Espresso(2.2+) and Robolectric testing frameworks.

Setting up Espresso

/**
* Enable Accessibility Checker in Espresso 2.2+
*/
@Test
public void setUp() {
AccessibilityChecks.enable(); // one extra line of code to enable accessibility checks
}

Getting Started with Robolectric

/**
* Enable Accessibility Checker in Robolectric
*/
@Test
@AccessibilityChecks // One line Java annotation to enable accessibility checks
public void testOneButton_shouldAddOne() {
...
}

Resources

For further reading and a more in-depth look at accessible application development in Android please visit Developing Accessible Applications

Out of this conversation came Jekyll Starter Kit, which is a project boilerplate with configurable tools for static site development. These tools provide synchronized cross-device testing with a focus on performance. This is a good starting point for developers who want to build a Jekyll site with fewer layers of abstraction in their tooling.

How it Works

Below is a snippet of the package.json file. With NPM run scripts, you can define strings which will be run on the command line when you invoke the script. For example, you could have a script called “build” that runs other commands. You can also run any Unix or Windows command in the package.json file!

{
  "name": "jekyll-starter-kit",
  "version": "1.0.0",
  "description": "jekyll, asset build using npm scripts",
  "main": "src/scripts/main.js",
  "scripts": {
    "build:jekyll": "jekyll build --config _config.yml,_config-dev.yml",
    "build:js": "npm run eslint && npm run uglify",
    "build:css": "npm run sass && npm run prefix",
    "build:font": "npm run font",
    "build:images": "npm run imagemin",
    "build": "npm run clean && npm run build:js && npm run build:css
              && npm run build:jekyll && npm run critical"
  }
}

Performance

Jekyll Starter Kit strives to give you a high-performance starting point out of the box. By default, your project will have a 99/100 on PageSpeed Insights. You will need to add caching on your server (8 days recommended) to bring it to 100/100.