文心一言 VS 讯飞星火 VS chatgpt （296）-- 算法导论21.4 5题

package main

import(
"fmt"
)

// TreeNode 定义树的节点
typeTreeNodestruct{
Valueint
Rankint
Parent*TreeNode
}

// Level 计算节点的深度（从根到节点的路径长度）
func Level(node *TreeNode)int{
if node ==nil{
return0
}
    level :=0
for node.Parent!=nil{
        node = node.Parent
        level++
}
return level
}

// 示例：验证从给定节点到根节点的路径上，节点的深度是单调递减的
func VerifyLevelsDecreasing(root *TreeNode, start *TreeNode)bool{
if start ==nil|| start.Parent==nil{
returntrue// 没有足够的信息来验证
}
    currentLevel :=Level(start)
for node := start.Parent; node !=nil; node = node.Parent{
        nextLevel :=Level(node)
if currentLevel < nextLevel {
returnfalse// 发现深度递增，不符合预期
}
        currentLevel = nextLevel
}
returntrue// 所有验证的路径上，深度都是单调递减的
}

func main(){
// 构建一个简单的树来测试
    root :=&TreeNode{Value:1,Rank:0}
    child1 :=&TreeNode{Value:2,Rank:1,Parent: root}
    child2 :=&TreeNode{Value:3,Rank:2,Parent: root}
    grandchild :=&TreeNode{Value:4,Rank:3,Parent: child1}

// 验证
    fmt.Println(VerifyLevelsDecreasing(root, grandchild))// 应该输出 true
}

package main

import"fmt"

typeNodestruct{
    rank int
    p    *Node
}

func level(x *Node)int{
if x ==nil|| x.rank ==0{
return0
}
return1+ level(x.p)
}

func main(){
// 创建一个简单的树结构
    root :=&Node{rank:3, p:nil}
    child1 :=&Node{rank:2, p: root}
    child2 :=&Node{rank:1, p: child1}

// 测试level函数
    fmt.Println("Level of root:", level(root))// 输出：Level of root: 3
    fmt.Println("Level of child1:", level(child1))// 输出：Level of child1: 2
    fmt.Println("Level of child2:", level(child2))// 输出：Level of child2: 1
}

type TreeNodestruct{
    rank int
    level int
    left *TreeNode
    right *TreeNode
}

func main(){
    root :=&TreeNode{rank:0, level:0}
    root.left =&TreeNode{rank:1, level:1}
    root.right =&TreeNode{rank:2, level:1}
    root.left.left =&TreeNode{rank:2, level:2}
    root.left.right =&TreeNode{rank:3, level:2}

// 检查从根到左子节点的左子节点的路径
    path :=[]*TreeNode{root, root.left, root.left.left}
for i :=1; i <len(path); i++{
if path[i].rank <= path[i-1].rank {
            fmt.Println("Rank is not strictly increasing.")
return
}
if path[i].level > path[i-1].level {
            fmt.Println("Level is not monotonic increasing.")
return
}
}
    fmt.Println("Rank is strictly increasing, but level is not monotonic increasing.")
}

package main
import(
"fmt"
)
typeNodestruct{
Valueinterface{}
Children[]*Node
Rankint
Parent*Node
}
func level(node *Node)int{
if node ==nil{
return-1
}
// 如果节点是根节点，则级别为0
if node.Parent==nil{
return0
}
// 否则，级别为父节点的级别加1
return level(node.Parent)+1
}
func checkRankAndLevel(node *Node){
if node ==nil{
return
}
// 检查每个节点的秩和级别的关系
for _, child :=range node.Children{
if child.Rank>0&& child.Parent!=nil{
if child.Rank> child.Parent.Rank{
                fmt.Printf("Error at node %v: rank %d is greater than parent's rank %d\n", child.Value, child.Rank, child.Parent.Rank)
}
if level(child)> level(child.Parent){
                fmt.Printf("Error at node %v: level %d is greater than parent's level %d\n", child.Value, level(child), level(child.Parent))
}
}
        checkRankAndLevel(child)
}
}
func main(){
// 构建树
    root :=&Node{Value:"root",Rank:0,Parent:nil}
    child1 :=&Node{Value:"child1",Rank:1,Parent: root}
    child2 :=&Node{Value:"child2",Rank:2,Parent: root}
    child3 :=&Node{Value:"child3",Rank:1,Parent: child1}
// 设置子节点关系
    root.Children=[]*Node{child1, child2}
    child1.Children=[]*Node{child3}
// 检查树中每个节点的秩和级别是否满足条件
    checkRankAndLevel(root)
}

type Nodestruct{
    children []*Node
}

func calculateLevel(node *Node, parentLevel int)int{
if node ==nil{
return parentLevel
}
    level := parentLevel +1
for _, child :=range node.children {
        level = max(level, calculateLevel(child, parentLevel+1))
}
return level
}

func max(a, b int)int{
if a > b {
return a
}
return b
}

package main

import"fmt"

typeNodestruct{
    rank  int
    parent *Node
}

func level(node *Node)int{
if node.parent ==nil{
return0
}
return1+ level(node.parent)
}

func main(){
    parentNode :=&Node{rank:0, parent:nil}
    childNode :=&Node{rank:1, parent: parentNode}

    fmt.Println("Level of parent node:", level(parentNode))
    fmt.Println("Level of child node:", level(childNode))

if childNode.rank >0&& childNode.parent !=nil{
if level(childNode)<= level(childNode.parent){
            fmt.Println("Dante 教授的观点成立：level(childNode) <= level(childNode.parent)")
}else{
            fmt.Println("Dante 教授的观点不成立")
}
}
}

package main

import"fmt"

// 定义树节点结构
typeTreeNodestruct{
    rank int// 节点的秩
    level int// 节点的层级
    parent *TreeNode// 父节点指针
}

// 检查节点是否满足条件
func checkCondition(node *TreeNode)bool{
if node ==nil|| node.parent ==nil{
returntrue// 如果是根节点或空节点，条件自然满足
}
// 检查节点的层级是否小于等于其父节点的层级
return node.level <= node.parent.level
}

func main(){
// 创建示例树结构
    root :=&TreeNode{rank:1, level:1}
    child :=&TreeNode{rank:2, level:2, parent: root}
    grandchild :=&TreeNode{rank:3, level:3, parent: child}

// 检查节点是否满足条件
    fmt.Println("Root condition satisfied:", checkCondition(root))// 应输出 true
    fmt.Println("Child condition satisfied:", checkCondition(child))// 应输出 true
    fmt.Println("Grandchild condition satisfied:", checkCondition(grandchild))// 应输出 true
}

type Nodestruct{
    rank int
    level int
    parent *Node
}

func (n *Node)IsRoot()bool{
return n.parent ==nil
}

func (n *Node)Level()int{
if n.IsRoot(){
return0
}
return n.parent.Level()+1
}

func (n *Node)ValidateRankAndLevel()bool{
if n.IsRoot(){
return n.rank >0&& n.level ==0
}

if n.rank <= n.parent.rank {
returnfalse// 秩不是严格递增的
}

if n.Level()<= n.parent.Level(){
returnfalse// 级不是单调递增的
}

returntrue
}