//#pragma GCC optimize("O3")
//#pragma GCC optimize("unroll-loops")
//#pragma GCC target("avx2") // doesn't work on Yandex
//#pragma GCC target("avx") // for old judges
//#pragma GCC target("bmi,bmi2,lzcnt,popcnt") // fast bit operations

#include <iostream>
#include <iomanip>
#include <vector>
#include <set>
#include <map>
#include <unordered_map>
#include <queue>
#include <deque>
#include <cmath>
#include <algorithm>
#include <cassert>
#include <chrono>
#include <random>
#include <string>
#include <numeric>
#include <complex>
#include <tuple>
#include <utility>
#include <bitset>
#include <array>
#include <stack>
#include <sstream>
#include <unordered_set>

using namespace std;
typedef long long ll;

string to_string(string a) { return '"' + a + '"'; }
string to_string(char a) { return "'" + string(1, a) + "'"; }
string to_string(const char* a) { return to_string((string) a); }
string to_string(bool a) { return a ? "true" : "false"; }
template <class T1, class T2>
string to_string(pair<T1, T2> a) {
    return "(" + to_string(a.first) + ", " + to_string(a.second) + ")";
}
template <class T>
string to_string(T a) {
    bool first = true; string res = "{";
    for (const auto& i : a) {
        if (!first) res += ", ";
        first = false;
        res += to_string(i);
    }
    res += "}";
    return res;
}
void debug_out() { cerr << endl; }
template <class T1, class... T2>
void debug_out(T1 a, T2... b) {
    cerr << " " << to_string(a);
    debug_out(b...);
}

#ifdef LOCAL
#define out(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define out(...) 42
#endif

clock_t start_time; void start_timer() { start_time = clock(); }
double get_time() { return (double) (clock() - start_time) / CLOCKS_PER_SEC; }

void Solve();

int main() {
    ios_base::sync_with_stdio(0); cin.tie(0);
#ifdef LOCAL
    freopen("usr/share/man/man1/input.txt", "r", stdin);
#endif
    start_timer();
    Solve();
#ifdef LOCAL
    cerr << fixed << setprecision(3);
    cerr << endl << "Time spent: " << get_time() << endl;
#endif
    return 0;
}

// do something, stay focused
// look for stupid bugs
// guess, slow, stress
// don't overgeneralize
// don't rush

// don't waste time on standings

// SOLVE THE PROBLEM OR DIE TRYING
// THE SOLUTION IS ALWAYS SIMPLE
// THE CODE IS ALWAYS SHORT

const int N = 2e5 + 5;
const int L = 20;

vector<int> g[N];
int tin[N];
int tout[N];
int up[N][L];
int timer = 1;

void dfs_lca(int v = 1, int p = 1) {
    tin[v] = timer++;
    up[v][0] = p;
    for (int i = 1; i < L; i++) {
        up[v][i] = up[up[v][i - 1]][i - 1];
    }
    for (int u : g[v]) {
        if (u != p) dfs_lca(u, v);
    }
    tout[v] = timer - 1;
}

bool is_anc(int u, int v) {
    return tin[u] <= tin[v] && tin[v] <= tout[u];
}

int lca(int u, int v) {
    if (is_anc(u, v)) return u;
    if (is_anc(v, u)) return v;
    for (int i = L - 1; i >= 0; i--) {
        if (!is_anc(up[u][i], v)) u = up[u][i];
    }
    return up[u][0];
}

void add_e(int u, int v) {
    g[u].push_back(v);
    g[v].push_back(u);
}

int dp[N];
vector<int> ls;
set<int> tree;
set<int> ls_set;

void dfs(int v = 1, int p = 0) {
    if (v > 1 && g[v].size() == 1) {
        g[v].clear();
        dp[v] = 1;
        return;
    }
    vector<pair<int, int>> cur;
    for (int u : g[v]) {
        if (u == p) continue;
        dfs(u, v);
        cur.push_back({dp[u], u});
    }
    sort(cur.rbegin(), cur.rend());
    g[v].clear();
    for (auto [d, u] : cur) {
        g[v].push_back(u);
    }
    dp[v] = 1;
    for (int i = 0; i <= 1; i++) {
        if (i < cur.size()) {
            dp[v] += cur[i].first;
        }
    }
}

vector<vector<int>> ts;
vector<int> t[N];

void merge(vector<int>& a, vector<int>& b) {
    if (a.size() < b.size()) {
        swap(a, b);
    }
    for (int i : b) {
        a.push_back(i);
    }
    b.clear();
}

void dfs_t(int v = 1) {
    if (g[v].empty()) {
        t[v] = {v};
        return;
    }
    for (int u : g[v]) {
        dfs_t(u);
    }
    if (g[v].size() >= 1) {
        merge(t[v], t[g[v][0]]);
    }
    if (g[v].size() >= 2) {
        merge(t[v], t[g[v][1]]);
    }
    for (int i = 2; i < g[v].size(); i += 2) {
        vector<int> cur;
        merge(cur, t[g[v][i]]);
        if (i + 1 < g[v].size()) {
            merge(cur, t[g[v][i + 1]]);
        }
        ts.push_back(cur);
    }
}

void Solve() {
    int n;
    cin >> n;
    for (int i = 2; i <= n; i++) {
        int p;
        cin >> p;
        add_e(i, p);
    }
    dfs();
    dfs_lca();
    dfs_t();
    ts.push_back(t[1]);
    sort(ts.begin(), ts.end(), [&](vector<int>& a, vector<int>& b) {
        return a.size() > b.size();
    });
    for (auto& i : ts) {
        for (auto j : i) {
            ls.push_back(j);
        }
    }
    for (int l : ls) {
        auto it = ls_set.lower_bound(l);
        if (it != ls_set.end()) {
            tree.insert(lca(l, *it));
        }
        if (it != ls_set.begin()) {
            --it;
            tree.insert(lca(l, *it));
        }
        tree.insert(l);
        ls_set.insert(l);
        cout << tree.size() << " ";
    }
    cout << "\n";
}