```go
package main

import (
	"bufio"
	"os"
)

var scanner *bufio.Scanner

func init() {
	scanner = bufio.NewScanner(os.Stdin)
	scanner.Buffer(make([]byte, 1024*1024), 1024*1024*10)
	scanner.Split(bufio.ScanWords)
}

func readInt() int {
	scanner.Scan()
	b := scanner.Bytes()
	res := 0
	for _, v := range b {
		res = res*10 + int(v-'0')
	}
	return res
}

func writeInt(w *bufio.Writer, n int) {
	if n == 0 {
		w.WriteByte('0')
		return
	}
	var buf [20]byte
	i := len(buf)
	for n > 0 {
		i--
		buf[i] = byte('0' + n%10)
		n /= 10
	}
	w.Write(buf[i:])
}

func main() {
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	if !scanner.Scan() {
		return
	}
	b := scanner.Bytes()
	t := 0
	for _, v := range b {
		t = t*10 + int(v-'0')
	}

	for test := 0; test < t; test++ {
		n := readInt()
		parent := make([]int, n+1)
		for i := 2; i <= n; i++ {
			parent[i] = readInt()
		}

		sz := make([]int, n+1)
		for i := 1; i <= n; i++ {
			sz[i] = 1
		}
		heavy_child := make([]int, n+1)

		for i := n; i >= 2; i-- {
			p := parent[i]
			sz[p] += sz[i]
			if heavy_child[p] == 0 || sz[i] > sz[heavy_child[p]] {
				heavy_child[p] = i
			}
		}

		degree := make([]int, n+1)
		for i := 2; i <= n; i++ {
			degree[parent[i]]++
		}
		adj := make([][]int, n+1)
		for i := 1; i <= n; i++ {
			adj[i] = make([]int, 0, degree[i])
		}
		for i := 2; i <= n; i++ {
			adj[parent[i]] = append(adj[parent[i]], i)
		}

		head := make([]int, n+1)
		in := make([]int, n+1)
		outTime := make([]int, n+1)

		type State struct {
			u, edgeIdx int
		}
		stack := make([]State, 0, n)
		stack = append(stack, State{1, 0})
		head[1] = 1
		timer := 0

		for len(stack) > 0 {
			curr := &stack[len(stack)-1]
			u := curr.u
			if curr.edgeIdx == 0 {
				timer++
				in[u] = timer
			}

			if curr.edgeIdx < len(adj[u]) {
				v := adj[u][curr.edgeIdx]
				curr.edgeIdx++

				if v == heavy_child[u] {
					head[v] = head[u]
				} else {
					head[v] = v
				}
				stack = append(stack, State{v, 0})
			} else {
				outTime[u] = timer
				stack = stack[:len(stack)-1]
			}
		}

		fenwick := make([]int, n+2)
		add := func(i, delta int) {
			for ; i < len(fenwick); i += i & -i {
				fenwick[i] += delta
			}
		}
		query := func(i int) int {
			s := 0
			for ; i > 0; i -= i & -i {
				s += fenwick[i]
			}
			return s
		}
		queryRange := func(l, r int) int {
			if l > r {
				return 0
			}
			return query(r) - query(l-1)
		}

		light_max := make([]int, n+1)
		c := 1
		S := 1
		add(in[1], 1)

		ans := make([]int, 0, n-1)

		for u := 2; u <= n; u++ {
			curr := u
			for curr != 0 {
				t_node := head[curr]
				p := parent[t_node]
				if p != 0 {
					new_val := queryRange(in[t_node], outTime[t_node]) + 1
					if new_val > light_max[p] {
						light_max[p] = new_val
					}
				}
				curr = p
			}

			add(in[u], 1)
			S++

			if in[c] <= in[u] && in[u] <= outTime[c] {
				curr_u := u
				var v int
				found := false
				for head[curr_u] != head[c] {
					if parent[head[curr_u]] == c {
						v = head[curr_u]
						found = true
						break
					}
					curr_u = parent[head[curr_u]]
				}
				if !found {
					v = heavy_child[c]
				}

				if queryRange(in[v], outTime[v]) > S/2 {
					c = v
				}
			} else {
				v := parent[c]
				if S-queryRange(in[c], outTime[c]) > S/2 {
					c = v
				}
			}

			max_branch := 0
			hc := heavy_child[c]
			if hc != 0 {
				hc_sz := queryRange(in[hc], outTime[hc])
				if hc_sz > max_branch {
					max_branch = hc_sz
				}
			}
			if light_max[c] > max_branch {
				max_branch = light_max[c]
			}
			if parent[c] != 0 {
				p_sz := S - queryRange(in[c], outTime[c])
				if p_sz > max_branch {
					max_branch = p_sz
				}
			}

			ans = append(ans, S-2*max_branch)
		}

		for i, val := range ans {
			if i > 0 {
				out.WriteByte(' ')
			}
			writeInt(out, val)
		}
		out.WriteByte('\n')
	}
}
```