二叉树相关面试算法题（java实现）

二叉树可以说是最重要的非线性数据结构了，也是考察递归思想的重要手段。二叉树分为普通二叉树，排序二叉树，平衡二叉树，红黑树等等。
这里代码中我选择的是排序二叉树，有特殊性但又不失一般性，复杂度适中。

算法主要有（难度递增）：

• 各种遍历，其中要注意的是后序非递归遍历，层序遍历（带层数，例如问第3层有几个节点）。
• 常见的统计叶子，非叶子节点数，求深度，判断左右子树相似，判断平衡等。
• 根据先序与中序建立二叉树，或者中序与后序，或者层序与中序。
• 寻找一个树中两个任意节点的公共父节点。或者在树中寻找节点和为target的路径。

暂且列出了所有可以考察的点（除红黑树及堆）

import java.util.ArrayList;
import java.util.LinkedList;

class Node {
int key;
Node left;
Node right;

public Node(int key) {
this.key = key;
left = null;
right = null;
}

public Node() {
}

@Override
public String toString() {
// TODO Auto-generated method stub
return String.valueOf(key);
}
//构建二叉树
public static Node Array_to_Tree(int[] a) {
if (a.length == 0)
return null;
else {
Node root = new Node(a[0]);
for (int i = 1; i < a.length; i++)
insert_SortTree(new Node(a[i]), root);
return root;
}
}
//插入一个节点到树中，用于构建二叉树
public static void insert_SortTree(Node temp, Node root) {
if (temp.key > root.key) {
if (root.right == null)
root.right = temp;
else
insert_SortTree(temp, root.right);
} else if (temp.key < root.key) {
if (root.left == null)
root.left = temp;
else
insert_SortTree(temp, root.left);
}
}
//递归方式先序遍历
public static void visit_PreOrder(Node root) {
if (root == null)
return;
System.out.print(root.key + " ");
visit_PreOrder(root.left);
visit_PreOrder(root.right);
}
//递归方式中序遍历
public static void visit_InOrder(Node root) {
if (root == null)
return;
visit_InOrder(root.left);
System.out.print(root.key + " ");
visit_InOrder(root.right);
}
//递归方式后序遍历
public static void visit_PostOrder(Node root) {
if (root == null)
return;
visit_PostOrder(root.left);
visit_PostOrder(root.right);
System.out.print(root.key + " ");
}
//非递归方式先序遍历
public static void visit_PreOrder_NotRecursive(Node root) {
LinkedList<Node> linkedList = new LinkedList<>();
while (root != null || !linkedList.isEmpty()) {
while (root != null) {
System.out.print(root + " ");
linkedList.addLast(root);
root = root.left;
}
if (!linkedList.isEmpty()) {
root = linkedList.pollLast().right;
}
}
}
//非递归方式后序遍历
public static void visit_PostOrder_NotRecursive(Node root) {
if (root == null)
return;
LinkedList<Node> linkedList = new LinkedList<>();
LinkedList<Node> outputList = new LinkedList<>();
linkedList.addLast(root);
while (!linkedList.isEmpty()) {
Node node = linkedList.pollLast();
outputList.addLast(node);
if (node.left != null)
linkedList.addLast(node.left);
if (node.right != null)
linkedList.addLast(node.right);
}
while (!outputList.isEmpty())
System.out.print(outputList.pollLast() + " ");

}
//非递归方式中序遍历
public static void visit_InOrder_NotRecursive(Node root) {
LinkedList<Node> linkedList = new LinkedList<>();
while (root != null || !linkedList.isEmpty()) {
while (root != null) {
linkedList.addLast(root);
root = root.left;
}
if (!linkedList.isEmpty()) {
Node temp = linkedList.pollLast();
System.out.print(temp + " ");
root = temp.right;
}
}
}
//层序遍历
public static void visit_Level(Node root) {
if (root == null)
return;
else {
LinkedList<Node> linkedList = new LinkedList<>();
linkedList.addLast(root);
int level = 0, curLevelNode = 1, nextLevelNode = 0;
while (!linkedList.isEmpty()) {
Node temp = linkedList.pollFirst();
System.out.print(temp.key + "(" + level + ")" + " ");
curLevelNode--;
if (temp.left != null) {
linkedList.addLast(temp.left);
nextLevelNode++;
}
if (temp.right != null) {
linkedList.addLast(temp.right);
nextLevelNode++;
}
if (curLevelNode == 0) {
level++;
curLevelNode = nextLevelNode;
nextLevelNode = 0;
}
}

}
System.out.println();
}
//统计叶节点个数
public static int count_LeafNode(Node root) {
if (root == null)
return 0;
else if (root.left == null && root.right == null)
return 1;
else
return count_LeafNode(root.left) + count_LeafNode(root.right);
}
//统计非叶节点个数
public static int count_NotLeafNode(Node root) {
if (root == null || (root.left == null && root.right == null))
return 0;
else
return count_NotLeafNode(root.left) + count_NotLeafNode(root.right) + 1;

}
//统计所有节点个数
public static int count_AllNode(Node root) {
if (root == null)
return 0;
else
return count_AllNode(root.left) + count_AllNode(root.right) + 1;

}
// 计算第k层节点数
public static int count_LevelNode(Node root, int k) {
if (root == null)
return 0;
int depth = 0;
int current_LevelNode = 1;
int next_LevelNode = 0;
LinkedList<Node> linkedList = new LinkedList<>();
linkedList.addLast(root);
while (!linkedList.isEmpty()) {
Node temp = linkedList.pollFirst();
current_LevelNode--;
if (temp.left != null) {
linkedList.addLast(temp.left);
next_LevelNode++;
}
if (temp.right != null) {
linkedList.addLast(temp.right);
next_LevelNode++;
}
if (current_LevelNode == 0) {
current_LevelNode = next_LevelNode;
next_LevelNode = 0;
depth++;
}
if (depth == k) {
return current_LevelNode;
}
}

return 1;
}
// 计算各层节点数
public static int[] count_LevelNode(Node root) {
int[] count = new int[100];
if (root == null)
return null;
LinkedList<Node> linkedList = new LinkedList<>();
int start = 0, end = 0, level = 0, last = 1;
linkedList.addLast(root);
end++;
while (!linkedList.isEmpty()) {
Node temp = linkedList.pollFirst();
start++;
count[level]++;

if (temp.left != null) {
linkedList.addLast(temp.left);
end++;
}
if (temp.right != null) {
linkedList.addLast(temp.right);
end++;
}
if (start == last) {
last = end;
level++;
}
}
System.out.print("各层节点数为:");
for (int i = 0; i < level; i++) {
int j = count[i];
System.out.print(j + " ");
}
System.out.println();
return count;
}

private static int max(int a, int b) {
if (a > b)
return a;
else
return b;
}

private static int min(int a, int b) {
if (a < b)
return a;
else
return b;
}
//计算最大深度
public static int depth(Node root) {
if (root == null)
return 0;
else
return max(depth(root.left), depth(root.right)) + 1;

}
//树的最大枝长
public static int MaxLeaf(Node root) {
if (root == null)
return 0;
else
return max(MaxLeaf(root.left), MaxLeaf(root.right)) + 1;
}
//树的最小枝长
public static int MinLeaf(Node root) {
if (root == null)
return 0;
else
return min(MinLeaf(root.left), MinLeaf(root.right)) + 1;
}

//获取节点深度，用于判断该二叉树是否是平衡二叉树的函数
//注意及时return 剪枝手法
private static int getDepth(Node root){
if(root == null) return 0;
int left = getDepth(root.left);
if(left == -1) return -1;
int right = getDepth(root.right);
if(right == -1) return -1;
return Math.abs(left - right) >1 ? -1:1+Math.max(left, right);
}

//判断该二叉树是否是平衡二叉树
public static  boolean isBalanced(Node root) {
return getDepth(root) != -1;

}
//复制一颗树
public static Node CopyTree(Node root) {
if (root == null)
return null;
else {
Node temp = new Node(root.key);
temp.left = CopyTree(root.left);
temp.right = CopyTree(root.right);
return temp;
}
}
//交换左右子树
public static void Swap_Tree(Node root) {
if (root == null)
return;
else {
Node temp = root.left;
root.left = root.right;
root.right = temp;
Swap_Tree(root.left);
Swap_Tree(root.right);
}
}
// 判断两颗树是否相似
public static boolean Tree_Like(Node root1, Node root2) {
if (root1 == null && root2 == null)
return true;
else if (root1 != null && root2 != null && root1.key == root2.key)
return Tree_Like(root1.left, root2.left) && Tree_Like(root1.right, root2.right);
return false;
}

/**
*
* @param a
*            先序
* @param b
*            中序
* @param start_a
*            起始下标
* @param start_b
*            起始下标
* @param len
*            长度
* @return
*/
//根据先序序列和中序序列建立二叉树
public static Node createTreeBy_PreOrder_and_InOrder(int[] a, int[] b, int start_a, int start_b, int len) {
if (len <= 0)
return null;
Node root = new Node(a[start_a]);
int k = 0;
for (int i = 0; i < len; i++) {
if (b[i] == root.key) {
k = i;
break;
}
}
root.left = createTreeBy_PreOrder_and_InOrder(a, b, start_a + 1, start_b, k);
root.right = createTreeBy_PreOrder_and_InOrder(a, b, start_a + k + 1, start_b + k + 1, len - k - 1);
return root;
}
//根据后序序列和中序序列建立二叉树
public static Node createTreeBy_InOrder_and_PostOrder(int[] a, int[] b, int start_a, int start_b, int len) {
if (len <= 0)
return null;
Node root = new Node(b[start_b + len - 1]);
int k = 0;
for (int i = 0; i < len; i++) {
if (a[i] == root.key) {
k = i;
break;
}
}
root.left = createTreeBy_InOrder_and_PostOrder(a, b, start_a, start_b, k);
root.right = createTreeBy_InOrder_and_PostOrder(a, b, start_a + k + 1, start_b + k, len - k - 1);
return root;
}
//根据层序序列和中序序列建立二叉树
public static Node createTreeBy_InOrder_and_LevelOrder(int[] levelOrder, int[] inOrder, int start_inOrder,
int end_inOrder) {
if (start_inOrder >= end_inOrder)
return null;
Node root = null;
boolean stop = false;
int i = 0, j = start_inOrder;
for (i = 0; i < levelOrder.length && !stop; i++) {
for (j = start_inOrder; j < end_inOrder && !stop; j++) {
if (inOrder[j] == levelOrder[i]) {
root = new Node(inOrder[j]);
stop = true;
}
}
}
root.left = createTreeBy_InOrder_and_LevelOrder(levelOrder, inOrder, start_inOrder, j - 1);
root.right = createTreeBy_InOrder_and_LevelOrder(levelOrder, inOrder, j, end_inOrder);
return root;
}
//只访问叶子节点
public static void visit_LeafNode(Node root) {
if (root == null)
return;
if (root.right == null && root.left == null)
System.out.print(root + " ");
visit_LeafNode(root.left);
visit_LeafNode(root.right);
}

@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + key;
result = prime * result + ((left == null) ? 0 : left.hashCode());
result = prime * result + ((right == null) ? 0 : right.hashCode());
return result;
}

