MIT International Journal of Computer Science and Information Technology, Vol. 5, No. 2, August 2015, pp.

66-70 66
ISSN 2230-7621©MIT Publications

To Solving Hybrid Appoarch by using Tim

Sort Algorithm and Comparision with Quick
Sort Algorithm

Kanchan Shipi Rani

Department of CSE Department of CSE
MIT, Moradabad, U.P., India MIT, Moradabad, U.P., India
kanchansinghcs@gmail.com sh.2507.cse@gmail.com

ABSTRACT
A hybrid algorithm that combines two or more other algorithms that solve the same problem. Hybrid algorithm simply done
by combine desired characteristic of each algorithm, so that the all-inclusive algorithm is better than the single components.
Hybrid algorithm does not refer to simply combining multiple algorithms to solve a different problem but only to combining
algorithms that solve the same problem. A goal of this paper to solve hybrid approach by using Tim sort algorithm and
comparison with quick sort algorithm.
Keywords: Hybrid algorithm, Tim sort algorithm, quick sort algorithm, insertion sort algorithm.

I. Introduction
Tim sort algorithm is a highly optimized hybrid sorting algorithm,
which derived from merge sort and insertion sort, which
combines in the merging logic. Timsort algorithm is an effective
method expressed as a finite list of well-defined instructions
for calculating a function [1]. Starting from an initial state and
initial input the instructions describe a computation that when
executed proceeds through a finite number of well-defined
successive states, eventually producing output and terminating
at a final ending state. Tim sort is a hybrid sorting algorithm that
designed to solve many kinds of real-world data. This algorithm
finds subsets of the data that are already organized, and to sort
the data more reliable. This is done by merging or recognizes
subset, until conclusive criteria are satisfied.
II. How Tim sort algorithm works
A. Timsort Algorithm
Tim sort is an adaptive, stable, in-place sorting algorithm [1].
The steps are following:
(i) It takes existing structure in a list, allowing it to perform
n-1 comparisons on a list which is already in order or in
strictly-descending (reverse) order.
(ii) Tim Sort walks the list, finding “runs” of elements already
in ascending order or in strictly descending order.
(iii) If the run is in strictly descending order, Tim Sort reverses
it in place (the run must be strictly descending, otherwise
this operation would not maintain Tim Sort’s stability).
Then, if the run is less than a chosen “minrun” size.
(iv) Tim Sort uses Insertion Sort to bulk it up to minrun
elements. The value of minrun is calculated such that,
where n is the size of an array.
(v) Tim Sort always tries to merge runs as soon as it is optimal
to do so, also attempts to keep the merges balanced. it
records each run created on a stack.
B. Data Flow Diagram of Timsort Algorithm
Timsort operates by finding runs, subsets of at least two elements,
in the data. Runs are either non-descending (each element is
equal to or greater than its predecessor) or strictly descending
(each element is lower than its predecessor) Fig. 1. Tim sort has
been Python’s standard sorting algorithm. After obtaining such
a run in the given array, Timsort processes it, and then searches
for the next run.
MIT International Journal of Computer Science and Information Technology, Vol. 5, No. 2, August 2015, pp. 66-70 67
ISSN 2230-7621©MIT Publications
Fig. 1: Dab Flow Diagram of Timsort
III. Implemention of Tim sort algorithm
A. Run
A natural run is a sub-array that is already ordered. Natural runs
in real-world data may be of varied lengths [4]. Timsort chooses
a sorting technique depending on the length of run Fig. 2. For
example, if the run length is smaller than a certain value, insertion
sort is used. Thus Timsort is an adaptive sort.
Fig. 2: Calculating Runs
B. Minrun
The minimum run size (minrun) depends on the size of the array.
minrun is chosen from the range 32 to 64 inclusive, such that
the size of the array, divided by min run, is equal to, or slightly
smaller than, a power of two. This algorithm works for all arrays,
including those smaller than 64.
C. Applying Insertion sort
When an array is random, natural runs most likely contain fewer
than min run elements [3]. In this case, an appropriate number of
succeeding elements is selected, and an insertion sort increases
the size of the run to minrun size. Thus, most runs in a random
array are, or become, minrun in length. This results in efficient,
balanced merges. It also results in a reasonable number of
function calls in the implementation of the sort.
D. Merge Memory
Timsort does not merge non-consecutive runs, because doing this
would cause the element common to all three runs to become
out of order with respect to the middle run [2]. Thus, merging
is always done on consecutive runs Fig. 3. If X, Y, Z represents
the lengths of the three uppermost runs in the stack and two
rules are satisfied:
1. X > Y + Z
2. Y > Z
If the first of the two rules is not satisfied by the current run
status, that is, if X < Y + Z, then, Y is merged with the smaller
of X and Z. The merging continues until both rules are satisfied.
Fig. 3: Rules for merging the memory
E. Merging Prodecure
Merging adjacent runs is done with the help of temporary
memory. The temporary memory is of the size of the lesser of
the two runs. The algorithm copies the smaller of the two runs
into this temporary memory and then uses the original memory
[3]. A simple merge algorithm runs left to right or right to left
depending on which run is smaller, on the temporary memory
and original memory of the larger run. The final sorted run is
stored in the original memory of the two initial runs. Timsort
searches for appropriate positions.
MIT International Journal of Computer Science and Information Technology, Vol. 5, No. 2, August 2015, pp. 66-70 68
ISSN 2230-7621©MIT Publications

