Golang如何优化和格式化短小但丑陋的代码

Golang如何优化和格式化短小但丑陋的代码

func (n *Node) updateHeight() {
	if n == nil {
		return
	}

	leftHeight := -1
	if n.Left != nil {
		leftHeight = n.Left.Heigth
	}

	rightHeight := -1
	if n.Right != nil {
		rightHeight = n.Right.Heigth
	}

	n.Heigth = 1 + leftHeight

	if n.Heigth < 1+rightHeight {
		n.Heigth = 1 + rightHeight
	}
}

这段代码看起来比需要的要冗长一些。有没有什么不同的写法建议？它只是根据子节点更新二叉树中节点的高度。


更多关于Golang如何优化和格式化短小但丑陋的代码的实战教程也可以访问 https://www.itying.com/category-94-b0.html

10 回复

阅读这篇文章，你就会明白我的观点 图片

更多关于Golang如何优化和格式化短小但丑陋的代码的实战系列教程也可以访问 https://www.itying.com/category-94-b0.html


你好，

更加简洁了。

顺便问一下，在你的项目中如何处理在多个包中使用 max 函数的情况（类似于 contains(s string, slice []string)）？

你是创建一个辅助包，还是每次使用时都复制这个方法？

你好，

你的想法很好，感谢分享。

不过我的方法主要是更新高度字段，它会在插入节点时使用，也会在其他情况（比如删除）下使用。

因此我需要重点重构它以提升可读性，欢迎提出任何建议。

你好 @root666

这是目前最好的版本，我非常喜欢。不过我在想，与其将辅助变量命名为 h，不如称它为 maxChildHeight。

实际上我很少给辅助变量起很长的名字，只是为了说明它的作用，但在这个案例中，我觉得这有助于更轻松地理解方法。

你对此有什么看法？

这个方案如何

func (n *Node) updateHeight() {
	if n == nil {
		return
	}
	h := -1
	if n.Left != nil {
		h = n.Left.Height
	}
	if n.Right != nil && h.Right.Height > h {
		h = n.Right.Height
	}
	n.Height = h + 1
}

以下建议如何：

func (n *Node) Height() int {
	if n == nil {
		return -1
	}
	return max(n.Left.Height(), n.Right.Height()) + 1
}

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

现在你不再需要 updateHeight()，直接使用 Height() 即可。

这对你有帮助吗？

func (tree *Tree) insert(val int) *Tree {
	if tree == nil {
		return &Tree{nil, val, 0, nil}
	}
	tree.Height++ // increase at every insert the height of the node.
	if tree.Value > val {
		tree.Left = tree.Left.insert(val)
		return tree
	}
	tree.Right = tree.Right.insert(val)
	return tree
}

JOhn_uart:

顺便问一下，在你的项目中如何处理在多个包中使用max函数的问题（类似于contains(s string, slice []string)这种情况）？

你是创建一个辅助包，还是在每个使用的地方都复制这个方法？

常见的做法是创建一个 tools 包来存放这类常用的内部函数。

switch 语句是否适用？您需要处理多维条件。

func (n *Node) updateHeight() {
        switch {
        case n.Left == nil && n.Right == nil: 
                n.Height = 0
        case n.Left == nil && n.Right != nil:
                n.Height = n.Right.Height
        case n.Left != nil && n.Right == nil:
                fallthrough
        case n.Left.Height > n.Right.Height:
                n.Height = n.Left.Height
        default:
                n.Height = n.Right.Height
        }
}

注意：每个 case 的顺序很重要。

测试地址：Go Playground - The Go Programming Language

以下是针对这段代码的优化和格式化版本。通过使用条件运算符和简化逻辑，可以减少代码行数并提高可读性：

func (n *Node) updateHeight() {
    if n == nil {
        return
    }

    leftHeight := -1
    if n.Left != nil {
        leftHeight = n.Left.Heigth
    }

    rightHeight := -1
    if n.Right != nil {
        rightHeight = n.Right.Heigth
    }

    n.Heigth = max(1+leftHeight, 1+rightHeight)
}

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

如果允许使用Go 1.21或更高版本的内置max函数，可以进一步简化：

func (n *Node) updateHeight() {
    if n == nil {
        return
    }

    leftHeight := -1
    if n.Left != nil {
        leftHeight = n.Left.Heigth
    }

    rightHeight := -1
    if n.Right != nil {
        rightHeight = n.Right.Heigth
    }

    n.Heigth = max(1+leftHeight, 1+rightHeight)
}

另一种更紧凑的写法，使用条件运算符处理空节点：

func (n *Node) updateHeight() {
    if n == nil {
        return
    }

    leftHeight := -1
    if n.Left != nil {
        leftHeight = n.Left.Heigth
    }

    rightHeight := -1
    if n.Right != nil {
        rightHeight = n.Right.Heigth
    }

    n.Heigth = 1 + max(leftHeight, rightHeight)
}

这些版本消除了原代码中的条件判断，直接使用max函数选择较大的高度值，使逻辑更清晰。注意：原代码中的字段名Heigth疑似拼写错误，应为Height。

回到顶部