#include <bits/stdc++.h>
using namespace std;

#define ar array
#define F first
#define S second
typedef int uci;
#define int long long
int diff[200001];
int has[200001];
bool leaf[200001];
int lc;
void pre(int v, vector<vector<int>> &adj){
    if(leaf[v]){
        has[v] = 1;
        return;
    }
    for(int i : adj[v]){
        pre(i, adj);
        has[v] += has[i];
    }
}

void recurse(int v, vector<int> &ins, vector<vector<int>> &adj){
    int ones = adj[v].size();
    ones -= 2;
    vector<pair<vector<int>, int>> comp(adj[v].size());
    for(int i{}; i < adj[v].size(); ++i){
        recurse(adj[v][i], comp[i].F, adj);
        comp[i].S = has[adj[v][i]];
    }
    sort(comp.begin(), comp.end());
    priority_queue<ar<int, 3>, vector<ar<int, 3>>, greater<>> q;
    for(int i{}; i < adj[v].size(); ++i){
        if(comp[i].F.size())
            q.push({comp[i].F[0], i, 1});
        else{
            q.push({comp[i].S, i, 1});
        }
    }
    int run{};
    int c{};
    while(q.size()){
        auto t = q.top();
        q.pop();
        if(t[2] > comp[t[1]].F.size()){
            if(c < ones)
                c++;
            else
                continue;
        }
        ins.push_back(run+t[0]);
        run += t[0];
        int i = t[1];
        if(t[2] == comp[t[1]].F.size()){
            q.push({comp[i].S - comp[i].F.back(), i, t[2]+1});
        }else if(t[2] > comp[t[1]].F.size())
            continue;
        else{
            q.push({comp[i].F[t[2]] - comp[i].F[t[2]-1], i, t[2]+1});
        }

    }
    /*
    cout << "vertex: " << v << '\n';
    for(int i : ins)
        cout << i << ' ';
    cout << '\n';
    */
}

void solve(){
    memset(has, 0, sizeof(has));
    int n;
    cin >> n;
    vector<vector<int>> adj(n);
    vector<int> par(n);
    for(int i{1}; i < n; ++i){
        cin >> par[i];
        par[i]--;
        adj[par[i]].push_back(i);
    }
    memset(leaf, 0, sizeof(leaf));
    int tot = n;
    lc = 0;
    for(int i{}; i < n; ++i){
        if(adj[i].empty()){
            leaf[i] = true;
            lc++;
        }
        if(adj[i].size() == 1)
            tot--;
    }
    pre(0, adj);
    for(int i{}; i < n; ++i)
        diff[i] = 2;
    vector<int> ones;
    recurse(0, ones, adj);
    for(int i : ones){
        diff[lc-i] = 1;
    }
    vector<int> out(lc, tot);
    for(int i = lc-1; i >= 0; --i){
        out[i] = tot;
        tot -= diff[i];
    }
    for(int i : out)
        cout << i << ' ';
    cout << '\n';
}

uci main(){
    ios_base::sync_with_stdio(false);
    cin.tie(0), cout.tie(0);
    solve();
}