堆排序及拓展

set

1. 请写出堆排序的代码。
2. 输入n个整数，找出其中最小的k个数。

1、思路：

　　堆排序分为建堆（insertion）和取根数据（delete root）。每一步都涉及到堆调整，堆调整算法的时间复杂度为O(logn)。

#include <stdio.h>

#define heap_parent(npos) ((int)(((npos) - 1) / 2))
#define heap_left(npos) ((npos) * 2 + 1)
#define heap_right(npos) ((npos) * 2 + 2)

void Swap(int *a, int *b)
{
    int temp = *a;
    *a = *b;
    *b = temp;
}

void PrintArray(int data[], int length)
{
    for (int i = 0; i < length; i++)
        printf("%d ", data[i]);
    printf("\n");
}

//子树满足最大堆的性质，只要判断根与左右两节点大小，看根是否满足最大堆性质。
//如果根与左右某个节点互换位置，则可能破坏了子树的最大堆性质。
//直到根节点均大于左右子节点，或是到达叶子节点,循环结束。
void HeapAdjust(int data[], int node, int size)
{
    while (heap_left(node) < size)
    {
        int temp = heap_left(node);
        if (heap_right(node) < size)
        {
            if (data[heap_left(node)] < data[heap_right(node)])
                temp = heap_right(node);
        }
        if (data[node] < data[temp])
        {
            Swap(&data[node], &data[temp]);
            node = temp;
        }
        else
            break;
    }
}

void HeapSort(int data[], int size)
{
    //由二叉树的下层往上层进行父子节点的数据比较，进行“筛选”调整堆的过程
    //构建堆是从非叶子节点开始从下往上，调整堆是从上往下。
    for (int i = size / 2 - 1; i >= 0; i--)
        HeapAdjust(data, i, size);

    //将根数据与末数据互换位置，始终调整根数据的最大堆性质，但是堆节点数量减少。
    for (int i = size - 1; i > 0; i--)
    {
        Swap(&data[0], &data[i]);
        HeapAdjust(data, 0, i);
    }
}

int main()
{
    int test[10] = {3, 5, 6, 4, 8, 0, 2, 7, 1, 9};
    PrintArray(test, 10);
    HeapSort(test, 10);
    PrintArray(test, 10);
}

 

2、思路：

　　如果可以用STL的话，我们可以选择允许增序的关联容器multiset，实现是红黑树方法，插入和删除都是O(logk)的时间复杂度，取最大元素是O(1)的时间复杂度。

#include <iostream>
#include <vector>
#include <set>

using namespace std;

typedef multiset<int, greater<int> > setK;
typedef multiset<int, greater<int> >::iterator sIter;

void GetKLeastNumbers(const vector<int>& data, setK& leastNumbers, int k)
{
    leastNumbers.clear();
    if (k < 1 || data.size() < k) return;

    for (vector<int>::const_iterator iter = data.begin(); iter != data.end(); iter++)
    {
        if (leastNumbers.size() < k)
            leastNumbers.insert(*iter);
        else
        {
            sIter topK = leastNumbers.begin();
            if (*iter < *topK)
            {
                leastNumbers.erase(topK);
                leastNumbers.insert(*iter);
            }
        }
    }
}
        
void Test(char* testName, int* data, int n, int* expectedResult, int k)
{
    if (testName != NULL)
        printf("%s\n", testName);

    vector<int> vData;
    for (int i = 0; i < n; i++)
        vData.push_back(data[i]);

    if (expectedResult == NULL)
        printf("We don't expect any result!\n");
    else
    {
        printf("Expected result:\n");
        for (int i = 0; i < k; i++)
            printf("%d\t", expectedResult[i]);
        printf("\n");
    }

    setK leastNumbers;
    GetKLeastNumbers(vData, leastNumbers, k);
    printf("The actual output numbers are:\n");
    for (sIter iter = leastNumbers.begin(); iter != leastNumbers.end(); iter++)
        printf("%d\t", *iter);
    printf("\n");
}

int main()
{
    int data[] = {4, 5, 1, 6, 2, 7, 3, 8};
    int expected[] = {1, 2, 3, 4};
    Test("test1", data, sizeof(data) / sizeof(int), expected, sizeof(expected) / sizeof(int));
}