Tim Sort Algorithm

In this article, we will discuss the Tim sort Algorithm. Tim-sort is a sorting algorithm derived from insertion sort and merge sort. It was designed to perform optimally on different kind of real-world data.

Tim sort is an adaptive sorting algorithm that needs O(n log n) comparisons to sort an array of n elements. It was designed and implemented by Tim Peters in 2002 in a python programming language. It has been python's standard sorting algorithm since version 2.3. It is the fastest sorting algorithm.

The basic approach used in the Tim sort algorithm is - first sort small chunks by using the insertion sort and then merge all the big chunks using the merge function of the merge sort.

Now, let's see the algorithm of Tim sort.

Algorithm

Step 1 - Divide the array into the number of blocks known as run.
Step 2 - Consider the size of run, either 32 or 64.
Step 3 - Sort the individual elements of every run one by one using insertion sort.
Step 4 - Merge the sorted runs one by one using the merge function of merge sort.
Step 5 - Double the size of merged sub-arrays after every iteration.

Working of Tim sort Algorithm

Now, let's see the working of the Tim sort Algorithm.

In Tim sort, first the array is divided into small chunks that are known as RUN. After dividing, each individual RUN is taken, and sorted using the insertion sort technique. After that, all sorted RUNs are merged using the merge() function of the merge sort algorithm.

In Tim sort, the advantage of using the insertion sort is that insertion sort works efficiently for the array with small size.

Example of Tim sort Algorithm

Let's see the example of Tim sort algorithm. To understand the working of Tim sort algorithm, let's take an unsorted array. It will be easier to understand the Tim sort via an example.

Suppose the array elements are -

For the simple illustration, let's consider the size of RUN is 4.

Now, divide the given array into two sub-arrays that are -

The first sub-array is -

Sorted subarray	Unsorted subarray	Array
(40)	(10, 20, 42)	(40, 10, 20, 42)

First iteration

a[1] = 10

Sorted subarray	Unsorted subarray	Array
(10, 40)	(20, 42)	(10, 40, 20, 42)

Second iteration

a[2] = 20

Sorted subarray	Unsorted subarray	Array
(10, 20, 40)	(42)	(10, 20, 40, 42)

Third iteration

a[3] = 42

Sorted subarray	Unsorted subarray	Final array
(10, 20, 40, 42)	()	(10, 20, 40, 42)

The second sub-array is -

Sorted subarray	Unsorted subarray	Final array
(27)	(25, 1, 19)	(27, 25, 1, 19)

First iteration

a[1] = 25

Sorted subarray	Unsorted subarray	Final array
(25, 27)	(1, 19)	(25, 27, 1, 19)

Second iteration

a[2] = 1

Sorted subarray	Unsorted subarray	Final array
(1, 25, 27)	(19)	(1, 25, 27, 19)

Third iteration

a[3] = 19

Sorted subarray	Unsorted subarray	Final array
(1, 19, 25, 27)	()	(1, 19, 25, 27)

Now, merge both sorted subarrays to get the final array as -

Now, the array is completely sorted.

Tim sort complexity

Now, let's see the time complexity of Tim sort in the best case, average case, and worst case. We will also see the space complexity of Tim sort.

1. Time Complexity

Case	Time Complexity
Best Case	O(n)
Average Case	O(n log n)
Worst Case	O(n log n)

Best Case Complexity - It occurs when there is no sorting required, i.e. the array is already sorted. The best-case time complexity of Tim sort is O(n).
Average Case Complexity - It occurs when the array elements are in jumbled order that is not properly ascending and not properly descending. The average case time complexity of Tim sort is O(n log n).
Worst Case Complexity - It occurs when the array elements are required to be sorted in reverse order. That means suppose you have to sort the array elements in ascending order, but its elements are in descending order. The worst-case time complexity of Tim sort is O(n log n).

2. Space Complexity

Space Complexity	O(n)
Stable	YES

The space complexity of Tim sort is O(n).

Implementation of Tim sort

Now, let's see the programs of Tim sort in different programming languages.

Program: Write a program to implement Tim sort in C language.

