名词解释

结点：树的基本数据结构，包含数据和指向子结点的指针

子树：子结点的同义词

结点的度：一个节点拥有子树的个数称为结点的度

树的度：树中所有结点的度的最大值

叶子结点：没有子树的结点/度为0的结点

分支结点：有子树的结点/度不为0的结点，也称非叶子节点

节点的层次：从根节点开始，根节点层次为1，根节点的子节点层次为2，以此类推，某节点层次为n，则他的子节点层次为n+1

树的深度：树深，又称树的高度，树中所有结点的层次的最大值即为树的深度

二叉树每个节点存储一个数据，同时存储一个左子树地址和一个右子树地址。

一个节点左子树中所有节点的值都小于本节点的值，一个节点右子树中所有节点的值都大于本节点的值；二叉树中所有节点皆遵循此规则。

下面是二叉树结构的示意图二叉树.png

前序遍历：先遍历本节点，再前序遍历左节点，再前序遍历右节点

中序遍历【因二叉树特性，中序遍历即是按顺序从小到大遍历】：先中序遍历左节点，再遍历本节点，再中序遍历右节点

后续遍历：先后续遍历左节点，再后续遍历右节点，再遍历本节点

层次遍历：先遍历第一层，再遍历第二层，以此类推；同一层内先遍历左边的结点再遍历右边的结点

下面上一下二叉树的代码

package binaryTree

import "fmt"

type node struct {
	left   *node
	right  *node
	v      int
}

var root *node

func (n *node) print() {
	fmt.Print(n.v, " ")
}

func Add(d int) {
	if root == nil {
		root = &node{
			left:   nil,
			right:  nil,
			v:      d,
		}
		return
	}
	root.addChack(d)
}

// addChack 递归调用函数，如果传入的值在树中已经存在则会被丢弃
func (n *node) addChack(d int) {
	if d < n.v {
		if n.left == nil {
			n.left = &node{
				left:   nil,
				right:  nil,
				v:      d,
			}
		}
		n.left.addChack(d)
	} else if d > n.v {
		if n.right == nil {
			n.right = &node{
				left:   nil,
				right:  nil,
				v:      d,
			}
		}
		n.right.addChack(d)
	}
}

// preorderTraversal 前序遍历
func(n *node) preorderTraversal() {
	n.print()
	if n.left != nil {
		n.left.preorderTraversal()
	}
	if n.right != nil {
		n.right.preorderTraversal()
	}
}

// inorderTraverse 中序遍历
func(n *node) inorderTraverse() {
	if n.left != nil {
		n.left.inorderTraverse()
	}
	n.print()
	if n.right != nil {
		n.right.inorderTraverse()
	}
}

// postorderTraversal 后序遍历
func(n *node) postorderTraversal() {
	if n.left != nil {
		n.left.postorderTraversal()
	}
	if n.right != nil {
		n.right.postorderTraversal()
	}
	n.print()
}

// find 查找某个节点
func(n *node) find(v int) *node {
	if n.v == v {
		return n
	}
	if n.left != nil {
		if temp :=  n.left.find(v); temp != nil {
			return temp
		}
	}
	if n.right != nil {
		if temp :=  n.right.find(v); temp != nil {
			return temp
		}
	}
	return nil
}

// levelTraversal 层次遍历
func(n *node) levelTraversal()  {
	nodes := []*node{n}
	for len(nodes) > 0 {
		nowNode := nodes[0]
		nodes = nodes[1:]
		nowNode.print()
		if nowNode.left != nil {
			nodes = append(nodes, nowNode.left)
		}
		if nowNode.right != nil {
			nodes = append(nodes, nowNode.right)
		}
	}
}

package binaryTree

import "testing"

func TestAdd(t *testing.T)  {
	Add(2)
	Add(8)
	Add(10)
	Add(6)
	Add(4)
	Add(1)
	Add(7)
	Add(3)
	Add(5)
	Add(9)

	println("中序遍历")
	root.inorderTraverse()
	println("\n前序遍历")
	root.preorderTraversal()
	println("\n后序遍历")
	root.postorderTraversal()
	println("\n层次遍历")
	root.levelTraversal()
}

这！就是二叉树【go实现

名词解释