Heap Sort

Heap Sort is an improvement to direct selection sort.From previous discussion,it can be seen that Using direct selection sort,in order to find out the smallest keyword among n keywords,n-1 comparisons are needed.Then n-2 comparisons are needed for finding out the minor keyword among the rest n-1 keywords.

In fact,in the n-2 comparisons to find out the minor keyword,there are many comparisons that may have been done in the previous n-1 comparisons.It just didn’t preserve the these results at that time.Therefore,these comparisons are repeated in the last sort.Tree sorting can overcome this.Heap sort is a tree type selection sort.Its basic idea is:

In the sorting process,the record array R[1…n] is regarded as a sequential storage structure of a complete binary tree.Using the internal relationship between parents and children in a complete binary tree,in the current unordered area,select the keyword maximum (or minimum) record.

Heap is defined as follows:

The keyword sequence k1,k2,…,kn of n records are called heap.

If and only if K_i ≤ K_2i and K_i ≤ K_2i+1 or K_i ≥ K_2i and K_i ≥ K_2i+1 .The former is called small root heap,the latter is called big root heap.For example,the keyword sequence (15,27,44,76,38,59) is a small root heap.You can adjust it to a big root heap(76,38,59,27,15,44).

Their corresponding complete binary trees are shown in the following figure:

Heap sorting uses the big root heap(or the smallest root heap) to select the record with the biggest(or smallest) keyword in the current unordered area to achieve sorting.

The operation of each sorting is as follows:
Adjust the current unordered area to a big root heap,and select the heap top record with the biggest keyword,exchange it with the last record in the unordered area.It is just contrary to selection sort.Heap sort is a process of constantly establishing heap.

Therefore,the key of heap sort is how to build a heap.Its specific practice is as follows:

• Store the keywords of file of waiting for sorting into array R[1…n].R is regarded as a storage structure of a complete binary tree.Each node stands for a record.The first record R[1] of source file serves as the root of binary tree.The following records R[2…n] successively layer by layer from left to right order arrange to build a complete binary tree.The left child of any node R[i] is R[2i], the right child is R[2i+1],parent is R[i/2]
• Suppose to build the big root heap:if the left subtree ,right subtree of some node i of a complete binary tree are already a heap,it just need to compare the big one of R[2i].key and R[2i+1].key with the R[i].key .If R[i].key is smaller,then exchange.But it could damage the heap of the next level.So continuously adopt the method above to build the heap of the next level.Until the subtree rooted with node i in the complete binary tree becomes a heap.
• The process is like a sieve.The smaller keywords are filtered down layer by layer.The bigger keywords are selected layer by layer.So this method of building a heap is called screening.

Algorithm of adjusting to a big root heap:

      
      

       
       void 
       
       Sift(
       
       SeqList 
       
       R,
       
       int 
       
       i,
       
       int 
       
       h){
       
       
  
       
       // adjust R[i..h] to a big root heap
       
       
  
       
       int 
       
       j;
       
       
  
       
       RecType 
       
       x 
       
       = 
       
       R[
       
       i];
       
       // store the filter node i in x
       
       
  
       
       j
       
       =
       
       2
       
       *
       
       i;
       
       // R[j] is the left child of R[i]
       
       
  
       
       while(
       
       i
       
       <=
       
       h){
       
       
    
       
       if(
       
       j
       
       <
       
       h 
       
       && 
       
       R[
       
       j].
       
       key 
       
       < 
       
       R[
       
       j
       
       +
       
       1].
       
       key)
       
       
      
       
       j
       
       ++;
       
       
    
       
       if(
       
       x.
       
       key 
       
       >= 
       
       R[
       
       j].
       
       key)
       
       
      
       
       break;
       
       // find out the final position of x
       
       
    
       
       R[
       
       i]
       
       =
       
       R[
       
       j];
       
       
    
       
       i
       
       =
       
       j;
       
       j
       
       =
       
       2
       
       *
       
       i;
       
       
  }
       
       
  
       
       R[
       
       i]
       
       =
       
       x;
       
       
}
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
       
       
6.
       
       
7.
       
       
8.
       
       
9.
       
       
10.
       
       
11.
       
       
12.
       
       
13.
       
       
14.
       
       
15.
      
      

According the definition of heap and the building process above,we can know that the order number 1 node R[1](namely heap top) is the keyword biggest node among the n nodes in heap.Therefore,the process of heap sort is relatively simple.First exchange R[1] with R[n],make R[n] the node with the biggest keyword.Then,the nodes in R[1…n-1] are filtered.We gain R[1] as the biggest keyword node in the current unordered area.Then R[1] is exchanged with the last node R[n-1] in the current unordered area.Make R[n-1] the biggest keyword node.And so on,after n-1 exchange and screening,all nodes become incremental order,that is to say,the sorting ends.Therefore,heap sort algorithm is as follows:

      
      

       
       void 
       
       HeapSort(
       
       SeqList 
       
       R,
       
       int 
       
       n){
       
       
  
       
       int 
       
       i;
       
       
  
       
       for(
       
       i
       
       =
       
       n
       
       /
       
       2;
       
       i
       
       >
       
       0;
       
       i
       
       --)
       
       
    
       
       Sift(
       
       R,
       
       i,
       
       n);
       
       // build a big root heap for the initial array R[1..n]
       
       
  
       
       for(
       
       i
       
       =
       
       n;
       
       i
       
       >
       
       1;
       
       i
       
       --){
       
       // Heap sort R [1.. I], n-1 times in total
       
       
    
       
       R[
       
       0]
       
       =
       
       R[
       
       1];
       
       R[
       
       1]
       
       =
       
       R[
       
       i];
       
       R[
       
       i]
       
       =
       
       R[
       
       0];
       
       
    
       
       Sift(
       
       R,
       
       1,
       
       i
       
       -
       
       1);
       
       // build a big root heap for the unordered area R[1..i-1]
       
       
  }
       
       
}
      
      
      
      

       
       
1.
       
       
2.
       
       
3.
       
       
4.
       
       
5.
       
       
6.
       
       
7.
       
       
8.
       
       
9.