总结

• 先序 中序 后序 遍历就能解决一些算法题。
• 层次遍历 使用队列。
• 从左子树 、右子树 获取答案，然后结合根节点来 计算答案。
• 前缀树，比Hashset更稳定。O(1)，只不过占内存。trie树。
• 递归。递归，递归。 到叶子节点收集答案。然后移除路径。

package main

import (
	"fmt"
	"math"

	. "github.com/isdamir/gotype"
)

// 将有序数组放置到二叉树中
// 取数组的中间元素为根节点。递归完成左右部分。

func arrayToTree(arr []int, start int, end int) *BNode {
	var root *BNode
	if end >= start {
		// root = new(BNode)
		root = NewBNode()
		mid := (start + end + 1) / 2
		root.Data = arr[mid]
		root.LeftChild = arrayToTree(arr, start, mid-1)
		root.RightChild = arrayToTree(arr, mid+1, end)
	}

	return root
}

// 层次遍历二叉树
func PrintTreeLayer(root *BNode) {
	// 考虑为空

	if root == nil {
		return
	}
	// 根节点入队
	q := &SliceQueue{}
	q.EnQueue(root)
	for !q.IsEmpty() {
		cur_node := q.DeQueue().(*BNode)
		fmt.Print(cur_node.Data, " ")
		if cur_node.LeftChild != nil {
			q.EnQueue(cur_node.LeftChild)
		}
		if cur_node.RightChild != nil {
			q.EnQueue(cur_node.RightChild)
		}
	}
}

// 计算一颗二叉树的最大子树和 。 后序遍历就好
var maxSum = math.MinInt64

func FindMaxSubTree(root *BNode, maxRoot *BNode) int {
	if root == nil {
		return 0
	}

	lmax := FindMaxSubTree(root.LeftChild, maxRoot)
	rmax := FindMaxSubTree(root.RightChild, maxRoot)

	sum := lmax + rmax + root.Data.(int)
	if sum > maxSum {
		maxSum = sum
		maxRoot.Data = root.Data
	}
	return sum
}

// 把二叉树转换为双向链表
//  PHead 1 2 3 PEnd  - root 4  5 6 7
var PHead *BNode
var PEnd *BNode

func InOrderBSTree(root *BNode) {

	if root == nil {
		return
	}
	// 转换左子树
	InOrderBSTree(root.LeftChild)

	root.LeftChild = PEnd // 4 -> 3
	if PEnd == nil {
		PHead = root //
	} else {
		PEnd.RightChild = root // 3 -> 4
	}

	PEnd = root //更新PEND 为 4
	//转换右子树
	InOrderBSTree(root.RightChild)

}

// 判断一个数组是否是二元查找树 后序遍历的序列
/**
1 3 2 5 7 6 4

根节点一定是4 。然后找到第一个大于根节点的5.5之前都要 <4 .
递归 左右部分
*/

func IsAfterOrder(arr []int, start int, end int) bool {
	if arr == nil {
		return false
	}
	root := arr[end]
	var i, j int

	// 1 3 2 5 7 6 4
	// 0 1 2 3 4 5 6
	for i = start; i < end; i++ {
		if arr[i] > root {
			break
		}
	}
	for j = i; j < end; j++ {
		if arr[j] < root {
			return false
		}
	}
	// start = 0   end = 6
	// i = 3
	// j = 5

	lresult := true
	rresult := true
	// 看 1 3 2 是不是
	if i > start {
		lresult = IsAfterOrder(arr, start, i-1)
	}
	// 看 5 7 6 是不是
	if j < end {
		rresult = IsAfterOrder(arr, i, end)
	}

	return lresult && rresult

}

// 找出排序二叉树上任意俩个节点的最近共同父节点

/**
方法一: 路径比对法。 root->n1 root->n2

*/

func GetPathFromRoot(root *BNode, node *BNode, s *SliceStack) bool {
	if root == nil {
		return false
	}

	if root.Data.(int) == node.Data.(int) {
		s.Push(root)
		return true
	}

	if GetPathFromRoot(root.LeftChild, node, s) || GetPathFromRoot(root.RightChild, node, s) {
		s.Push(root)
		return true
	}

	return false
}

func FindParentNode(root, node1, node2 *BNode) *BNode {
	s1 := NewSliceStack()
	s2 := NewSliceStack()

	GetPathFromRoot(root, node1, s1)
	GetPathFromRoot(root, node2, s2)

	var parent *BNode
	for t1, t2 := s1.Pop().(*BNode), s2.Pop().(*BNode); t1 != nil && t2 != nil && t1.Data.(int) == t2.Data.(int); {
		parent = t1
		t1 = s1.Pop().(*BNode)
		t2 = s2.Pop().(*BNode)
	}

	return parent

}

