java 39 lines · 7 steps

Quicksort with Lomuto partitioning in Java

A recursive in-place sort that partitions around a pivot and conquers each half.

Explained by highlit

Intermediate recursion divide-and-conquer in-place partitioning sorting

1public final class Quicksort {
2 
  private Quicksort() {
  }
5 
  public static void sort(int[] array) {
      if (array == null || array.length < 2) {
          return;
      }
      quicksort(array, 0, array.length - 1);
  }
12 
  private static void quicksort(int[] array, int low, int high) {
      if (low < high) {
          int pivotIndex = partition(array, low, high);
          quicksort(array, low, pivotIndex - 1);
          quicksort(array, pivotIndex + 1, high);
      }
  }
20 
  private static int partition(int[] array, int low, int high) {
      int pivot = array[high];
      int i = low - 1;
      for (int j = low; j < high; j++) {
          if (array[j] <= pivot) {
              i++;
              swap(array, i, j);
          }
      }
      swap(array, i + 1, high);
      return i + 1;
  }
33 
  private static void swap(int[] array, int a, int b) {
      int temp = array[a];
      array[a] = array[b];
      array[b] = temp;
  }
39}

01 / 01

STEP 01

Walkthrough

Space play ←→ step click any line

Three takeaways

1Quicksort sorts in place by recursively partitioning subranges around a chosen pivot.
2The Lomuto scheme keeps everything ≤ the pivot to the left, then drops the pivot into its final slot.
3Guarding the public entry point against null and tiny arrays keeps the recursive core simple.

Related explainers

java

public class ThumbnailProcessor {
 
    private static final int MAX_CONCURRENCY = 4;

Bounded parallel thumbnail rendering in Java

concurrency thread-pool futures

Intermediate 7 steps

python

from collections.abc import Mapping
from typing import Any, Iterator

Flattening nested config into dotted keys

recursion generators tree-traversal

Intermediate 7 steps

java

public class SortedListMerger {
 
    public static int[] merge(int[] a, int[] b) {
        int[] result = new int[a.length + b.length];

Merging two sorted arrays in Java

two-pointers merging arrays

Beginner 6 steps

java

import java.util.ArrayDeque;
import java.util.Deque;
 
public final class RollingAverage {

A rolling average over a sliding window

sliding-window running-sum deque

Intermediate 7 steps

ruby

require 'json'
require 'set'
 
class SensitiveScrubber

Recursively scrubbing secrets from JSON

recursion data-masking pattern-matching

Intermediate 7 steps

java

@Target({ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@Constraint(validatedBy = StrongPasswordValidator.class)
@Documented