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 –

Tim Sort Algorithm

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

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

Tim Sort Algorithm

The first sub-array is –

Tim Sort Algorithm

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 –

Tim Sort Algorithm

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 –

Tim Sort Algorithm

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 –

Tim Sort Algorithm

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

Tim Sort Algorithm

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

Tim Sort Algorithm

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 –

Tim Sort Algorithm

So, that’s all about the article. Hope the article will be helpful and informative to you.

Next TopicLinear vs Non-Linear data structure

Tim Sort

Tim Sort Algorithm

Algorithm

Working of Tim sort Algorithm

Example of Tim sort Algorithm

Tim sort complexity

1. Time Complexity

2. Space Complexity

Implementation of Tim sort

Priority Queue using Linked list

Bitmap Indexing

You may also like