@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
Node other = (Node) obj;
if (key != other.key)
return false;
if (left == null) {
if (other.left != null)
return false;
} else if (!left.equals(other.left))
return false;
if (right == null) {
if (other.right != null)
return false;
} else if (!right.equals(other.right))
return false;
return true;
}
//根据值获取一个节点的引用
public static Node findNode(Node root, int key) {
if(root == null) return null;
if(root.key == key) return root;
Node res1 = findNode(root.left, key);
if(res1 != null) return res1;
Node res2 = findNode(root.right, key);
if(res2 != null) return res2;
return null;
}

/*
* 寻找一个节点到根节点的路径
* 为了偷懒使用了全局变量
*/
public static ArrayList<Node> arrayList_findPathNodeToRoot = new ArrayList<>();
private static ArrayList<Node> temp_findPathNodeToRoot = new ArrayList<>();
public static void findPathNodeToRoot(Node root, Node node) {
if(root == null) return;
temp_findPathNodeToRoot.add(root);
if(root == node) {
//注意这里要复制一份temp保存起来，防止在回溯过程中其中的引用被改变
arrayList_findPathNodeToRoot = new ArrayList<>(temp_findPathNodeToRoot);
return;}
findPathNodeToRoot(root.left, node);
findPathNodeToRoot(root.right, node);
temp_findPathNodeToRoot.remove(temp_findPathNodeToRoot.size()-1);
}

