1、利用层序遍历的产生的字符串来创建二叉树
/**
* 使用层序遍历的字符串创建二叉树
* @param treeInfo
* @return
*/
public static TreeNode generateTreeNodeSecond(String treeInfo) {
LinkedList<TreeNode> treeNodeLinkedList = new LinkedList<>();
if(StringUtils.isEmpty(treeInfo)) {
return null;
}
String[] stringList = treeInfo.split(",");
int i =0;
TreeNode root = new TreeNode(Integer.valueOf(stringList[i]));
treeNodeLinkedList.offer(root);
i++;
while(!treeNodeLinkedList.isEmpty()) {
TreeNode currentNode = treeNodeLinkedList.poll();
String temp = stringList[i];
if(temp.compareTo("null")!=0) {
currentNode.left = new TreeNode(Integer.valueOf(temp));
treeNodeLinkedList.offer(currentNode.left);
}
i++;
temp = stringList[i];
if(temp.compareTo("null")!=0) {
currentNode.right = new TreeNode(Integer.valueOf(temp));
treeNodeLinkedList.offer(currentNode.right);
}
i++;
if(i>= stringList.length) {
break;
}
}
return root;
}
2、层序遍历二叉树
public static List<List<Integer>> levelShow(TreeNode root) {
List<List<Integer>> listList = new ArrayList<>();
LinkedList<TreeNode> treeNodeLinkedList = new LinkedList<>();
treeNodeLinkedList.offer(root);
while(!treeNodeLinkedList.isEmpty()) {
int size = treeNodeLinkedList.size();
List<Integer> rowInfo = new ArrayList<>();
for(int i =0;i< size;i++) {
TreeNode treeNode = treeNodeLinkedList.poll();
// 读取数据
rowInfo.add(treeNode.value);
if(treeNode.left !=null) {
treeNodeLinkedList.offer(treeNode.left);
}
if(treeNode.right !=null) {
treeNodeLinkedList.offer(treeNode.right);
}
}
listList.add(rowInfo);
}
return listList;
}
3、获取树中节点的个数
/**
* 获取树中节点的个数
* @param root
* @return
*/
public int size(TreeNode root) {
if(root == null) {
return 0;
}
//递归遍历左子树
int a = size(root.left);
int b= size(root.right);
return a + b+ 1;
}
4、获取叶子节点的个数
/**
* 获取叶子节点的个数
* @param root
* @return
*/
public int getLeaf(TreeNode root) {
if(root == null) {
return 0;
}
if(root.left == null &&root.right == null) {
// 判断叶子左右节点是否为空，若为空则为叶子节点
return 1;
}
int getLeafLeft = getLeaf(root.left);
int getLeafRight = getLeaf(root.right);
return getLeafLeft + getLeafRight;
}
5、获取第k层的节点个数
/**
* 获取第k层的节点个数
* @param root
* @param k
* @return
*/
public static int getKLevelNode(TreeNode root,int k) {
if(root == null) {
return 0;
}
if(k == 1) {
return 1;
}
int getKLevelNodeLeft = getKLevelNode(root.left , k-1);
int getKLevelNodeRight = getKLevelNode(root.right , k -1);
return getKLevelNodeLeft +getKLevelNodeRight;
}
6、查询对应值的节点
public static TreeNode find(TreeNode root, int val) {
if(root == null) {
return null;
}
if(root.value == val) {
return root;
}
// 左子树查找val 使用对应的值
TreeNode leftTree = find(root.left, val);
// 接收值不为 null ,说明左子树已经查找到val
if(leftTree != null) {
return leftTree;
}
// 右子树查找val, 使用 rightTree 来接收
TreeNode rightTree = find(root.right ,val);
if(rightTree !=null) {
return rightTree;
}
// 走到这一步说明左右子树都没有找到val,直接返回null
return null;
}
7、是否是完全二叉树
public static boolean isCompleteTree(TreeNode root) {
LinkedList<TreeNode> queue = new LinkedList<>();
queue.offer(root);
boolean isStep1 = true;
while(!queue.isEmpty()) {
TreeNode node = queue.poll();
if(isStep1) {
if(node.left !=null && node.right != null) {
queue.offer(node.left);
queue.offer(node.right);
} else if(node.left !=null){
queue.offer(node.left);
isStep1 = false;
} else if(node.right !=null) {
return false;
} else {
isStep1 = false;
}
} else {
// 到达第二轮的时候，如果两者存在一个为空的就说明不是完全二叉树
if(node.left!=null || node.right !=null) {
return false;
}
}
}
return true;
}
8、两棵树是否完全相同
/**
* 检查两颗树是否相同
* @param p
* @param q
* @return
*/
public static boolean isSameTree(TreeNode p, TreeNode q) {
if( p== null&& q== null) {
return true;
}
if ( p == null || q == null) {
return false;
}
if(p.value == q.value) {
return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
}
return false;
}
9、一颗树是否是另一个树的子树
/**
* 判断是否是子树
* @param root
* @param subRoot
* @return
*/
public static boolean isSubTree(TreeNode root ,TreeNode subRoot) {
if(subRoot == null) {
return true;
}
if(root == null) {
return false;
}
// 递归判断
return isSameTree(root,subRoot) || isSubTree(root.left,subRoot) ||
isSubTree(root.right,subRoot);
}
10、打印从根节点到子节点的路径
/**
* 打印对应根节点到子节点的路径
* @param root
*/
public static void showTrace(TreeNode root) {
List<String> result = new ArrayList<>();
// 声明一个队列
LinkedList<TreeNode> queue = new LinkedList<>();
// 记录路径信息
LinkedList<String> stringLinkedList = new LinkedList<>();
queue.offer(root);
stringLinkedList.offer(root.value + "");
while(queue !=null) {
TreeNode tempNode =queue.poll();
String currentPath = stringLinkedList.poll();
// 说明不是子节点
if(tempNode.left == null && tempNode.right == null) {
result.add(currentPath);
}
if(tempNode.left != null) {
queue.offer(tempNode.left);
stringLinkedList.offer(currentPath + "->" + tempNode.left.value);
}
if(tempNode.right !=null) {
queue.offer(tempNode.right);
stringLinkedList.offer(currentPath + "->" + tempNode.right.value);
}
}
for(String item: result) {
System.out.println(item);
}
}