《Cracking the Coding Interview》——第18章：难题——题目6

2014-04-29 02:27

题目：找出10亿个数中最小的100万个数，假设内存可以装得下。

解法1：内存可以装得下？可以用快速选择算法得到无序的结果。时间复杂度总体是O(n)级别，但是常系数不小。

代码：

// 18.6 Find the smallest one million number among one billion numbers.
// Suppose one billion numbers can fit in memory.
// I'll use quick selection algorithm to find them. This will return an unsorted result.
// Time complexity is O(n), but the constant factor may be massive. I don't quite like this algorithm.
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

const int CUT_OFF = 3;

int medianThree(vector<int> &v, int ll, int rr)
{
    int mm = (ll + rr) / 2;

    if (v[ll] > v[mm]) {
        swap(v[ll], v[mm]);
    }
    if (v[ll] > v[rr]) {
        swap(v[ll], v[rr]);
    }
    if (v[mm] > v[rr]) {
        swap(v[mm], v[rr]);
    }
    swap(v[mm], v[rr - 1]);
    return v[rr - 1];
}

void quickSelect(vector<int> &v, int ll, int rr, int k)
{
    // reference from "Data Structure and Algorithm Analysis in C" by Mark Allen Weiss.
    int pivot;
    int i, j;
    
    if (ll + CUT_OFF <=    rr) {
        pivot = medianThree(v, ll, rr);
        i = ll;
        j = rr - 1;
        
        while (true) {
            while (v[++i] < pivot);
            while (v[--j] > pivot);
            if (i > j) {
                break;
            }
            swap(v[i], v[j]);
        }
        swap(v[i], v[rr - 1]);
    
        if (k < i) {
            return quickSelect(v, ll, i - 1, k);
        } else if (k > i) {
            return quickSelect(v, i + 1, rr, k);
        }
    } else {
        for (i = ll; i <= rr; ++i) {
            for (j = i + 1; j <= rr; ++j) {
                if (v[i] > v[j]) {
                    swap(v[i], v[j]);
                }
            }
        }
    }
}

int main()
{
    vector<int> v;
    vector<int> res;
    int n, k;
    int i;
    int k_small, count;
    
    while (cin >> n >> k && (n > 0 && k > 0)) {
        v.resize(n);
        for (i = 0; i < n; ++i) {
            cin >> v[i];
        }

        // find the kth smallest number
        // this will change the order of elements
        quickSelect(v, 0, n - 1, k - 1);
        k_small = v[k - 1];
        count = k;
        for (i = 0; i < n; ++i) {
            if (v[i] < k_small) {
                --count;
            }
        }
        for (i = 0; i < n; ++i) {
            if (v[i] < k_small) {
                res.push_back(v[i]);
            } else if (v[i] == k_small && count > 0) {
                res.push_back(v[i]);
                --count;
            }
        }
        
        cout << '{';
        for (i = 0; i < k; ++i) {
            i ? (cout << ' '), 1 : 1;
            cout << res[i];
        }
        cout << '}' << endl;
        
        v.clear();
        res.clear();
    }
    
    return 0;
}

 

解法2：如果要求结果也是有序的，那可以用最大堆得到有序结果。时间复杂度是O(n * log(m))级别，思路和代码相比快速选择算法都更简单，不过效率低了些。

代码：

// 18.6 Find the smallest one million number among one billion numbers.
// Suppose one billion numbers can fit in memory.
// I'll use a max heap, which runs in O(n * log(k)) time, returns a sorted result.
#include <iostream>
#include <queue>
#include <vector>
using namespace std;

template <class T>
struct myless {
    bool operator () (const T &x, const T &y) {
        return x < y;
    };
};

int main()
{
    int val;
    int n, k;
    int i;
    // max heap
    priority_queue<int, vector<int>, myless<int> > q;
    vector<int> v;
    
    while (cin >> n >> k && (n > 0 && k > 0)) {
        k = k < n ? k : n;
        for (i = 0; i < k; ++i) {
            cin >> val;
            q.push(val);
        }
        
        for (i = k; i < n; ++i) {
            cin >> val;
            if (q.top() > val) {
                q.pop();
                q.push(val);
            }
        }
        while (!q.empty()) {
            v.push_back(q.top());
            q.pop();
        }
        reverse(v.begin(), v.end());
        
        cout << '{';
        for (i = 0; i < k; ++i) {
            i ? (cout << ' '), 1 : 1;
            cout << v[i];
        }
        cout << '}' << endl;
        
        v.clear();
    }
    
    return 0;
}