#include <bits/stdc++.h>

#define lsb(x) (x & (-x))

using ull = unsigned long long;
using ll = long long;

using namespace std;


#ifdef HOME
    #define LOCAL_CHECK(x) assert(x);
#else
    #define LOCAL_CHECK(x)
#endif 

// https://judge.yosupo.jp/submission/159946

template<bool _CompressPath = true>
class DSU {
public:
    DSU(int n) : n(n) {
        LOCAL_CHECK(n > 0);

        link.resize(n, -1);
        size.resize(n, 1);
    }

    int getRoot(int x) noexcept {
        LOCAL_CHECK(0 <= x && x < n);

        if (_CompressPath) {
            return link[x] == -1 ? x : link[x] = getRoot(link[x]);
        } else {
            return link[x] == -1 ? x : getRoot(link[x]);
        }
    }

    bool join(int x, int y) noexcept(_CompressPath) {
        LOCAL_CHECK(0 <= x && x < n);
        LOCAL_CHECK(0 <= y && y < n);

        x = getRoot(x), y = getRoot(y);
        if (size[x] > size[y]) {
            std::swap(x, y);
        }

        bool joined = (x != y);
        if (joined) {
            link[x] = y;
            size[y] += size[x];
            if (!_CompressPath) {
                joinedLinks.push(x);
            }
        } else {
            if (!_CompressPath) {
                joinedLinks.push(-1);
            }
        }

        return joined;
    }

    inline int getSize(int x) noexcept {
        return size[getRoot(x)];
    }

    void undo() {
        static_assert(!_CompressPath);

        if (!joinedLinks.empty()) {
            auto lastJoin = joinedLinks.top();

            joinedLinks.pop();

            if (lastJoin == -1) return;

            size[link[lastJoin]] -= size[lastJoin];
            link[lastJoin] = -1;
        } else {
            assert(false);
        }
    }

private:
    std::vector<int> link;
    std::vector<int> size;
    int n;

    std::stack<int> joinedLinks;
};

int main() {
#ifdef HOME
    ifstream cin("input.in");
    ofstream cout("output.out");
#endif
    ios::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);

    int n;
    cin >> n;

    vector<ll> r(n + 1);
    for (int i = 1; i <= n; i++) {
        cin >> r[i];
    }
    sort(r.begin() + 1, r.end());

    vector<pair<ll, int>> diffs;
    for (int i = 1; i < n; i++) {
        diffs.push_back({r[i + 1] - r[i], i});
    }

    sort(diffs.begin(), diffs.end());
    DSU<true> dsu(n + 1);

    constexpr ll INF = 1e18;
    vector<ll> results(n + 2, INF);
    int current = 0;
    int i = 0;

    while (i < (int)diffs.size()) {
        int j = i;
        while (j < (int)diffs.size() && diffs[i].first == diffs[j].first) {
            int pos = diffs[i].second;
            if  (dsu.getRoot(pos) != dsu.getRoot(pos + 1)) {
                current -= dsu.getSize(pos) / 2;
                current -= dsu.getSize(pos + 1) / 2;
                dsu.join(pos, pos + 1);
                current += dsu.getSize(pos) / 2;
            }
            j++;
        }
        results[current] = min(results[current], diffs[i].first);        
        i = j;
    }

    for (int i = n / 2; i >= 1; i--) {
        results[i] = min(results[i], results[i + 1]);
    }
    for (int i = 1; i <= n / 2; i++) {
        cout << results[i] << " ";
    }

    return 0;
}