CHUANGXINBAN JOURNAL OF COMPUTING, MAR 2018 1

An efficient sorting algorithm — Ultimate

Heapsort(UHS)
Feiyang Chen, Nan Chen, Hanyang Mao, Hanlin Hu

Abstract—Motivated by the development of computer theory, sorting algorithm is emerging in an endless stream. Inspired by decrease
and conquer method, we propose a brand new sorting algorithmUltimately Heapsort. The algorithm consists of two parts: building a
heap and adjusting a heap. Through the asymptotic analysis and experimental analysis of the algorithm, the time complexity of our
algorithm can reach O(nlogn) under any condition.Moreover, its space complexity is only O(1). It can be seen that our algorithm is
superior to all previous algorithms.

Index Terms—Sort algorithm, Min-heap, Max-heap, Asymptotic analysis, Experimental analysis

arXiv:1902.00257v1 [cs.DS] 1 Feb 2019

1 I NTRODUCTION
2.3 Design of the UHS
S ORTING algorithm is one of the most important re-
search areas in computer science. It has a wide range
of applications in computer graphics, computer-aided de-
2.3.1 MAX-HEAPLFY
In order to maintain the max-heap property, we call the
sign, robotics, pattern recognition, and statistics. At present,
procedure MAX-HEAPIFY. Its inputs are an array A and an
quicksort is generally considered as the best choice in
index i into the array. When it is called, MAX- HEAPIFY
practical sorting applications. However, when we need to
assumes that the binary trees rooted at LEF T (i) and
dynamically add and delete data during the sorting, we
RIGHT (i) are max- heaps, but that A[i] might be smaller
find that the quicksort can’t exert its performance. There-
than its children, thus violating the max-heap property.
fore, we design an efficient sorting algorithm—the ultimate
MAX-HEAPIFY lets the value at A[i] ”float down” in the
heapsort(UHS), which offers us a better solution to this type
max-heap so that the subtree rooted at index i obeys the
of problem.
max-heap property.

2 U LTIMATE H EAPSORT (UHS)

2.1 Preliminary
We use heap data structure to implement our ultimate
heapsort algorithm. The heap is a complete binary tree, and
it is divided into a max-heap and a min-heap. The max-heap
requires that the value of the parent node is greater than or
equal to the value of the child node, and the min-heap is the
opposite. According to the characteristic of the max-heap,
we can know that the maximum value must be at the top
of the heap, that is, the root node. With this, we can build
an array into a max-heap. Here we take the max-heap as an
example. The min-heap is similar. For our UHS algorithm,
At each step of MAX-HEAPLFY, the largest of the ele-
we use max-heaps.
ments A[i], A[LEF T (i)], and A[RIGHT (i)] is determined,
and its index is stored in largest. IfA[i]is largest, then the
subtree rooted at node i is already a max-heap and the pro-
2.2 Main idea
cedure terminates. Otherwise, one of the two children has
Here we will describe our UHS algorithm’s main idea in the largest element, and A[i] is swapped with A[largest],
detail. Firstly, we build the array as a max-heap, which is which causes node i and its children to satisfy the max-
the initial heap. At this point we know that the top element heap property. The node indexed by largest, however, now
of the heap is the maximum, that is, the first element of the has the original value A[i], and thus the subtree rooted at
array is the maximum value. Secondly, we swap the first largest might violate the max-heap property. Consequently,
element of the array with the last one, then the last one will we call MAX-HEAPIFY recursively on that subtree.
be the maximum value, and then we update the heap with
the last element removed, ensuring that the first one is at 2.3.2 Building a heap
its maximum in the new heap. Finally, we repeat the above We can use the procedure MAX-HEAPIFY in a bottom-up
operation until only one element left. manner to convert an array A[1..n], where n = A.length,
CHUANGXINBAN JOURNAL OF COMPUTING, MAR 2018 2
 
into a max-heap. The elements in the subarray A(( n
+ Since the running time of resuming the heap is O(logN )
2
each time, a total of N − 1 times to restore the heap
1)..n) are all leaves of the tree, and so each is a 1-element operation, plus the N/2 times downward adjustment when
heap to begin with. The procedure BUILD-MAX-HEAP goes the previous stack was built, the running time of each ad-
through the remaining nodes of the tree and runs MAX- justment time is also O(logN ). The sum of the two operation
HEAPIFY on each one. times is also O(N ∗ logN ). Therefore, the time complexity of
heap sorting is O(N ∗ logN )

TABLE 1
Running time analyze of 7 algorithms

