Accessing consecutive pairs of elements is part of a collection of standard algorithms.

Check if a list is sorted

This demonstration checks if an array is sorted in ascending order (smallest to largest) and allows duplicates. An empty array is considered sorted.

Determining if an array is sorted can be accomplished by checking each pair of adjacent elements (elements at consecutive indexes). If any pair is found to be out of order, the array is not sorted. If there is no pair that is out of order, the array is sorted.

Algorithm

Loop through every element except the first.
    If the element before the current element is greater than the current element
        Return false.

Return true.

Implementation in Java

public static boolean isSorted(int[] nums)
{
    for(int i = 1; i < nums.length; i++)
    {
        if(nums[i - 1] > nums[i])
            return false;
    }
    
    return true;
}

When skipping one or more elements, my preference is to start the loop later rather than end it earlier. This avoids the somewhat odd condition i < nums.length - 1 in the alternate solution below.

Alternate algorithm

Loop through every element except the last.
    If the current element is greater than the one after it
        Return false.

Return true.

Alternate implementation in Java

public static boolean isSorted(int[] nums)
{
    for(int i = 0; i < nums.length - 1; i++)
    {
        if(nums[i] > nums[i + 1])
            return false;
    }
    
    return true;
}

Some programmers prefer to skip the last value instead of the first. In this case, the values at indexes i and i + 1 are checked.

Get the sums of all adjacent elements

Given an array of even length, return an array containing the sums of each pair of adjacent elements. Each element is part of exactly 1 pair. For example:

int[] sums = getSums(new int[] {1, 2, 3, 4, 5, 6});

results in sums having the values:

[3, 7, 11]

3 is 1 + 2.
7 is 3 + 4.
11 is 5 + 6.

Algorithm

Create an array, sums, with length nums.length / 2

Loop through each pair of elements in nums (increment by 2).
    Set sums[i / 2] to the sum of the current pair.

Return sums.

Implementation in Java

// precondition: nums.length % 2 == 0
public static int[] getSums(int[] nums)
{
    int[] sums = new int[nums.length / 2];
    
    for(int i = 0; i < nums.length; i += 2)
    {
        sums[i / 2] = nums[i] + nums[i + 1];
    }
    
    return sums;
}

This example defines pairs of consecutive elements differently than the example that checks if a list is sorted. In this example, each element is part of exactly 1 pair. The pairs are at indexes 0 and 1, 2 and 3, 4 and 5, and so on.

When checking if a list is sorted, most elements are part of 2 pairs. The pairs are at indexes 0 and 1, 1 and 2, 2 and 3, and so on.

The index in sums is calculated as i / 2, where i is the index of the first element in each pair in nums.

i	i / 2
0	0
2	1
4	2
6	3

It is also possible to maintain a separate index in sums as shown below.

Alternate implementation using sumsIndex

// precondition: nums.length % 2 == 0
public static int[] getSums(int[] nums)
{
    int[] sums = new int[nums.length / 2];
    
    int sumsIndex = 0;
    
    for(int numsIndex = 0; numsIndex < nums.length; numsIndex += 2)
    {
        sums[sumsIndex] = nums[numsIndex] + nums[numsIndex + 1];
        sumsIndex++;
    }
    
    return sums;
}

This implementation maintains sumsIndex separately instead of calculating it based on i. i has been renamed numsIndex for readability.

Additional examples & practice

Detecting duplicates within an array known to be sorted can be accomplished by comparing each pair of adjacent elements. (A different approach is required for detecting duplicates in an array not known to be sorted.)

The CodingBat Array-2 exercises isEverywhere and either24 require accessing adjacent elements.

Help & comments

Get help from AP CS Tutor Brandon Horn

Comment on Accessing consecutive pairs