下一个排列

/*
 * The next permutation algorithm using Java Streams is generally not straightforward, but we can still use functional constructs:
 * 1. Find the largest index k such that nums[k] < nums[k + 1]. If no such index exists, the permutation is the last permutation.
 * 2. Find the largest index l greater than k such that nums[k] < nums[l].
 * 3. Swap the value of nums[k] with that of nums[l].
 * 4. Reverse the sequence from nums[k + 1] to the end.
 */
 
import java.util.stream.IntStream;
import java.util.Collections;
 
public class Solution {
    public void nextPermutation(int[] nums) {
        int k = IntStream.range(0, nums.length - 1)
                         .boxed()
                         .sorted(Collections.reverseOrder())
                         .filter(i -> nums[i] < nums[i + 1])
                         .findFirst()
                         .orElse(-1);
        if (k == -1) {
            reverse(nums, 0, nums.length - 1);
            return;
        }
        int l = IntStream.range(k + 1, nums.length)
                         .boxed()
                         .sorted(Collections.reverseOrder())
                         .filter(i -> nums[i] > nums[k])
                         .findFirst()
                         .orElse(-1);
        swap(nums, k, l);
        reverse(nums, k + 1, nums.length - 1);
    }
 
    private void swap(int[] nums, int i, int j) {
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }
 
    private void reverse(int[] nums, int i, int j) {
        while (i < j) {
            swap(nums, i, j);
            i++;
            j--;
        }
    }
}