/*
* 寻找一个树中两个任意节点的公共父节点
* 思想是用刚才的"寻找一个节点到根节点的路径"
* 问题转化为求两条链表的第一个公共交点（这里是顺序表，但是差不多）
*/
public static Node findParent(Node root, Node node1, Node node2) {
//这里因为list是全局static变量，使用前要清空一下
arrayList_findPathNodeToRoot.clear();
temp_findPathNodeToRoot.clear();
findPathNodeToRoot(root, node1);
ArrayList<Node> list1 = new ArrayList<>(arrayList_findPathNodeToRoot);
arrayList_findPathNodeToRoot.clear();
temp_findPathNodeToRoot.clear();
findPathNodeToRoot(root, node2);
ArrayList<Node> list2 = new ArrayList<>(arrayList_findPathNodeToRoot);
//下面开始
for(int i = 0; i < list1.size() && i < list2.size(); i++) {
if(i == list1.size()-1 || i == list2.size()-1) return list1.get(i);
if(list1.get(i+1) != list2.get(i+1)) return list1.get(i);
}

return list1.get(list1.size()-1);
}

/*
* 寻找节点和为target的路径
* 为了偷懒使用了全局变量
*/
public static ArrayList<ArrayList<Node>> arrayList_findSumPath = new ArrayList<>();
public static ArrayList<Node> temp_findSumPath = new ArrayList<>();
public static void findSumPath(Node root, int target) {
if (root == null)
return;
temp_findSumPath.add(root);
target = target - root.key;
if(target == 0) {arrayList_findSumPath.add(new ArrayList<>(temp_findSumPath));}
findSumPath(root.left, target);
findSumPath(root.right, target);
temp_findSumPath.remove(temp_findSumPath.size()-1);
}

}