// 后序遍历法

func FindParentNodeReverse(root, node1, node2 *BNode) *BNode {

	if root == nil || root.Data.(int) == node1.Data.(int) || root.Data.(int) == node2.Data.(int) {
		return root
	}

	l := FindParentNodeReverse(root.LeftChild, node1, node2)
	r := FindParentNodeReverse(root.RightChild, node1, node2)

	if l == nil {
		return r
	} else if r == nil {
		return l
	} else {
		return root
	}

}

// 复制二叉树

func DupTree(root *BNode) *BNode {
	if root == nil {
		return nil
	}

	dupTree := NewBNode()

	dupTree.Data = root.Data
	dupTree.LeftChild = DupTree(root.LeftChild)
	dupTree.RightChild = DupTree(root.RightChild)

	return dupTree

}

//找出与输入整数相等的所有路径

// 先序遍历，到了叶子节点收集答案。然后要清除自己的路径

func FindRoad(root *BNode, num, sum int, v []int) {
	sum += root.Data.(int)

	v = append(v, root.Data.(int))

	if root.LeftChild == nil && root.RightChild == nil && sum == num {
		for _, v := range v {
			fmt.Print(v, " ")
		}
	}

	if root.LeftChild != nil {
		FindRoad(root.LeftChild, num, sum, v)
	}

	if root.RightChild != nil {
		FindRoad(root.RightChild, num, sum, v)
	}

	sum -= v[len(v)-1]
	v = v[:len(v)-1]

}

// 反转二叉树 。递归

func ReverseTree(root *BNode) {
	if root == nil {
		return
	}

	ReverseTree(root.LeftChild)
	ReverseTree(root.RightChild)

	tmp := root.LeftChild
	root.LeftChild = root.RightChild
	root.RightChild = tmp
}

// 二叉树 路径最大的和
var trieNode *TrieNode

func main() {
	// 二叉数 B  B+
	// data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	// fmt.Println("arr:", data)
	// root := arrayToTree(data, 0, len(data)-1)
	// PrintTreeMidOrder(root)
	// fmt.Println()
	// fmt.Println("层序遍历")
	// PrintTreeLayer(root)
	//
	// root := &BNode{}
	// n1 := &BNode{}
	// n2 := &BNode{}
	// n3 := &BNode{}
	// n4 := &BNode{}

	// root.Data = 6
	// n1.Data = 3
	// n2.Data = -7
	// n3.Data = -1
	// n4.Data = 9

	// root.LeftChild = n1
	// root.RightChild = n2
	// n1.LeftChild = n3
	// n1.RightChild = n4
	// mr := &BNode{}
	// FindMaxSubTree(root, mr)
	// fmt.Println("max sub tree:", maxSum, mr.Data)

	// data := []int{1, 2, 3, 4, 5, 6, 7}
	// root := arrayToTree(data, 0, len(data)-1)
	// InOrderBSTree(root)
	// for cur := PHead; cur != nil; cur = cur.RightChild {
	// 	fmt.Print(cur.Data, " ")
	// }
	// data := []int{1, 3, 9, 2, 7, 6, 4}
	// r := IsAfterOrder(data, 0, len(data)-1)
	// if r {
	// 	fmt.Print("是后序遍历")
	// }
	// data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	// r := arrayToTree(data, 0, len(data)-1)
	// n1 := r.LeftChild.LeftChild.LeftChild
	// n2 := r.LeftChild.RightChild

	// res := FindParentNode(r, n1, n2)

	// if res != nil {
	// 	fmt.Println("parent:", n1.Data, n2.Data, res.Data)
	// }

	// res2 := FindParentNodeReverse(r, n1, n2)
	// if res2 != nil {
	// 	fmt.Println("parent:", n1.Data, n2.Data, res2.Data)
	// }

	// data := []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
	// r := arrayToTree(data, 0, len(data)-1)
	// dr := DupTree(r)
	// PrintTreeMidOrder(r)
	// PrintTreeMidOrder(dr)

	r := NewBNode()
	n1 := NewBNode()
	n2 := NewBNode()
	n3 := NewBNode()
	n4 := NewBNode()

	r.Data = 6
	n1.Data = 3
	n2.Data = -7
	n3.Data = -1
	n4.Data = 9
	r.LeftChild = n1
	r.RightChild = n2
	n1.LeftChild = n3
	n1.RightChild = n4

	FindRoad(r, -1, 0, make([]int, 0))
}