堆排序算法实现

思路：先将数组以大根堆形式存取，然后每次将首尾元素替换时，将堆长度减1，最后就是从小到大排列

代码如下：

class Solution
{
public:
void heapSort(int nums[], int n)
{
for (int i = n / 2; i >= 0; i--)
{
siftUp(i, nums, n);
}

int len = n;
for (int i = 0; i < n; i++)
{
swap(nums[0], nums[len - 1]);
len--;
siftUp(0, nums, len);
}

}

private:
void siftUp(int cur, int nums[], int n)
{
while (cur < n)
{
int left = 2 * cur + 1, right = 2 * cur + 2;
if (left >= n) break;

int child = left;
int max_value = nums[child];
if (right < n && nums[child] < nums[right])
{
child = right;
max_value = nums[right];
}

if (nums[cur] >= max_value) break;

swap(nums[cur], nums[child]);
cur = child;
}
}
};

测试如下：

#include <iostream>
#include <fstream>
#include <algorithm>
#include <iterator>

using namespace std;

int main()
{
int nums[] = {4, 3, 1, 2, 5};
Solution solution;
int len = sizeof(nums) / sizeof(int);
solution.heapSort(nums, len);

copy(nums, nums + len, ostream_iterator<int>(cout, " "));
return 0;
}

js实现：

var heapSort = {
sort:function(nums)
{
var len = nums.length;
for (var i = len / 2; i >= 0; i--)
{
this.siftUp(i, nums, len);
}

var n = len;
for (var i = 0; i < len; i++)
{
var tmp = nums[0];
nums[0] = nums[n - 1];
nums[n - 1] = tmp;

n--;
this.siftUp(0, nums, n);
}
},

siftUp:function(cur, nums, n)
{
while (cur < n)
{
var left = 2 * cur + 1, right = 2 *  cur + 2;
if (left >= n) break;

var child = left;
var max_value = nums[child];

if (right < n && nums[right] > max_value)
{
max_value = nums[right];
child = right;
}

if (nums[cur] >= max_value) break;

var tmp = nums[cur];
nums[cur] = nums[child];
nums[child] = tmp;
}
}
};

var nums = [3, 4, 5, 1];
heapSort.sort(nums);
console.log(nums);

第二种实现形式，是将当前结点元素与子元素比较，将当前元素移动到合适的位置

代码如下：

class Solution
{
public:
void heapSort(int nums[], int n)
{
for (int i = n / 2; i >= 0; i--)
{
siftUp(i, nums, n);
}

int len = n;
for (int i = 0; i < n; i++)
{
int tmp = nums[0]; nums[0] = nums[len - 1]; nums[len - 1] = tmp;
len--;
siftUp(0, nums, len);
}

}

private:
void siftUp(int cur, int nums[], int n)
{
int child = 2 * cur + 1;
int elem = nums[cur];
while (child < n)
{
if (child + 1 < n && nums[child] < nums[child + 1]) child++;

if (elem >= nums[child]) break;

nums[cur] = nums[child];
cur = child;
child = 2 * cur + 1;
}

nums[cur] = elem;
}
};