B. Comparing with Quick Sort

1. Timsort algorithm’s unbelievably fast for nearly sorted
data sequence (including reverse sorted data).
2. The worst case for timsort is O (n log n) while for quick
sort, worst case is O (n^2).

V. Experimental Results

A. To Perform Sorting Choice

Fig. 4: Merging Procedure (a)

For example, (Fig. 4 & Fig. 5) if two runs A and B are to be merged,
with A as the smaller run. In this case a binary search examines A to
find the first position larger than the first element of B (a’). When
a’ is found, the algorithm can ignore elements before that position
while inserting B. Similarly, the algorithm also looks for the smallest
element in B (b’) greater than the largest element in A (a”). The
elements after b’ can also be ignored for the merging.

B. Finding Minrun for Array100(Array_Size>64)

Fig. 5 Merging Procedure (b)

IV. Comparison of Tim sort with Quick

sort C. Applying Insertion Sort to Merge Runs to the Size
of Minrun
A. Introduction of Quick Sort
Quick Sort is a divide and conquer algorithm which relies on a
partition operation, if partition an array an element called a pivot
is selected. All elements smaller than the pivots are moved before
it and all greater elements are moved after it [5]. This can be
done efficiently in linear time and in-place. The lesser and greater
sub-lists are then recursively sorted. Efficient implementations
of quick sort (with in-place partitioning) are typically unstable
sorts and somewhat complex, but are among the fastest sorting
algorithms in practice. The most complex issue in quick sort
is choosing a good pivot element consistently poor choices of
pivots can result in drastically slower O (n²) performance, if at
each step the median is chosen as the pivot then the algorithm
works in O (n log n).
MIT International Journal of Computer Science and Information Technology, Vol. 5, No. 2, August 2015, pp. 66-70 69
ISSN 2230-7621©MIT Publications

E. Sorting Array of Size 1200 Using Timsort

F. Quick Sort for Sorting Array of Size 1200

D. Final Runs After Merging the Memory

G. Comparision Processing Time of Timsort and Quicksort

Algorithm
MIT International Journal of Computer Science and Information Technology, Vol. 5, No. 2, August 2015, pp. 66-70 70
ISSN 2230-7621©MIT Publications
VI. Conclusion
Tim sort is a hybrid sorting algorithm combining the advantages
of merge sort and insertion sort. Merge sort is asymptotically
optimal on large data, but the overhead becomes significant if
applying them to small data. Insertion sort is optimal for small
data. If divide and conquer algorithm is used, it would be better
to use insertion sort for sorting smaller to get better performance.
So it is a good strategy to mix insertion sort with merge sort to
devise a good hybrid sorting algorithm like Tim sort, on real
world data, Tim sort often requires far fewer than Θ (n log n)
comparison, because it takes advantage of the fact that subs lists
of data that may already be ordered.
REFERENCES
[1] http://bugs.python.org/file4451/timsort.txt
[2] http://en.wikipedia.org/wiki/Timsort
[3] http://stromberg.dnsalias.org/~strombrg/sort-comparison/
[4] G. Jost, H. Jin, D. Mey, F. Hatay. Comparing the OpenMP, MPI, and
hybrid programming paradigms on an SMP cluster. NAS Technical
Report NAS-03-019, November 2003.
[5] T.H. Cormen, C.E. Leiserson, R.L. Rivest, and C. Stein,
“Introduction to Algorithms”. MIT Press, Cambridge, MA, 2nd
Edition, 2001.