Golang slices.IsSorted Function

The slices.IsSorted function in Golang is part of the slices package, introduced in Go 1.21 as part of the standard library. This function allows you to determine whether a slice is sorted in ascending order. It is particularly useful when you need to verify that data is ordered correctly before performing operations that depend on sorted input.

Table of Contents

1. Introduction
2. slices.IsSorted Function Syntax
3. Examples
   • Basic Usage
   • Checking a Slice of Strings
   • Handling Empty and Single-Element Slices
4. Real-World Use Case Example
5. Conclusion

Introduction

The slices.IsSorted function provides a simple way to check if a slice is sorted in ascending order. This is especially useful in scenarios where the correctness of algorithms or operations depends on the data being sorted. By confirming that a slice is sorted, you can avoid errors and ensure that your code behaves as expected.

slices.IsSorted Function Syntax

The syntax for the slices.IsSorted function is as follows:

func IsSorted[S ~[]E, E cmp.Ordered](x S) bool

Parameters:

• x S: The slice to check for sorted order.

Returns:

• bool: true if the slice is sorted in ascending order, false otherwise.

Behavior:

• Sorted order check: The function iterates through the slice to verify that each element is less than or equal to the following element. If any element is greater than the next, the function returns false.

Examples

Basic Usage

This example demonstrates how to use slices.IsSorted to check if a slice of integers is sorted in ascending order.

Example

package main

import (
	"fmt"
	"slices"
)

func main() {
	// Define a slice of integers
	numbers := []int{1, 2, 3, 4, 5}

	// Check if the slice is sorted
	isSorted := slices.IsSorted(numbers)

	// Print the result
	fmt.Println("Is the slice sorted?", isSorted)
}

Output:

Is the slice sorted? true

Explanation:

• The slices.IsSorted function checks the numbers slice and confirms that it is sorted in ascending order, returning true.

Checking a Slice of Strings

This example shows how to use slices.IsSorted to check if a slice of strings is sorted alphabetically.

Example

package main

import (
	"fmt"
	"slices"
)

func main() {
	// Define a slice of strings
	words := []string{"apple", "banana", "cherry", "date"}

	// Check if the slice is sorted
	isSorted := slices.IsSorted(words)

	// Print the result
	fmt.Println("Is the slice sorted?", isSorted)
}

Output:

Is the slice sorted? true

Explanation:

• The slices.IsSorted function confirms that the words slice is sorted alphabetically, returning true.

Handling Empty and Single-Element Slices

This example demonstrates how slices.IsSorted handles edge cases such as empty slices and slices with a single element.

Example

package main

import (
	"fmt"
	"slices"
)

func main() {
	// Define an empty slice and a single-element slice
	emptySlice := []int{}
	singleElementSlice := []int{42}

	// Check if the slices are sorted
	isEmptySorted := slices.IsSorted(emptySlice)
	isSingleElementSorted := slices.IsSorted(singleElementSlice)

	// Print the results
	fmt.Println("Is the empty slice sorted?", isEmptySorted)
	fmt.Println("Is the single-element slice sorted?", isSingleElementSorted)
}

Output:

Is the empty slice sorted? true
Is the single-element slice sorted? true

Explanation:

• The slices.IsSorted function returns true for both the empty slice and the single-element slice, as these are trivially sorted.

Real-World Use Case Example: Verifying Sorted Data Before Binary Search

A practical use case for slices.IsSorted is verifying that data is sorted before performing a binary search, ensuring that the search operation will work correctly.

Example: Checking Sorted Order Before Binary Search

package main

import (
	"fmt"
	"slices"
)

func main() {
	// Define a slice of integers
	numbers := []int{10, 20, 30, 40, 50}

	// Check if the slice is sorted before performing a binary search
	if slices.IsSorted(numbers) {
		fmt.Println("The slice is sorted, safe to perform binary search.")
	} else {
		fmt.Println("The slice is not sorted, cannot perform binary search.")
	}
}

Output:

The slice is sorted, safe to perform binary search.

Explanation:

• The slices.IsSorted function checks that the numbers slice is sorted, confirming that it is safe to proceed with a binary search.

Conclusion

The slices.IsSorted function in Go is used for ensuring that a slice is sorted in ascending order. It simplifies the process of validating data before performing operations that depend on sorted input, helping you avoid errors and ensuring that your code runs smoothly. Whether you are working with numeric data, strings, or complex types, slices.IsSorted provides a reliable way to verify sorted order in your Go applications.