#include <algorithm>
#include <iostream>
#include <unordered_set>
#include <vector>
#include <map>

int n;
std::vector<int> E[200007];
int fa[200007], sz[200007], maxsz[200007], dep[200007];
std::map<std::pair<int, int>, int> Sz;

void dfs(int u, std::unordered_set<int>& vertex, std::vector<int>& vs) {
  vs.push_back(u), sz[u] = 1, maxsz[u] = 0;
  for (int v : E[u]) {
    if (v != fa[u] && vertex.find(v) != vertex.end()) {
      fa[v] = u;
      dep[v] = dep[u] + 1;
      dfs(v, vertex, vs);
      sz[u] += sz[v];
      maxsz[u] = std::max(maxsz[u], sz[v]);
    }
  }
  maxsz[u] = std::max(maxsz[u], int(vertex.size()) - sz[u]);
}
int findG(std::unordered_set<int> vertex) {
  std::vector<int> tmp;
  int t = *vertex.begin();
  dfs(t, vertex, tmp);
  for (int i : vertex) {
    if (maxsz[i] < maxsz[t]) {
      t = i;
    }
  }
  return t;
}

int lowbit(int x) { return x & (-x); }
int bit[200007];
int query(int x) {
  if (x == 0) {
    return 0;
  }
  return std::max(bit[x], query(x - lowbit(x)));
}
void modify(int x, int d) {
  if (x > n) {
    return;
  }
  bit[x] = std::max(bit[x], d);
  modify(x + lowbit(x), d);
}
void modify0(int x) {
  if (x > n) {
    return;
  }
  bit[x] = 0;
  modify0(x + lowbit(x));
}

int ans[200007];

void Divide_Conquer(std::unordered_set<int> vertex) {
  int root = findG(vertex);
  std::vector<std::vector<int>> sons;
  for (int i : E[root]) {
    if (vertex.find(i) != vertex.end()) {
      std::vector<int> st;
      fa[i] = root, dep[i] = 1;
      dfs(i, vertex, st);
      sons.push_back(st);
    }
  }
  int szr = n - vertex.size() + 1;
  for (int t = 0; t < 2; ++t) {
    for (auto i : sons) {
      for (int j : i) {
        int S = Sz[{fa[j], j}];
        int d = query(n + 1 - S);
        if (d) {
          ans[S] = std::max(ans[S], 1 + dep[j] + d);
        }
        ans[std::min(S, szr)] = std::max(ans[std::min(S, szr)], dep[j] + 1);
      }
      for (int j : i) {
        int S = Sz[{fa[j], j}];
        modify(n + 1 - S, dep[j]);
      }
    }
    for (auto i : sons) {
      for (int j : i) {
        int S = Sz[{fa[j], j}];
        modify0(n + 1 - S);
      }
    }
    std::reverse(sons.begin(), sons.end());
  }
  for (auto i : sons) {
    Divide_Conquer(std::unordered_set<int>(i.begin(), i.end()));
  }
}

int main() {
  std::cin.tie(nullptr)->sync_with_stdio(false);
  std::cin >> n;
  for (int i = 1; i < n; ++i) {
    int u, v;
    std::cin >> u >> v;
    E[u].push_back(v), E[v].push_back(u);
  }
  std::unordered_set<int> t;
  for (int i = 1; i <= n; ++i) {
    t.insert(i);
  }
  std::vector<int> s;
  fa[1] = 0, dfs(1, t, s);
  for (int i = 2; i <= n; ++i) {
    Sz[{fa[i], i}] = sz[i];
    Sz[{i, fa[i]}] = n - sz[i];
  }
  Divide_Conquer(t);
  fa[1] = 0, dfs(1, t, s);
  int r = 0;
  for (int i = 1; i <= n; ++i) {
    r = std::max(r, std::min(sz[i], n - sz[i]));
  }
  ans[r] = std::max(ans[r], 2);
  for (int i = n; i >= 1; --i) {
    ans[i] = std::max(ans[i], 1);
    ans[i] = std::max(ans[i], ans[i + 1]);
  }
  for (int i = 1; i <= n; ++i) {
    if (i & 1) {
      std::cout << "1\n";
    } else {
      std::cout << ans[i >> 1] << '\n';
    }
  }
  return 0;
}