二叉树算法题

package code

import (
	"fmt"
	"math"
)

//无实际意义、讲其他操作绑定到一起而已
type BinaryTree struct {

}

//前序遍历
//前序遍历的顺序是  根 -----> 左子树 -----> 右子树
//中序遍历
//中序遍历的顺序是 左子树 -----> 根 ------> 右子树
//后序遍历
//后序遍历的顺序是 左子树 -----> 右子树 -----> 根

type TreeNode struct {
	Val   interface{}
	Left  *TreeNode
	Right *TreeNode
}

// 将类似[]interface{}{1, 2, 3, nil, nil, 4, 5}的数组转换成相应的Binary Tree节点
func (this *BinaryTree) TreeFromNullableArray(data []interface{}) *TreeNode {
	if len(data) == 0 {
		return nil
	}
	root := &TreeNode{}
	switch t := data[0].(type) {
	case int:
		root.Val = t
	case nil:
		return nil
	default:
		panic("Unknown element type")
	}

	queue := make([]*TreeNode, 1)
	queue[0] = root

	data = data[1:]
	for len(data) > 0 && len(queue) > 0 {
		node := queue[0]
		queue = queue[1:]

		// 左侧节点
		node.Left = this.newNodeFromData(data[0])
		if node.Left != nil {
			queue = append(queue, node.Left)
		}
		data = data[1:]

		// 右侧节点
		if len(data) > 0 {
			node.Right = this.newNodeFromData(data[0])
			if node.Right != nil {
				queue = append(queue, node.Right)
			}
			data = data[1:]
		}
	}
	return root
}

// 根据数据来创建一个新的节点
func (this *BinaryTree) newNodeFromData(val interface{}) *TreeNode {
	switch t := val.(type) {
	case int:
		return &TreeNode{Val: t}
	case nil:
		return nil
	default:
		panic("Unknown element type")
	}
}

// 前序遍历 根 ---> 左 --->右
func (self *BinaryTree) PreorderTraverse(node *TreeNode) {
	if node == nil {
		return
	} else {
		fmt.Print(node.Val, " ")
		self.PreorderTraverse(node.Left)
		self.PreorderTraverse(node.Right)
	}

}

// 中序遍历 左 ---> 根 --->右
func (self *BinaryTree) InorderTraverse(node *TreeNode) {
	if node == nil {
		return
	} else {
		self.InorderTraverse(node.Left)
		fmt.Print(node.Val, " ")
		self.InorderTraverse(node.Right)

	}
}

// 后序遍历 左 ----> 右 ---> 根
func (self *BinaryTree) PostTraverse(node *TreeNode) {
	if node == nil {
		return
	} else {
		self.PostTraverse(node.Left)
		self.PostTraverse(node.Right)
		fmt.Print(node.Val, " ")
	}
}

//  求 K 层节点个数
func (this *BinaryTree) GetKthNum(root *TreeNode, k int) int {
	if root == nil {
		return 0
	}
	if k == 1 {
		return 1
	}
	return this.GetKthNum(root.Left, k-1) + this.GetKthNum(root.Right, k-1)
}

// 求叶子节点个数
func (this *BinaryTree) GetLeavNum(root *TreeNode) int {
	if root == nil {
		return 0
	}
	if root.Left == nil && root.Right == nil {
		return 1
	}
	return this.GetLeavNum(root.Left) + this.GetLeavNum(root.Right)
}

// 计算二叉树节点个数
func (this *BinaryTree) GetNodeNum(root *TreeNode) int {
	if root == nil {
		return 0
	} else {
		return this.GetNodeNum(root.Left) + this.GetNodeNum(root.Right) + 1
	}
}

// 计算二叉树的深度
func (this *BinaryTree) GetDegree(root *TreeNode) int {
	if root == nil {
		return 0
	}
	var maxDegree = 0
	if this.GetDegree(root.Left) > this.GetDegree(root.Right) {
		maxDegree = this.GetDegree(root.Left)
	} else {
		maxDegree = this.GetDegree(root.Right)
	}
	return maxDegree + 1
}

// 判断是否平衡二叉树
func (this *BinaryTree) IsBalanced(root *TreeNode) bool {
	if root == nil {
		return true
	}
	lde := this.GetDegree(root.Left)
	rde := this.GetDegree(root.Right)
	flag := false
	if (math.Abs(float64(lde - rde))) <= 1 {
		flag = true
	} else {
		flag = false
	}
	return flag && this.IsBalanced(root.Left) && this.IsBalanced(root.Right)
}