package main

import (
	"bytes"
	"io"
	"math/bits"
	"os"
)

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data}
}

func (fs *FastScanner) NextInt() int {
	n := len(fs.data)
	i := fs.idx
	for i < n && (fs.data[i] < '0' || fs.data[i] > '9') {
		i++
	}
	val := 0
	for i < n && fs.data[i] >= '0' && fs.data[i] <= '9' {
		val = val*10 + int(fs.data[i]-'0')
		i++
	}
	fs.idx = i
	return val
}

var up [][]int
var dep []int
var lg int

func lca(u, v int) int {
	if dep[u] < dep[v] {
		u, v = v, u
	}
	diff := dep[u] - dep[v]
	k := 0
	for diff > 0 {
		if diff&1 != 0 {
			u = up[k][u]
		}
		diff >>= 1
		k++
	}
	if u == v {
		return u
	}
	for k = lg - 1; k >= 0; k-- {
		if up[k][u] != up[k][v] {
			u = up[k][u]
			v = up[k][v]
		}
	}
	return up[0][u]
}

func dist(u, v int) int {
	w := lca(u, v)
	return dep[u] + dep[v] - 2*dep[w]
}

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

func main() {
	fs := NewFastScanner()
	t := fs.NextInt()
	var out bytes.Buffer

	for ; t > 0; t-- {
		n := fs.NextInt()

		head := make([]int, n+1)
		for i := range head {
			head[i] = -1
		}
		to := make([]int, 2*(n-1))
		next := make([]int, 2*(n-1))
		edgeIdx := 0

		for i := 0; i < n-1; i++ {
			u := fs.NextInt()
			v := fs.NextInt()
			to[edgeIdx] = v
			next[edgeIdx] = head[u]
			head[u] = edgeIdx
			edgeIdx++
			to[edgeIdx] = u
			next[edgeIdx] = head[v]
			head[v] = edgeIdx
			edgeIdx++
		}

		dep = make([]int, n+1)
		parent := make([]int, n+1)
		stack := make([]int, 1, n)
		stack[0] = 1
		h := 0

		for len(stack) > 0 {
			u := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			for e := head[u]; e != -1; e = next[e] {
				v := to[e]
				if v == parent[u] {
					continue
				}
				parent[v] = u
				dep[v] = dep[u] + 1
				if dep[v] > h {
					h = dep[v]
				}
				stack = append(stack, v)
			}
		}

		cnt := make([]int, h+1)
		for v := 2; v <= n; v++ {
			cnt[dep[v]]++
		}
		start := make([]int, h+2)
		for d := 1; d <= h; d++ {
			start[d+1] = start[d] + cnt[d]
		}
		ord := make([]int, n-1)
		cur := make([]int, h+1)
		copy(cur, start[:h+1])
		for v := 2; v <= n; v++ {
			d := dep[v]
			ord[cur[d]] = v
			cur[d]++
		}

		lg = bits.Len(uint(n))
		up = make([][]int, lg)
		up[0] = parent
		for k := 1; k < lg; k++ {
			arr := make([]int, n+1)
			prev := up[k-1]
			for v := 1; v <= n; v++ {
				arr[v] = prev[prev[v]]
			}
			up[k] = arr
		}

		g := make([]int, h)
		active := false
		a, b, diam := 0, 0, 0

		for d := h; d >= 1; d-- {
			for i := start[d]; i < start[d+1]; i++ {
				u := ord[i]
				if !active {
					active = true
					a, b, diam = u, u, 0
				} else {
					da := dist(u, a)
					db := dist(u, b)
					if da >= db {
						if da > diam {
							b = u
							diam = da
						}
					} else {
						if db > diam {
							a = u
							diam = db
						}
					}
				}
			}
			g[d-1] = diam
		}

		r := 0
		for x := 1; x <= n; x++ {
			for r < h && r-(g[r]+1)/2 < x {
				r++
			}
			ans := h
			if r < h {
				ans = r
			}
			if x > 1 {
				out.WriteByte(' ')
			}
			writeInt(&out, ans)
		}
		out.WriteByte('\n')
	}

	os.Stdout.Write(out.Bytes())
}