# How the k-Means Clustering Algorithm Handles Centroid Initialization

> Discover how k-Means clustering algorithm selects initial centroids using the first k data points. Learn about effective centroid initialization in this article.

- Repository: [Oleksii Trekhleb/javascript-algorithms](https://github.com/trekhleb/javascript-algorithms)
- Tags: deep-dive
- Published: 2026-02-24

---

**The k-Means implementation initializes centroids by taking the first k data points from the input dataset and using them directly as the initial cluster centers.**

Centroid initialization determines the starting position of cluster centers before the iterative optimization process begins. In the trekhleb/javascript-algorithms repository, the k-Means clustering algorithm handles centroid initialization through a deterministic approach that prioritizes code clarity and predictable behavior. This implementation strategy differs from randomized initialization methods commonly used in production machine learning pipelines.

## First-K Centroid Initialization Strategy

The algorithm employs a straightforward "first-k" approach to establish initial centroids. Rather than randomly sampling points or using distance-based probabilistic methods, it simply extracts the initial rows from the input data matrix.

### The Initialization Logic

In [`src/algorithms/ml/k-means/kMeans.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/src/algorithms/ml/k-means/kMeans.js), the initialization occurs through a single slice operation on the input data array:

```javascript
// Assign k clusters locations equal to the location of initial k points.
const dataDim = data[0].length;
const clusterCenters = data.slice(0, k);

```

The `data.slice(0, k)` method extracts the first `k` rows from the dataset, assigning them directly to `clusterCenters`. These extracted points serve as the starting coordinates for each cluster before the algorithm enters its iterative refinement loop. This approach assumes that the input data order carries meaningful structure or that the dataset has been pre-shuffled by the caller.

### Implications of the Sequential Selection

Because the implementation uses `data.slice(0, k)`, the clustering outcome becomes dependent on the ordering of the input data. Points appearing early in the dataset automatically become initial centroids, which can lead to suboptimal clustering if the first observations represent outliers or belong to the same underlying cluster. More sophisticated initialization strategies like **k-means++** improve convergence speed and cluster quality by selecting points probabilistically based on their distance from existing centroids, but this implementation opts for deterministic simplicity.

## Iterative Refinement Process

Once centroids are initialized, the algorithm enters a convergence loop that repeatedly performs four operations until cluster assignments stabilize:

1. **Distance Calculation**: Computes Euclidean distances between every data point and each centroid using `euclideanDistance` from [`src/math/euclidean-distance/euclideanDistance.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/src/math/euclidean-distance/euclideanDistance.js)
2. **Cluster Assignment**: Assigns each point to the nearest centroid based on calculated distances
3. **Centroid Update**: Recalculates each centroid as the mean of all points currently assigned to that cluster
4. **Convergence Check**: Continues iterating until no points change their cluster assignment (the `iterate` flag remains `false`)

The distance calculations utilize a distance matrix managed through utilities in [`src/math/matrix/Matrix.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/src/math/matrix/Matrix.js), which provides the `zeros` method for matrix initialization.

## Practical Implementation Example

The following example demonstrates how to use the k-Means implementation with a two-dimensional dataset:

```javascript
import KMeans from './src/algorithms/ml/k-means/kMeans.js';

// Sample dataset: 2-dimensional points
const data = [
  [0, 0],
  [0, 1],
  [5, 5],
  [5, 6],
  [9, 9],
];

// Request 2 clusters
const clusters = KMeans(data, 2);

console.log(clusters); // → [0, 0, 1, 1, 1] (example output)

```

In this example, the algorithm initializes centroids at coordinates `[0, 0]` and `[0, 1]` (the first two points), then iteratively refines these positions until reaching the final cluster assignments.

## Summary

- **Initialization Method**: The algorithm selects the first **k data points** via `data.slice(0, k)` to serve as initial centroids
- **File Location**: Core logic resides in [`src/algorithms/ml/k-means/kMeans.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/src/algorithms/ml/k-means/kMeans.js)
- **Deterministic Behavior**: Unlike randomized approaches, this implementation produces consistent results for identical input orders
- **Dependencies**: Uses [`euclideanDistance.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/euclideanDistance.js) for distance calculations and [`Matrix.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/Matrix.js) for matrix operations
- **Convergence Criteria**: Iterates until cluster assignments no longer change between iterations

## Frequently Asked Questions

### How are centroids initialized in this k-Means implementation?

Centroids are initialized by extracting the first k data points from the input array using `data.slice(0, k)` in [`src/algorithms/ml/k-means/kMeans.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/src/algorithms/ml/k-means/kMeans.js). These points become the starting coordinates for the k clusters before iterative refinement begins.

### Does this implementation support k-means++ initialization?

No, the trekhleb/javascript-algorithms implementation does not include k-means++ or other probabilistic initialization strategies. It uses a deterministic first-k approach that selects the initial rows of the dataset regardless of their spatial distribution.

### Why does the algorithm use the first k points instead of random selection?

The implementation prioritizes code simplicity and deterministic behavior. Using the first k points eliminates the need for random seed management and ensures reproducible results across runs, though this may sacrifice cluster quality compared to randomized methods when the input data order correlates with cluster structure.

### What files are involved in the k-Means clustering implementation?

The primary implementation is in [`src/algorithms/ml/k-means/kMeans.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/src/algorithms/ml/k-means/kMeans.js). Supporting files include [`src/math/euclidean-distance/euclideanDistance.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/src/math/euclidean-distance/euclideanDistance.js) for distance calculations and [`src/math/matrix/Matrix.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/src/math/matrix/Matrix.js) for matrix operations. Unit tests demonstrating expected behavior are located in [`src/algorithms/ml/k-means/__test__/kMeans.test.js`](https://github.com/trekhleb/javascript-algorithms/blob/main/src/algorithms/ml/k-means/__test__/kMeans.test.js).