package main

import (
	"io"
	"os"
)

func appendInt(dst []byte, x int) []byte {
	if x == 0 {
		return append(dst, '0')
	}
	if x < 0 {
		dst = append(dst, '-')
		x = -x
	}
	var buf [20]byte
	i := len(buf)
	for x > 0 {
		i--
		buf[i] = byte('0' + x%10)
		x /= 10
	}
	return append(dst, buf[i:]...)
}

func dist(u, v int, depth []int, up [][]int, lg int) int {
	du, dv := depth[u], depth[v]
	if du < dv {
		u, v = v, u
		du, dv = dv, du
	}
	diff := du - dv
	bit := 0
	for diff > 0 {
		if diff&1 != 0 {
			u = up[bit][u]
		}
		diff >>= 1
		bit++
	}
	if u == v {
		return du + dv - 2*depth[u]
	}
	for k := lg - 1; k >= 0; k-- {
		if up[k][u] != up[k][v] {
			u = up[k][u]
			v = up[k][v]
		}
	}
	l := up[0][u]
	return du + dv - 2*depth[l]
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0
	nextInt := func() int {
		for idx < len(data) && (data[idx] < '0' || data[idx] > '9') && data[idx] != '-' {
			idx++
		}
		sign := 1
		if data[idx] == '-' {
			sign = -1
			idx++
		}
		val := 0
		for idx < len(data) && data[idx] >= '0' && data[idx] <= '9' {
			val = val*10 + int(data[idx]-'0')
			idx++
		}
		return sign * val
	}

	t := nextInt()
	out := make([]byte, 0, 1<<20)

	for ; t > 0; t-- {
		n := nextInt()

		head := make([]int, n+1)
		for i := 1; i <= n; i++ {
			head[i] = -1
		}
		to := make([]int, 2*(n-1))
		nxt := make([]int, 2*(n-1))
		edgeIdx := 0
		for i := 0; i < n-1; i++ {
			u := nextInt()
			v := nextInt()
			to[edgeIdx] = v
			nxt[edgeIdx] = head[u]
			head[u] = edgeIdx
			edgeIdx++
			to[edgeIdx] = u
			nxt[edgeIdx] = head[v]
			head[v] = edgeIdx
			edgeIdx++
		}

		lg := 1
		for (1 << lg) <= n {
			lg++
		}

		up := make([][]int, lg)
		for i := 0; i < lg; i++ {
			up[i] = make([]int, n+1)
		}
		depth := make([]int, n+1)
		queue := make([]int, n)
		queue[0] = 1
		qh, qt := 0, 1
		maxDepth := 0

		for qh < qt {
			u := queue[qh]
			qh++
			pu := up[0][u]
			for e := head[u]; e != -1; e = nxt[e] {
				v := to[e]
				if v == pu {
					continue
				}
				up[0][v] = u
				depth[v] = depth[u] + 1
				if depth[v] > maxDepth {
					maxDepth = depth[v]
				}
				for k := 1; k < lg; k++ {
					up[k][v] = up[k-1][up[k-1][v]]
				}
				queue[qt] = v
				qt++
			}
		}

		diamByR := make([]int, maxDepth)
		end1, end2, diam := 0, 0, 0
		has := false
		ptr := n - 1

		for d := maxDepth; d >= 1; d-- {
			for ptr >= 1 && depth[queue[ptr]] == d {
				v := queue[ptr]
				if !has {
					end1, end2, diam = v, v, 0
					has = true
				} else {
					d1 := dist(v, end1, depth, up, lg)
					d2 := dist(v, end2, depth, up, lg)
					if d1 >= d2 {
						if d1 > diam {
							end2 = v
							diam = d1
						}
					} else {
						if d2 > diam {
							end1 = v
							diam = d2
						}
					}
				}
				ptr--
			}
			diamByR[d-1] = diam
		}

		h := make([]int, maxDepth)
		for r := 0; r < maxDepth; r++ {
			h[r] = r - (diamByR[r]+1)/2
		}

		r := 0
		for x := 1; x <= n; x++ {
			for r < maxDepth && h[r] < x {
				r++
			}
			ans := maxDepth
			if r < maxDepth {
				ans = r
			}
			out = appendInt(out, ans)
			if x == n {
				out = append(out, '\n')
			} else {
				out = append(out, ' ')
			}
		}
	}

	_, _ = os.Stdout.Write(out)
}