Worst-case Average-case/expected
Algorithm running time running time
Insertion sort Θ(n2 ) Θ(n2 )
Merge sort Θ(nlogn) Θ(nlogn)
2.3.3 Implementation Quicksort Θ(n2 ) Θ(nlogn) (expected)
The heapsort algorithm starts by using BUILD-MAX-HEAP Bucket sort Θ(n2 ) Θ(n) (average-case)
Radix sort Θ(d(n + k)) Θ(d(n + k))
to build a max-heap on the input array A[1..n], where
Bubble sort Θ(n2 ) Θ(n2 )
n = A.length. Since the maximum element of the array Heapsort Θ(nlogn) Θ(nlogn)
is stored at the root A[1], we can put it into its correct final
position by exchanging it with A[n] . If we now discard node For the commonly used seven sorting algorithms, we
n from the heap-and we can do so by simply decrementing have analyzed and compared the running time, including
A.heap-size-we observe that the children of the root remain the worst-running time and expected running time . The
max-heaps, but the new root element might violate the comparison results are shown in the table 1.
max-heap property. All we need to do to restore the max-
heap property, however, is call MAX-HEAPIFY(A,1), which
3.2 Space complexity analysis
leaves a max-heap in A[1..n]. The heapsort algorithm then
repeats this process for the max-heap of size n − 1 down to At the same time, we have also analyzed the space complex-
a heap of size 2. ity of these seven sorting methods.

TABLE 2
Space complexity analysis of 7 algorithms

Algorithm Space complexty

Insertion sort O(1)
Merge sort O(n)
Quicksort O(nlogn)
Bucket sort O(n)
Radix sort O(n + k)
Bubble sort O(1)
Heapsort O(1)

3 A NALYSIS Table 2 shows the space complexity for each methods.

Heap sort is in-sequence sorting algorithms, which means
3.1 Running time analysis
only a constant additional memory space is required in
We have used mathematical methods to analyze the running addition to the input array. Thus, UHS? performance was
time of UHS. one of the best among all algorithms. The results suggested
The maximum number of nodes in each layer during that UHS can increase the sorting speed without taking up
the build process is n1 = ceil(n/(2h+1 )), where n and h more space.
represent the number of nodes and the number of layers in
the heap, respectively.
3.3 Stability analysis
∞
X 1 The structure of the heap is that the children of node i are
= (1)
x−1 nodes 2∗i and 2∗i+1 . The max heap requires that the parent
h=0
node is greater than or equal to its 2 child nodes, and the
∞
X 1 min heap requires that the parent node is less than or equal
h ∗ xh−1 ∗ x2 = ∗ x2 (2) to its 2 child nodes. In a sequence of length n, the process of
(1 − x)2
h=0
heap sorting is to choose the largest (max heap) or smallest
∞ (min heap) values from the first n/2 and the total of 3 values
X h
=1 (3) of its sub-nodes. The choice between these 3 elements won?t
2h+1
h=0 affect the stability. However, when elements are selected for
logn h=0 the parent nodes n/2 − 1, n/2 − 2, ...1, stability is destroyed.
X X h It is possible that the n/2th parent node exchange swaps
n1 ∗ O(h) = O(n ∗ ) = O(n) (4)
2h+1 the next one, and the n/2 − 1th parent does not swap the
h=0 logn
CHUANGXINBAN JOURNAL OF COMPUTING, MAR 2018 3

same subsequent element. Then the stability between these

2 same elements is destroyed. Therefore, heap sorting is not
a stable sorting algorithm.

TABLE 3
Stability analysis of 7 algorithms

Algorithm Stability
Insertion sort YES
Merge sort YES
Quicksort NO
Bucket sort YES
Radix sort YES
Bubble sort YES
Heapsort NO

3.4 Contrast
According to the previous three parts, we can conclude that
the advantage of heap sorting over other algorithms is that
it can still maintain the running time of O(nlogn) in the
worst case. Compared to the quick-sorting algorithm that is
efficient at the same time, it is an in-sequence sort and does
not require an auxiliary array. And, because of the heap data
structure, heap sorting is more convenient for dynamically
adding and deleting from sorted arrays.

4 R ESULTS
We have proposed a new method for sorting algorithm,
and named it ultimate heap sorting (UHS). Ultimate heap
sorting is a comparison-basedsorting algorithm. Its best,
worst, and average running time are O(n ∗ logn). Heapsort
is anin-place algorithm, but it is not astable sort.
It divides its input into a sorted and an unsorted region,
and it iteratively shrinks the unsorted region by extracting
the largest element and moving that to the sorted region.
The improvement consists of the use of a heap data structure
rather than a linear-time search to find the maximum.
At the same time, according to experimental results,
when the ultimate heap sorting algorithm is facing the
situation that it needs to dynamically add data, its worst-
case running time and average running time are improved
compared with other sorting algorithms.

R EFERENCES
[1] Thomas H.Cormen and Charles,”Introduction to Algorithms”, Mas-
sachusetts Institute of Technology