Subjects and resources that you bookmark will appear here.

Peter Cao

Caroline Koffke

The other major application of ArrayLists is sorting, which is placing elements in an ascending or descending order, but it is mainly used for ascending order. There are many sorting algorithms, but we'll only learn **selection sort** and **insertion sort** in this unit and **merge sort** in Unit 10. There are many others that you can view in this video:

π₯ Video on 50+ Sorts, Visualized - Bar Graph *Seize Warning*

Courtesy of Musicombo.

To determine whether an ArrayList is sorted, there is a quick algorithm that sees if the elements are always increasing. Here is its implementation:

```
/** Returns if the ArrayList is sorted in ascending order
*/
```

```
public static boolean isSorted(ArrayList<Integer> array) {
for (int i = 0; i < array.size() - 1) {
if (array.get(i + 1) < array.get(i)) { //checks if two array elements are in the
return false; // wrong order
}
}
return true;
}
```

```
/** Uses selection sort on an ArrayList
* 1. Originally the ArrayList is unsorted
* 2. We
```

`select`

```
the smallest number and swap it with the first element
* 3. Now the sorted subarray is the first item and the rest of the array is unsorted
* 4.
```

**Select**

```
the smallest of the unsorted numbers (the second smallest overall) and
* swap it with the second element
* 5. Now the first two elements are sorted and the rest are unsorted
* 6. Repeat until the rest of the elements are sorted
*/
public static ArrayList<Integer> selectionSort(ArrayList<Integer> array) {
for (int i = 0; i < array.size() - 1; i++) { // traverse to the second to last item, the last item is automatically the largest
int smallestIndex = i;
int smallestElement = array.get(i);
for (int j = i + 1; i < array.size(); j++) { //traverse through the rest of the array, looking for the smallest remaining item (less than smallestElement)
if (array.get(j) < smallestElement) {
smallestIndex = j;
smallestElement = array.get(j);
}
}
if (smallestIndex > i) { // swap the elements of i and j if the element of i isn't already the smallest
int originalItem = array.get(i);
array.set(i, smallestElement);
array.set(smallestIndex, originalItem);
}
}
return array;
}
```

Here is a visual graphic showing selection sort:

Courtesy of w3resource.

The other sorting algorithm is the **insertion sort**. Like selection sort, there are sorted and unsorted subarrays. Here is the implementation and pseudocode explaining why it is called insertion sort:

```
/** Uses insertion sort on an ArrayList
* 1. Assume the first element is already sorted
* 2. Select the second element
* 3.
```

`Insert`

```
it before the first element or keep it in place to make the first 2 elements sorted
* 4. Select the third element and
```

`insert`

```
it so that the first 3 elements are sorted
* 5. Repeat until all elements are sorted.
*/
public static ArrayList<Integer> insertionSort(ArrayList<Integer> array) {
for (int i = 1; i < array.length(); i++) {
int currentElement = array.get(i);
int currentIndex = i;
for (int j = i; j > 0 ; j--) {
if (currentElement < array.get(j - 1)) { // shifting the item left until properly placed by swapping consecutive items
itemToRight = array.get(j - 1);
array.set(j - 1, currentElement);
array.set(j, itemToRight);
}
}
}
return array;
}
```

Here is a visual version of insertion sort:

Courtesy of Wikipedia.

Take this quiz for a progress check on what youβve learned this year and get a personalized study plan to grab that 5!

START QUIZSign up now for instant access to 2 amazing downloads to help you get a 5

Browse Study Guides By Unit

π

Exam Reviews

π±

Unit 10: Recursion

β

Unit 1: Primitive Types

π±

Unit 2: Using Objects

π₯

Unit 3: Boolean Expressions and if Statements

πΉ

Unit 4: Iteration

βοΈ

Unit 5: Writing Classes

βοΈ

Unit 6: Array

πΎ

Unit 7: ArrayList

π»

Unit 8: 2D Array

π²

Unit 9: Inheritance

Thousands of students are studying with us for the AP Computer Science A exam.

join now