#include<stdio.h>
const int RUN = 32;
int min(int a, int b)  
{  
    if(a<b)  
    return a;   
    else   
    return b;   
}  
/* This function sorts array from starting index to ending index which is of size atmost RUN */
void insertionSort(int a[], int beg, int end) /* function to sort an array with insertion sort */
{
	int i, j, temp;
	for (i = beg + 1; i <= end; i++) {
		temp = a[i];
		j = i - 1;

		while(j>=0 && temp <= a[j])  
        {  
            a[j+1] = a[j];   
            j = j-1;  
        }  
        a[j+1] = temp;  
	}
}
/* Function to merge the sorted runs */
void merge(int a[], int beg, int mid, int end)  
{  
    int i, j, k;
    int n1 = mid - beg + 1;  
    int n2 = end - mid;      
    int LeftArray[n1], RightArray[n2]; //temporary arrays    
    /* copy data to temp arrays */
    for (int i = 0; i < n1; i++)  
    LeftArray[i] = a[beg + i];  
    for (int j = 0; j < n2; j++)  
    RightArray[j] = a[mid + 1 + j];     
    i = 0; 
    j = 0;
    k = beg;     
    while (i < n1 && j < n2)  
    {  
        if(LeftArray[i] <= RightArray[j])  
        {  
            a[k] = LeftArray[i];  
            i++;  
        }  
        else  
        {  
            a[k] = RightArray[j];  
            j++;  
        }  
        k++;  
    }  
    while (i<n1)  
    {  
        a[k] = LeftArray[i];  
        i++;  
        k++;  
    }     
    while (j<n2)  
    {  
        a[k] = RightArray[j];  
        j++;  
        k++;  
    }  
}
/* function to implement tim sort */
void timSort(int a[], int n)
{
	
	/* Sort individual subarrays of size RUN */
	for (int i = 0; i < n; i+=RUN)
		insertionSort(a, i, min((i+RUN-1), (n-1)));	
	// Start merging from size RUN (or 32).
	for (int size = RUN; size < n; size = 2*size)
	{
		for (int beg = 0; beg < n; beg += 2*size)
		{
			/* find ending point of left sub array. The starting point of right sub array is mid + 1 */
			int mid = beg + size - 1;
			int end = min((beg + 2*size - 1),(n-1));

			/* Merge subarray a[beg...mid] and a[mid+1...end] */
			if(mid < end)
				merge(a, beg, mid, end);
		}
	}
}
/* function to print the array elements */
void printArr(int a[], int n)
{
	for (int i = 0; i < n; i++)
		printf("%d ", a[i]);
	printf("\n");
}
int main()
{
	int a[] = { 40, 12, 31, 27, 25, 8, 1, 32, 17 };
	int n = sizeof(a) / sizeof(a[0]);
    printf("Before sorting array elements are - \n");
    printArr(a, n);
    timSort(a, n);
    printf("\nAfter sorting array elements are - \n");  
    printArr(a, n);
	return 0;
}

Output

After the execution of the above code, the output will be -

Program: Write a program to implement Tim sort in C++.

