1.判断一棵树是否是完全二叉树:
(1)完全二叉树该树中若存在右子树则必然存在左子树
(2)完全二叉树的节点编号必须和满二叉树一一对应(你有的节点必须和满二叉树节点编号相同)。
(3)对于完全二叉树来说一共存在三种节点:
A.度为2的节点有N个
B.度为1的节点最多有一个(恰好就是左树的那个一个节点)
C.度为0的节点有N个
(4)判断方法:
package bin_tree.leetcode;
import java.util.LinkedList;
import java.util.Queue;
public class IsCompleteTree {
public boolean isCompleteTree(TreeNode root) {
if (root == null) {
return true;
}
// 层序遍历判断二叉树
Queue<TreeNode> queue = new LinkedList<>();
queue.offer(root);
// 引入标志位,来区分当前遍历过程处在第一还是第二阶段
boolean isSecondStep = false;
while (!queue.isEmpty()) {
TreeNode cur = queue.poll();
if (!isSecondStep) {
// 此时处在第一阶段
if (cur.left != null && cur.right != null) {
// 当前cur左右子树全部都存在
queue.offer(cur.left);
queue.offer(cur.right);
}else if (cur.left == null && cur.right != null) {
// 此时只有右树没有左树,反例
return false;
}else if (cur.left != null) {
// 只有左树没有右树,此时cur是碰到的第一个只有左树的节点
// 切换状态
isSecondStep = true;
queue.offer(cur.left);
}else {
// 此时左树和右树全部为空,cur第一个碰到的叶子节点
isSecondStep = true;
}
}else {
// 此时处在第二阶段,第二阶段中的所有节点不可能有子树
// 有一个反例就false
if (cur.left != null || cur.right != null) {
return false;
}
}
}
// 遍历全部结束,没有找到反例
return true;
}
}
package bin_tree.NewCoder;
import java.util.Scanner;
// 根据先序遍历结果还原二叉树,输出中序遍历结果
public class KY11 {
private static class TreeNode {
char val;
TreeNode left;
TreeNode right;
public TreeNode(char val) {
this.val = val;
}
}
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
// 获取用户多组输入
while (scanner.hasNext()) {
// 字符串形式的先序二叉树结果
String line = scanner.next();
// str -> TreeNode
TreeNode root = build(line);
// 中序遍历二叉树,按照格式打印结点值
inOrder(root);
// 每个结果占一行
System.out.println();
}
}
private static void inOrder(TreeNode root) {
if (root == null)
return;
inOrder(root.left);
System.out.print(root.val +" ");
inOrder(root.right);
}
// 根据先序遍历结果字符串还原二叉树,返回构建后二叉树的根节点
private static TreeNode build(String line) {
return preOrderBuild(line);
}
// abc##de#g##f###
// str -> char
// 当前处理到哪个字符了
static int index = 0;
private static TreeNode preOrderBuild(String line) {
char c = line.charAt(index);
if (c == '#') {
return null;
}
TreeNode root = new TreeNode(c);
index ++;
root.left = preOrderBuild(line);
index ++;
root.right = preOrderBuild(line);
return root;
}
}
3.从二叉树与中序遍历序列构造二叉树
前序遍历:第一个节点一定是当前树的根节点,后序节点也是左树或右树的根节点。
中序遍历:左子树在根节点左侧,右子树在根节点右侧。
package bin_tree.leetcode;
/**
* 根据前序和中序遍历结果,还原二叉树
*/
public class Num105 {
//当前处理到前序遍历的哪个位置了
int index=0;
public TreeNode buildTree(int[] preorder, int[] inorder) {
return buildTreeInternal(preorder, inorder, 0, inorder.length);
}
/**
* 根据传入的前序遍历和中序遍历的部分区间
* [left,right) 表示当前节点中序遍历结果
* 左区间连接到根节点左侧
* 右区间连接到根节点右侧
* @param preOrder 前序遍历结果
* @param inOrder 中序遍历结果
* @param left
* @param right
* @return
*/
public TreeNode buildTreeInternal(int[] preOrder,int[] inOrder,int left,int right){
//边界
if(left >=right){
//空区间,说明此时中序结果为空,空树
return null;
}
if(index >= preOrder.length){
//所有的节点已经全部处理完毕
return null;
}
//此时前序结果还有没处理的元素,从Index取得一个元素构建根节点
TreeNode root=new TreeNode(preOrder[index]);
//继续处理下一个节点
index++;
//处理左树
//拿着这个root.val去中序遍历中找到该值对应的索引pos
int pos=find(inOrder,left,right,root.val);
//左树
root.left=buildTreeInternal(preOrder,inOrder,left,pos);
//右树
root.right=buildTreeInternal(preOrder,inOrder,pos+1,right);
return root;
}
/**
* 在当前中序遍历中寻找root.val对应的索引值
* @param inOrder
* @param left
* @param right
* @param val
* @return
*/
private int find(int[] inOrder, int left, int right, int val) {
for (int i = left; i <right ; i++) {
if (inOrder[i]==val){
return i;
}
}
return -1;
}
}
package bin_tree.leetcode;
import java.util.HashMap;
import java.util.Map;
/**
* 后序 + 中序
**/
public class Num106 {
// 存储中序遍历的对应的值和索引
Map<Integer,Integer> map = new HashMap<>();
public TreeNode buildTree(int[] inorder, int[] postorder) {
// 将后序遍历结果反转
int[] preOrder = reverse(inorder,postorder);
return buildTreeInternal(preOrder,inorder,0,inorder.length);
}
int index = 0;
public TreeNode buildTreeInternal(int[] preOrder,int[] inOrder,int left,int right) {
if(left >= right) {
return null;
}
if (index >= preOrder.length) {
return null;
}
TreeNode root = new TreeNode(preOrder[index]);
index ++;
int pos = map.get(root.val);
root.right = buildTreeInternal(preOrder,inOrder,pos + 1,right);
root.left = buildTreeInternal(preOrder,inOrder,left,pos);
return root;
}
private int[] reverse(int[] inorder,int[] postorder) {
int[] ret = new int[postorder.length];
for (int i = 0; i < ret.length; i++) {
ret[i] = postorder[ret.length - 1 - i];
}
for (int i = 0; i < inorder.length; i++) {
map.put(inorder[i],i);
}
return ret;
}
}
package bin_tree.leetcode;
/**
* 找二叉树的最近公共祖先
**/
public class Num236 {
TreeNode lca;
public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
if (root == null) {
return null;
}
// 从根节点出发进行后序遍历,找到lca(p和q出现在三个位置的两个)
find(root,p,q);
return lca;
}
// 在以root为根节点的二叉树中,是否能同时找到p和q
private boolean find(TreeNode root, TreeNode p, TreeNode q) {
if (root == null) {
return false;
}
int left = find(root.left,p,q) ? 1 : 0;
int right = find(root.right,p,q) ? 1 : 0;
int mid = (root == p || root == q) ? 1 : 0;
if (left + right + mid == 2) {
lca = root;
return true;
}
return (left + right + mid) > 0;
}
}
package bin_tree.leetcode;
/**
* 二叉树转为字符串
**/
public class Num606 {
StringBuilder sb = new StringBuilder();
// "1(2(4))(3)"
public String tree2str(TreeNode root) {
if (root == null) {
return "";
}
preOrder(root);
return sb.toString();
}
private void preOrder(TreeNode root) {
if (root == null) {
return;
}
// "1(2(4))(3)"
sb.append(root.val);
if (root.left != null) {
sb.append("(");
// 先序遍历左树
preOrder(root.left);
sb.append(")");
}else {
// 左空,判断右树是否为空
if (root.right != null) {
sb.append("()");
}
}
if (root.right != null) {
sb.append("(");
preOrder(root.right);
sb.append(")");
}
}
}
package bin_tree.NewCoder;
import bin_tree.leetcode.TreeNode;
/**
* 将二分搜索树转为排序的双向链表
**/
public class ConvertTree2LinkedList {
// 传入一个BST的根节点,就可以将其转为双向链表,且返回链表头
public TreeNode Convert(TreeNode pRootOfTree) {
if(pRootOfTree == null ||(pRootOfTree.left == null &&
pRootOfTree.right == null)) {
return pRootOfTree;
}
//先转换左子树
TreeNode left = Convert(pRootOfTree.left);
//将左子树的尾部与根节点连接
TreeNode leftTail = left;
while (leftTail != null && leftTail.right != null) {
leftTail = leftTail.right;
}
//此时leftTail指向左链表的尾部
//连接左链表尾部和根节点
//判空
if (leftTail != null) {
leftTail.right = pRootOfTree;
pRootOfTree.left = leftTail;
}
//继续转化右子树
TreeNode right = Convert(pRootOfTree.right);
//将根节点和右子树连接起来
if (right != null) {
right.left = pRootOfTree;
pRootOfTree.right = right;
}
return left == null ? pRootOfTree : left;
}
}