#include <bits/stdc++.h>

using namespace std;

using ll = long long;
using ld = long double;
using D = double;
using uint = unsigned int;

#ifdef WIN32
    #define LLD "%I64d"
#else
    #define LLD "%lld"
#endif

#define pb push_back
#define mp make_pair
#define all(x) x.begin(),x.end()
#define fi first
#define se second

const int maxn = 100005;
const int maxk = 17;

int p[maxn][maxk];
vector<int> gr[maxn];
vector<int> sons[maxn], toadd[maxn], sumsons[maxn];
vector<pair<int, int>> todel[maxn];
vector<pair<int, int>> cursons;
int tin[maxn], tout[maxn];
int sz[maxn];
int n, k;
int answer;
int mink[maxn];
int mark[maxn];
int wasmark;
int wask[maxn];
int ttldel[maxn];
int pos[maxn];
int timer;
vector<int> lowest, now;

inline bool isanc(int a, int b)
{
	return tin[a] <= tin[b] && tout[a] >= tout[b];
}

void prepare(int cur, int pr)
{
// 	cout << "prepare " << cur << ' ' << pr << endl;
	tin[cur] = timer++;
	p[cur][0] = pr;
	for (int k = 1; k < maxk; k++) p[cur][k] = p[p[cur][k - 1]][k - 1];
	sz[cur] = 1;
	for (auto v : gr[cur]) if (v != pr)
	{
		prepare(v, cur);
		sz[cur] += sz[v];
	}
// 	cout << "a " << cur << endl;
	cursons.clear();
	for (auto v : gr[cur]) if (v != pr)
	{
		cursons.push_back({sz[v], v});
	}
// 	cout << "b " << cur << endl;
	sort(all(cursons));
	reverse(all(cursons));
	sumsons[cur].push_back(0);
	for (int i = 0; i < (int)cursons.size(); i++)
	{
		sons[cur].push_back(cursons[i].fi);
		pos[cursons[i].se] = i;
		sumsons[cur].push_back(sumsons[cur].back() + cursons[i].fi);
	}
// 	cout << "c " << cur << endl;
	if (sz[cur] == 1)
	{
		lowest.pb(cur);
	}
	tout[cur] = timer - 1;
}

inline void updwas(int cur)
{
	if (wask[cur] == k) return;
	ttldel[cur] = 0;
	todel[cur].clear();
	wask[cur] = k;
}

inline int get(int cur, int t)
{
// 	cout << "get " << cur << ' ' << t << endl;
	int cursum = sumsons[cur][t];
	int curkv = t;
	for (auto x : todel[cur]) if (x.fi < t)
	{
		cursum -= sons[cur][x.fi];
		curkv--;
	}
// 	cout << "now " << cursum << ' ' << curkv << endl;
	int whsons = t;
	int whadd = 0;
	while (curkv < t)
	{
		while (whsons < (int)sons[cur].size() && mark[whsons] == wasmark) whsons++;
// 		cout << curkv << ' ' << whsons << ' ' << whadd << endl;
		if (whsons == (int)sons[cur].size() || (whadd < (int)toadd[cur].size() && toadd[cur][whadd] > sons[cur][whsons]))
		{
// 			cout << "gere " << endl;
			cursum += toadd[cur][whadd];
			curkv++;
			whadd++;
		} else
		{
			cursum += sons[cur][whsons];
			curkv++;
			whsons++;
		}
	}
// 	cout << cursum << endl;
	return cursum;
}

inline int proceed(int cur)
{
// 	cout << "proceed " << cur << endl;
	assert(wask[cur] == k);
	assert(sz[cur] - ttldel[cur] > k);
	int need = sz[cur] - ttldel[cur] - k;
	toadd[cur].clear();
	wasmark++;
	for (auto t : todel[cur])
	{
		toadd[cur].push_back(sons[cur][t.fi] - t.se);
		mark[t.fi] = wasmark;
	}
	sort(all(toadd[cur]));
	reverse(all(toadd[cur]));
// 	cout << "here " << ' ' << need << endl;
	int l = 0;
	int r = sons[cur].size();
	while (r - l > 1)
	{
		int m = (l + r) / 2;
		if (get(cur, m) >= need) r = m;
		else l = m;
	}
// 	cout << "cut " << r << endl;
	answer += r;
	return get(cur, r);
}

int go(int cur, int prv, int nxt)
{
// 	cout << "go " << cur << ' ' << prv << ' ' << nxt << endl;
	if (isanc(cur, prv) || isanc(cur, nxt)) return cur;
	updwas(cur);
	if (sz[cur] - ttldel[cur] > k)
	{
		ttldel[cur] += proceed(cur);
	}
	int curdel = ttldel[cur];
	while (true)
	{
// 		cout << "curdel = " << curdel << endl;
		for (int kk = maxk - 1; kk >= 0; kk--)
		{
			int to = p[cur][kk];
			bool ok = !isanc(to, prv) && !isanc(to, nxt);
			if (ok) cur = p[cur][kk];
		}
		int son = cur;
		cur = p[cur][0];
		updwas(cur);
		ttldel[cur] += curdel;
		todel[cur].push_back({pos[son], curdel});
		if (isanc(cur, prv) || isanc(cur, nxt))
		{
			return cur;
		}
		curdel += proceed(cur);
	}
}

int main()
{
	scanf("%d", &n);
	for (int i = 0; i < n - 1; i++)
	{
		int a, b;
		scanf("%d%d", &a, &b);
		a--, b--;
		gr[a].pb(b);
		gr[b].pb(a);
	}
	prepare(0, 0);
	for (int i = 0; i < n; i++) mink[i] = n;
	for (k = 1; k < n; k++)
	{
// 		cout << "================ k = " << k << endl;
		for (int i = 0; i < (int)lowest.size(); i++)
		{
			while (sz[lowest[i]] <= k) lowest[i] = p[lowest[i]][0];
		}
		lowest.resize(unique(all(lowest)) - lowest.begin());
		int cur = 0;
		for (int i = 0; i < (int)lowest.size(); i++)
		{
			bool need = true;
			if (cur > 0 && isanc(lowest[i], lowest[cur - 1])) need = false;
			if (i + 1 < (int)lowest.size() && isanc(lowest[i], lowest[i + 1])) need = false;
			if (need) lowest[cur++] = lowest[i];
		}
		lowest.resize(cur);
// 		for (auto t : lowest) cout << t << ' ';
// 		cout << endl;
		now = lowest;
		answer = 0;
		while (true)
		{
			if (now.size() == 1 && now[0] == 0) break;
			for (int i = 0; i < (int)now.size(); i++)
			{
				int prv = 0;
				if (i > 0) prv = now[i - 1];
				int nxt = 0;
				if (i + 1 < (int)now.size()) nxt = now[i + 1];
				now[i] = go(now[i], prv, nxt);
			}
			now.resize(unique(all(now)) - now.begin());
// 			cout << "now: " << endl;
// 			for (auto t : now) cout << t << ' ';
// 			cout << endl;
		}
		updwas(0);
		if (sz[0] - ttldel[0] > k) proceed(0);
// 		cout << "answer = " << answer << endl;
		mink[answer] = min(mink[answer], k);
	}
	for (int i = 1; i < n; i++) mink[i] = min(mink[i], mink[i - 1]);
	for (int i = 1; i < n; i++) printf("%d ", mink[i]);
	printf("\n");
    return 0;
}