#include <bits/stdc++.h>

#define rep(i,s,n) for(int i = int(s); i < int(n); i++)
#define rrep(i,s,n) for(int i = int(n) - 1; i >= int(s); i--)
#define all(v) (v).begin(), (v).end()

using ll = long long;
using ld = long double;
using ull = unsigned long long;

template<class T>
bool chmin(T &a, T b) {
    if(a <= b) return false;
    a = b;
    return true;
}

template<class T>
bool chmax(T &a, T b) {
    if(a >= b) return false;
    a = b;
    return true;
}

using namespace std;

int main() {
    std::cin.tie(nullptr);
    std::ios::sync_with_stdio(false);

    int n; cin >> n;
    vector ikeru(n, vector<int>(0));
    vector<int> deg(n);
    rep(i,1,n){
        int p; cin >> p;
        ikeru[p-1].push_back(i);
        deg[p-1]++;
    }
    
    vector<int> doit(n);
    iota(all(doit),0);
    int leaf = 0;
    rep(i,0,n){
        if (deg[i] == 0){
            leaf++;
        }else if(deg[i] == 1){
            doit[ikeru[i][0]] = doit[i];
        }
    }

    vector<bool> good(n);
    rep(i,0,n){
        if (doit[i] == i) good[i] = 1;
    }

    vector new_ikeru(n, vector<int>(0));
    rrep(i,0,n){
        for (int j: ikeru[i]){
            if (doit[i] == doit[j]) continue;
            new_ikeru[doit[i]].push_back(doit[j]);
        }
    }

    vector<int> dp(n);
    vector<vector<pair<int,int>>> gg(n, vector<pair<int,int>>(0));
    rrep(i,0,n){
        if (!good[i]) continue;
        vector<pair<int,int>> tmp;
        if ((int)new_ikeru[i].size() == 0){
            dp[i] = 1;
            continue;
        }
        for (int j: new_ikeru[i]){
            tmp.push_back(pair(dp[j], j));
        }
        sort(all(tmp));
        reverse(all(tmp));
        assert((int)tmp.size() >= 2);
        dp[i] = tmp[0].first + tmp[1].first;
        gg[i] = tmp;
    }

    vector<int> lens;
    auto dfs = [&](auto self, int i, bool mode) -> void {
        assert(good[i]);
        if (mode) lens.push_back(dp[i]);
        for (int j=0; j<(int)gg[i].size(); j++){
            if (j < 2){
                self(self, gg[i][j].second, false);
            }else{
                self(self, gg[i][j].second, true);
            }
        }
    };
    
    for (int i=0; i<n; i++){
        if (good[i]){
            dfs(dfs, i, 1);
            break;
        }
    }

    sort(all(lens));
    reverse(all(lens));
    vector<int> imos;
    rep(i,0,(int)lens.size()){
        imos.push_back(1);
        rep(j,1,lens[i]){
            imos.push_back(2);
        }
    }

    assert((int)imos.size() == leaf);
    int tmp = 0;
    rep(i,0,leaf){
        tmp += imos[i];
        cout << tmp;
        if (i == leaf-1) cout << '\n';
        else cout << ' ';
    }

}