#include <iostream>
using namespace std;
const int RUN = 32;
int min(int a, int b)  
{  
    if(a<b)  
    return a;   
    else   
    return b;   
}  
/* This function sorts array from starting index to ending index which is of size atmost RUN */
void insertionSort(int a[], int beg, int end) /* function to sort an array with insertion sort */
{
	int i, j, temp;
	for (i = beg + 1; i <= end; i++) {
		temp = a[i];
		j = i - 1;

		while(j>=0 && temp <= a[j])  
        {  
            a[j+1] = a[j];   
            j = j-1;  
        }  
        a[j+1] = temp;  
	}
}
/* Function to merge the sorted runs */
void merge(int a[], int beg, int mid, int end)  
{  
    int i, j, k;
    int n1 = mid - beg + 1;  
    int n2 = end - mid;     
    int LeftArray[n1], RightArray[n2]; //temporary arrays    
    /* copy data to temp arrays */
    for (int i = 0; i < n1; i++)  
    LeftArray[i] = a[beg + i];  
    for (int j = 0; j < n2; j++)  
    RightArray[j] = a[mid + 1 + j];      
    i = 0; 
    j = 0;
    k = beg;     
    while (i < n1 && j < n2)  
    {  
        if(LeftArray[i] <= RightArray[j])  
        {  
            a[k] = LeftArray[i];  
            i++;  
        }  
        else  
        {  
            a[k] = RightArray[j];  
            j++;  
        }  
        k++;  
    }  
    while (i<n1)  
    {  
        a[k] = LeftArray[i];  
        i++;  
        k++;  
    }      
    while (j<n2)  
    {  
        a[k] = RightArray[j];  
        j++;  
        k++;  
    }  
}
/* function to implement tim sort */
void timSort(int a[], int n)
{	
	/* Sort individual subarrays of size RUN */
	for (int i = 0; i < n; i+=RUN)
		insertionSort(a, i, min((i+RUN-1), (n-1)));
	
	// Start merging from size RUN (or 32).
	for (int size = RUN; size < n; size = 2*size)
	{
		for (int beg = 0; beg < n; beg += 2*size)
		{
			/* find ending point of left sub array. The starting point of right sub array is mid + 1 */
			int mid = beg + size - 1;
			int end = min((beg + 2*size - 1),(n-1));

			/* Merge subarray a[beg...mid] and a[mid+1...end] */
			if(mid < end)
				merge(a, beg, mid, end);
		}
	}
}
/* function to print the array elements */
void printArr(int a[], int n)
{
	for (int i = 0; i < n; i++)
		cout<<a[i]<<" ";
}
int main()
{
	int a[] = { 39, 11, 30, 26, 24, 7, 0, 31, 16 };
	int n = sizeof(a) / sizeof(a[0]);
    cout<<"Before sorting array elements are - \n";
    printArr(a, n);
    timSort(a, n);
    cout<<"\nAfter sorting array elements are - \n";  
    printArr(a, n);
	return 0;
}

Output

Program: Write a program to implement Tim sort in C#.

using System;
class TimSort {
const int RUN = 32;
static int min(int a, int b)  
{  
    if(a<b)  
    return a;   
    else   
    return b;   
}  
/* This function sorts array from starting index to ending index which is of size atmost RUN */
static void insertionSort(int[] a, int beg, int end) /* function to sort an array with insertion sort */
{
	int i, j, temp;
	for (i = beg + 1; i <= end; i++) 
	{
		temp = a[i];
		j = i - 1;

		while(j >= beg && temp <= a[j])  
        {  
            a[j+1] = a[j];   
            j = j-1;  
        }  
        a[j+1] = temp;  
	}
}
/* Function to merge the sorted runs */
public static void merge(int[] a, int beg, int mid, int end)  
{  
    int i, j, k;
    int n1 = mid - beg + 1;  
    int n2 = end - mid;   
  //temporary arrays  
    int[] LeftArray = new int [n1];  
    int[] RightArray = new int [n2];     
    /* copy data to temp arrays */
    for (i = 0; i < n1; i++)  
    LeftArray[i] = a[beg + i];  
    for (j = 0; j < n2; j++)  
    RightArray[j] = a[mid + 1 + j];      
    i = 0; 
    j = 0; 
    k = beg;    
    while (i < n1 && j < n2)  
    {  
        if(LeftArray[i] <= RightArray[j])  
        {  
            a[k] = LeftArray[i];  
            i++;  
        }  
        else  
        {  
            a[k] = RightArray[j];  
            j++;  
        }  
        k++;  
    }  
    while (i<n1)  
    {  
        a[k] = LeftArray[i];  
        i++;  
        k++;  
    }      
    while (j<n2)  
    {  
        a[k] = RightArray[j];  
        j++;  
        k++;  
    }  
}  
/* function to implement tim sort */
public static void timSort(int[] a, int n)
{	
	/* Sort individual subarrays of size RUN */
	for (int i = 0; i < n; i+=RUN)
		insertionSort(a, i, min((i+RUN-1), (n-1)));	
	// Start merging from size RUN (or 32).
	for (int size = RUN; size < n; size = 2*size)
	{
		for (int beg = 0; beg < n; beg += 2*size)
		{
			/* find ending point of left sub array. The starting point of right sub array is mid + 1 */
			int mid = beg + size - 1;
			int end = min((beg + 2*size - 1),(n-1));

			/* Merge subarray a[beg...mid] and a[mid+1...end] */
			if(mid < end)
				merge(a, beg, mid, end);
		}
	}
}
/* function to print the array elements */
static void printArr(int[] a, int n)
{
	for (int i = 0; i < n; i++)
		Console.Write(a[i] + " ");
}
static void Main() 
{
    int[] a = { 39, 11, 30, 26, 24, 7, 0, 31, 16 };
	int n = a.Length;
	Console.Write("Before sorting array elements are - ");
	printArr(a, n);
	timSort(a, n);
	Console.Write("\nAfter sorting array elements are - ");
	printArr(a, n);
}
}