public class Main {

public static void main(String[] args) {
int[] a = { 5, 3, 1, 7, 2, 4, 6, 10 };
Node root = Node.Array_to_Tree(a);
System.out.print("中序遍历结果为:");
Node.visit_InOrder_NotRecursive(root);
System.out.println();
System.out.print("后序遍历结果为:");
Node.visit_PostOrder_NotRecursive(root);
System.out.println();
System.out.print("层次遍历结果为:");
Node.visit_Level(root);
System.out.print("从左到右遍历叶子节点结果为:");
Node.visit_LeafNode(root);
System.out.println();
System.out.print("所有节点总数为:" + Node.count_AllNode(root));
System.out.println("  叶子节点总数为:" + Node.count_LeafNode(root));
System.out.print("非叶子节点总数为:" + Node.count_NotLeafNode(root));
System.out.println("  最大枝长为:" + Node.MaxLeaf(root));
System.out.print("最小枝长为:" + Node.MinLeaf(root));
System.out.println("  数的高度为:" + Node.depth(root));
Node root2 = Node.CopyTree(root);
System.out.print("交换左右子树后层次遍历结果为:");
Node.Swap_Tree(root2);
Node.visit_Level(root2);
System.out.print("两个树是否相等:" + Node.Tree_Like(root, root2));
System.out.println("   第k层节点数为:" + Node.count_LevelNode(root, 2));
Node.count_LevelNode(root);
Node r1 = Node.createTreeBy_PreOrder_and_InOrder(new int[] { 2, 3, 4, 5, 6 }, new int[] { 4, 3, 5, 2, 6 }, 0, 0,
5);
System.out.print("由前序和中序确定的二叉树的后序遍历为 : ");
Node.visit_PostOrder(r1);
System.out.println();
Node r2 = Node.createTreeBy_InOrder_and_PostOrder(new int[] { 4, 3, 5, 2, 6 }, new int[] { 4, 5, 3, 6, 2 }, 0,
0, 5);
System.out.print("由中序和后序确定的二叉树的前序遍历为 : ");
Node.visit_PreOrder(r2);
System.out.println();
Node r3 = Node.createTreeBy_InOrder_and_LevelOrder(new int[] { 1, 2, 3, 4, 5 }, new int[] { 2, 4, 1, 5, 3 }, 0,
5);
System.out.print("由层序和中序确定的二叉树的后序遍历为 : ");
Node.visit_PostOrder(r3);
System.out.println();
System.out.print("路径和为12的路径有：");
Node.findSumPath(root, 12);
for (ArrayList<Node> temp : Node.arrayList_findSumPath) {
for(Node i : temp)
System.out.print(i.key+"  ");
System.out.print(" # ");
}
System.out.println();
System.out.println("获取值为1的节点："+Node.findNode(root, 1));
System.out.print("从根节点到节点2的路径为：");
Node.findPathNodeToRoot(root, Node.findNode(root, 2));
for (Node i : Node.arrayList_findPathNodeToRoot) {
System.out.print(i+" ");
}System.out.println();
System.out.print("节点2和节点6的公共父节点为："+Node.findParent(root, Node.findNode(root, 2), Node.findNode(root, 10)));
}

}