Top_K问题，堆排序

Top_K问题

简述：在大量数据中选出K个最大的或最小的。

以取K个最大数为例：

具体思路：

1. 将给定的数据的前K个元素压入到vector空间，对这K个数进行向下调整建小堆;

2. 再将堆顶元素和数组的其他元素进行比较，当堆顶元素小于数组中所取元素时，将所取数组元素入堆;

3. 再进行调整，直到数组所有元素都依次进行比较。

//仿函数比较
template<class T>
struct Less
{
bool operator()(const T& l, const T& r)
{
return l < r;
}
};
template<class T>
struct Greator
{
bool operator()(const T& l, const T& r)
{
return l > r;
}
};

template<class T,class Compare >
class K_Heap
{
public:
K_Heap()
{}
K_Heap(T* arr, size_t size, size_t k)
{
assert(k < size);
_a.reserve(k);
for (size_t i = 0; i < k; ++i)
{
_a.push_back(arr[i]);
}
for (size_t i = (k - 2) / 2; i > 0; --i)
{
AdjustDown(k, i);
}
for (size_t i = 0; i < size; ++i)
{
if (_a[0] < arr[i])
{
_a[0] = arr[i];
AdjustDown(k, 0);
}
}
for (size_t i = 0; i < k; ++i)
{
cout << _a[i] << " ";
}
cout << endl;
}
protected:
void AdjustDown(size_t k, size_t parent)
{
Compare com;
size_t child = parent * 2 + 1;
while (child < _a.size())
{
if (child + 1 < _a.size() && com(_a[child+1], _a[child]))
{
++child;
}
if (com(_a[child], _a[parent]))
{
swap(_a[child], _a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
private:
vector<T> _a;
};

堆排序：

具体思路：

1. 将给定的数组压入vector中，对其进行向下调整调节为大堆或者小堆；

2.取出最小的数和最大数进行交换；

3.再次进行调整的时候元素的个数应该减一，不用算最后一个元素（因为最后一个不是最大的数就是最小的数）；

4.直到所有的数都依次进行了比较。

//堆排序
template<class T>
struct Less
{
bool operator()(const T& l, const T& r)
{
return l < r;
}
};
template<class T>
struct Greator
{
bool operator()(const T& l, const T& r)
{
return l > r;
}
};
template<class T, class Compare>
class Sort_Heap
{
public:
Sort_Heap()
{}
Sort_Heap(T* arr, size_t size)
{
_a.reserve(size);
for (size_t i = 0; i < size; ++i)
{
_a.push_back(arr[i]);
}
for (int i = (size - 2) / 2; i >= 0; --i)
{
AdjustDown(size, i);
}
}
void AdjustDown(size_t size, size_t parent)
{
Compare com;
size_t child = parent * 2 + 1;
while (child < size)
{
if (child + 1 < size && com(_a[child + 1], _a[child]))
{
++child;
}
if (com(_a[child], _a[parent]))
{
swap(_a[child], _a[parent]);
parent = child;
child = parent * 2 + 1;
}
else
{
break;
}
}
}
void _Sort_Heap(size_t size)
{
size_t end = size - 1;
while (end > 0)
{
swap(_a[0], _a[end]);
AdjustDown(end, 0);
--end;
}
}
void Print()
{
for (size_t i = 0; i < _a.size(); ++i)
{
cout << _a[i] << " ";
}
cout << endl;
}
private:
vector<T> _a;
};