Output

Program: Write a program to implement Tim sort in Java.

class TimSort {
static int RUN = 32;
int min(int a, int b)  
{  
    if(a<b)  
    return a;   
    else   
    return b;   
}  
/* This function sorts array from starting index to ending index which is of 
size atmost RUN */
void insertionSort(int a[], int beg, int end) /* function to sort an array with 
insertion sort */
{
	int i, j, temp;
	for (i = beg + 1; i <= end; i++) 
	{
		temp = a[i];
		j = i - 1;

		while(j >= beg && temp <= a[j])  
        {  
            a[j+1] = a[j];   
            j = j-1;  
        }  
        a[j+1] = temp;  
	}
}
/* Function to merge the sorted runs */
void merge(int a[], int beg, int mid, int end)  
{  
    int i, j, k;
    int n1 = mid - beg + 1;  
    int n2 = end - mid;   
  //temporary arrays  
    int[] LeftArray = new int [n1];  
    int[] RightArray = new int [n2];     
    /* copy data to temp arrays */
    for (i = 0; i < n1; i++)  
    LeftArray[i] = a[beg + i];  
    for (j = 0; j < n2; j++)  
    RightArray[j] = a[mid + 1 + j];      
    i = 0; 
    j = 0; 
    k = beg;    
    while (i < n1 && j < n2)  
    {  
        if(LeftArray[i] <= RightArray[j])  
        {  
            a[k] = LeftArray[i];  
            i++;  
        }  
        else  
        {  
            a[k] = RightArray[j];  
            j++;  
        }  
        k++;  
    }  
    while (i<n1)  
    {  
        a[k] = LeftArray[i];  
        i++;  
        k++;  
    }      
    while (j<n2)  
    {  
        a[k] = RightArray[j];  
        j++;  
        k++;  
    }  
}  
/* function to implement tim sort */
void timSort(int a[], int n)
{	
	/* Sort individual subarrays of size RUN */
	for (int i = 0; i < n; i+=RUN)
		insertionSort(a, i, min((i+RUN-1), (n-1)));	
	// Start merging from size RUN (or 32).
	for (int size = RUN; size < n; size = 2*size)
	{
		for (int beg = 0; beg < n; beg += 2*size)
		{
			/* find ending point of left subarray. The 
starting point of right sub array is mid + 1 */
			int mid = beg + size - 1;
			int end = min((beg + 2*size - 1),(n-1));

			/* Merge subarray a[beg...mid] and a[mid
+1...end] */
			if(mid < end)
				merge(a, beg, mid, end);
		}
	}
}
/* function to print the array elements */
void printArr(int[] a, int n)
{
	for (int i = 0; i < n; i++)
		System.out.print(a[i] + " ");
}
public static void main(String args[]) 
{
    int a[] = { 38, 10, 29, 25, 23, 6, 2, 30, 15 };
	int n = a.length;
TimSort t1 = new TimSort();
	System.out.print("\nBefore sorting array elements are - ");
	t1.printArr(a, n);
	t1.timSort(a, n);
	System.out.print("\nAfter sorting array elements are - ");
	t1.printArr(a, n);
System.out.println();
}
}

Output

After the execution of above code, the output will be -