#include <cmath>
#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <list>
#include <time.h>
#include <math.h>
#include <random>
#include <deque>
#include <queue>
#include <cassert>
#include <unordered_map>
#include <iomanip>
#include <bitset>

using namespace std;

typedef long long ll;

mt19937 rnd(228);

const int N = 2e5 + 7;

vector <int> g[N];
int sz[N];
int ans[N];
int t[4 * N];
int d[4 * N];

void push(int v)
{
    d[v * 2 + 1] += d[v];
    d[v * 2 + 2] += d[v];
    t[v * 2 + 1] += d[v];
    t[v * 2 + 2] += d[v];
    d[v] = 0;
}

void upd(int v, int l, int r, int tl, int tr, int x)
{
    if (tl >= r || tr <= l)
    {
        return;
    }
    if (tl >= l && tr <= r)
    {
        t[v] += x;
        d[v] += x;
    }
    else
    {
        int tm = (tl + tr) / 2;
        push(v);
        upd(v * 2 + 1, l, r, tl, tm, x);
        upd(v * 2 + 2, l, r, tm, tr, x);
        t[v] = max(t[v * 2 + 1], t[v * 2 + 2]);
    }
}

void dfs(int v, int pr)
{
    sz[v] = 1;
    for (int to : g[v])
    {
        if (to != pr)
        {
            dfs(to, v);
            sz[v] += sz[to];
        }
    }
}

int n;

void relax()
{
    while (t[0] >= 0)
    {
        int v = 0;
        int l = 0, r = N;
        while (l < r - 1)
        {
            int m = (l + r) / 2;
            push(v);
            if (t[v * 2 + 1] >= 0)
            {
                r = m;
                v = v * 2 + 1;
            }
            else
            {
                l = m;
                v = v * 2 + 2;
            }
        }
        ans[l]++;
        upd(0, l, r, 0, N, -t[v] - l);
    }
}

int get(int v, int l, int r, int i)
{
    if (r - l == 1)
    {
        return t[v];
    }
    else
    {
        int m = (l + r) / 2;
        push(v);
        if (i < m)
        {
            return get(v * 2 + 1, l, m, i);
        }
        else
        {
            return get(v * 2 + 2, m, r, i);
        }
    }
}

void solve(int v, int pr)
{
    int x = -1;
    for (int to : g[v])
    {
        if (to != pr)
        {
            if (x == -1 || sz[to] > sz[x])
            {
                x = to;
            }
        }
    }
    vector <int> know;
    for (int to : g[v])
    {
        if (to != pr && to != x)
        {
            solve(to, v);
            while ((int) know.size() <= sz[to])
            {
                know.push_back(0);
            }
            for (int x = 1; x <= sz[to]; x++)
            {
                int val = get(0, 0, N, x);
                know[x] += val + x;
                upd(0, x, x + 1, 0, N, -val - x);
            }
        }
    }
    for (int to : g[v])
    {
        if (to != pr && to == x)
        {
            solve(to, v);
        }
    }
    for (int to : g[v])
    {
        if (to != pr)
        {
            upd(0, sz[to] + 1, sz[v] + 1, 0, N, sz[to]);
        }
    }
    upd(0, 0, sz[v] + 1, 0, N, 1);
    for (int i = 1; i < (int) know.size(); i++)
    {
        upd(0, i, i + 1, 0, N, know[i]);
    }
    relax();
}

int main()
{
#ifdef ONPC
    freopen("a.in", "r", stdin);
#endif
    ios::sync_with_stdio(0);
    cin.tie(0);
    cin >> n;
    for (int i = 1; i < n; i++)
    {
        int a, b;
        cin >> a >> b;
        a--, b--;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    for (int i = 0; i < N; i++)
    {
        if (1 <= i && i <= n)
        {
            upd(0, i, i + 1, 0, N, -i);
        }
        else
        {
            upd(0, i, i + 1, 0, N, -N);
        }
    }
    dfs(0, -1);
    solve(0, -1);
    for (int i = 1; i <= n; i++)
    {
        cout << ans[i] << '\n';
    }
}