PowerShell/Docs/measure-HeapSort.md

*measure-HeapSort.ps1*
================

This PowerShell script measures the speed of the HeapSort algorithm.
HeapSort is a comparison-based sorting algorithm. Heapsort can be thought of as an
improved selection sort: like selection sort, heapsort divides its input into a sorted
and an unsorted region, and it iteratively shrinks the unsorted region by extracting
the largest element from it and inserting it into the sorted region. Unlike selection
sort, heapsort does not waste time with a linear-time scan of the unsorted region;
rather, heap sort maintains the unsorted region in a heap data structure to more quickly
find the largest element in each step.

Parameters
----------
```powershell
PS> ./measure-HeapSort.ps1 [[-numIntegers] <Int32>] [<CommonParameters>]

-numIntegers <Int32>
    Specifies the number of integers to sort
    
    Required?                    false
    Position?                    1
    Default value                1000
    Accept pipeline input?       false
    Accept wildcard characters?  false

[<CommonParameters>]
    This script supports the common parameters: Verbose, Debug, ErrorAction, ErrorVariable, WarningAction, 
    WarningVariable, OutBuffer, PipelineVariable, and OutVariable.
```

Example
-------
```powershell
PS> ./measure-HeapSort.ps1
🧭 Sorting 1000 integers by HeapSort took 0.6145732 sec

```

Notes
-----
Author: Markus Fleschutz | License: CC0

Related Links
-------------
https://github.com/fleschutz/PowerShell

Script Content
--------------
```powershell
<#
.SYNOPSIS
        Measures the speed of HeapSort
.DESCRIPTION
        This PowerShell script measures the speed of the HeapSort algorithm.
        HeapSort is a comparison-based sorting algorithm. Heapsort can be thought of as an
	improved selection sort: like selection sort, heapsort divides its input into a sorted
	and an unsorted region, and it iteratively shrinks the unsorted region by extracting
	the largest element from it and inserting it into the sorted region. Unlike selection
	sort, heapsort does not waste time with a linear-time scan of the unsorted region;
	rather, heap sort maintains the unsorted region in a heap data structure to more quickly
	find the largest element in each step.
.PARAMETER numIntegers
        Specifies the number of integers to sort
.EXAMPLE
        PS> ./measure-HeapSort.ps1
        🧭 Sorting 1000 integers by HeapSort took 0.6145732 sec
.LINK
        https://github.com/fleschutz/PowerShell
.NOTES
        Author: Markus Fleschutz | License: CC0
#>

param([int]$numIntegers = 1000)

class HeapSort {
    static Sort($targetList) {
        $heapSize = $targetList.Count

        for ([int]$p = ($heapSize - 1) / 2; $p -ge 0; $p--) {
            [HeapSort]::MaxHeapify($targetList, $heapSize, $p)
        }

        for ($i = $targetList.Count - 1; $i -gt 0; $i--) {
            $temp = $targetList[$i]
            $targetList[$i] = $targetList[0]
            $targetList[0] = $temp

            $heapSize--
            [HeapSort]::MaxHeapify($targetList, $heapSize, 0)
        }
    }

    static MaxHeapify($targetList, $heapSize, $index) {
        $left = ($index + 1) * 2 - 1
        $right = ($index + 1) * 2
        $largest = 0

        if ($left -lt $heapSize -and $targetList[$left] -gt $targetList[$index]) {
            $largest = $left
        }
        else {
            $largest = $index
        }

        if ($right -lt $heapSize -and $targetList[$right] -gt $targetList[$largest]) {
            $largest = $right
        }

        if ($largest -ne $index) {
            $temp = $targetList[$index]
            $targetList[$index] = $targetList[$largest]
            $targetList[$largest] = $temp

            [HeapSort]::MaxHeapify($targetList, $heapSize, $largest)
        }
    }
}

$list = (1..$numIntegers | foreach{Get-Random -minimum 1 -maximum $numIntegers})
$stopWatch = [system.diagnostics.stopwatch]::startNew()
[HeapSort]::Sort($list)
[float]$elapsed = $stopWatch.Elapsed.TotalSeconds
"🧭 Sorting $numIntegers integers by HeapSort took $elapsed sec"
exit 0 # success
```

*(generated by convert-ps2md.ps1 using the comment-based help of measure-HeapSort.ps1 as of 09/01/2023 17:51:53)*