Principles and application methods of php heap sorting

Principles and application methods of php heap sorting

This article mainly introduces the principles and application methods of php heap sorting. It analyzes in detail the principles and usage skills of heap sorting, and has some reference value. For more information, see

 

 

This article describes the principles and application methods of php heap sorting. Share it with you for your reference. The specific analysis is as follows:

Here, php is used as the description language to explain in detail the heap sorting principle. It is not optimized to ensure program readability. Some Concepts about heap in php are as follows:

If n is the key of the current array, the parent node of n is n> 1 or n/2 (Division ); n left subnode l = n <1 or l = n * 2, n right subnode r = (n <1) + 1 or r = l + 1

$ Arr = array (, 9 );

The original structure of the array $ arr is as follows:

1
/
8 7
//
2 3 4 6
/
5 9
Heapsort ($ arr); print_r ($ arr );

The standard small top Heap Structure generated after sorting is as follows:

1
/
2 3
//
4 5 6 7
/
8 9
Array: array (1, 2, 3, 4, 5, 6, 7, 8, 9 ):

The Code is as follows:

Function heapsort (& $ arr)
{
// Find the last element bit
$ Last = count ($ arr );
// $ Arr [0] is usually ignored in heap sorting.
Array_unshift ($ arr, 0 );
// The last non-leaf node
$ I = $ last> 1;

// Organize the heap into a large top heap, increase the maximum number to the top of the heap, switch the maximum number to the end of the heap, and ignore the maximum number (last) of the array backend in subsequent calculations ), until the heap top (last = heap top)
While (true)
{
Adjustnode ($ I, $ last, $ arr );
If ($ I> 1)
{
// Move the node pointer to traverse all non-leaf nodes
$ I --;
}
Else
{
// Critical point last = 1, which indicates that all sorting is completed.
If ($ last = 1) break;
// When I is 1, the maximum number (heap top, $ arr [1]) will be obtained for each heap arrangement, and the heap will be adjusted repeatedly at the root node.
Swap ($ arr [$ last], $ arr [1]);
// Retain the maximum number at the end of the array in order of size, and define the critical point last to avoid disrupting the elements sorted after the array During Heap sorting.
$ Last --;
}
}
// The first array element is displayed.
Array_shift ($ arr );
}

// Organize the current Tree node ($ n). Elements sorted after the critical point $ last
Function adjustnode ($ n, $ last, & $ arr)
{
$ L = $ n <1; // left child location of $ n
If (! Isset ($ arr [$ l]) | $ l> $ last) return;
$ R = $ l + 1; // The right child of $ n

// If the right child is larger than the left child, compare the right child of the parent node
If ($ r <= $ last & $ arr [$ r]> $ arr [$ l]) $ l = $ r;
// If the child node $ l is larger than the parent node $ n, it is switched to the parent node $ n.
If ($ arr [$ l]> $ arr [$ n])
{
// Exchange the value of the child node ($ l) with the value of the parent node ($ n)
Swap ($ arr [$ l], $ arr [$ n]);
// The value ($ arr [$ n]) of the parent node after the switch may be smaller than the value of the child node of the atomic node ($ l, therefore, we need to adjust the subnodes of an atomic node ($ l) and implement them recursively.
Adjustnode ($ l, $ last, $ arr );
}
}

// Exchange two values
Function swap (& $ a, & $ B)
{
$ A = $ a ^ $ B;
$ B = $ a ^ $ B;
$ A = $ a ^ $ B;
}

 

I hope this article will help you with php programming.