二叉树：
static class Node {
private int data;
private Node left;
private Node right;
public Node() {
}
public Node(int data) {
this.data = data;
}
public int getData() {
return data;
}
public void setData(int data) {
this.data = data;
}
public Node getLeft() {
return left;
}
public void setLeft(Node left) {
this.left = left;
}
public Node getRight() {
return right;
}
public void setRight(Node right) {
this.right = right;
}1、分别先序、中序、后序遍历二叉树
递归：
思路：注意与打印位置的关系
先序：
public static void method(Node node) {
if (node == null) {
return;
}
System.out.println(node.data);
method(node.left);
method(node.right);
}中序：
public static void method(Node node) {
if (node == null) {
return;
}
method(node.left);
System.out.println(node.data);
method(node.right);
}后序：
public static void method(Node node) {
if (node == null) {
return;
}
method(node.left);
method(node.right);
System.out.println(node.data);
}非递归：
先序：
思路：通过栈，当前节点的右节点压栈，输出当前节点，当前指向左节点。左边为空时出栈
public static void method(Node head) {
if (head == null) {
return;
}
Stack stack = new Stack();
Node node = head;
while (node != null || stack.size() != 0) {
if (node == null) {
node = (Node) stack.pop();
}
System.out.println(node.data);
if (node.right != null) {
stack.add(node.right);
}
node = node.left;
}
}中序：
思路：将左节点全部压入栈中，弹出时指向弹出节点的右节点
如果当前节点的左节点不为空，压入栈中，且当前节点指向左节点。
为空的话，指向栈中弹出节点，输出当前节点，并指向当前节点的右节点。
public static void method(Node head) {
if (head == null) {
return;
}
Stack stack = new Stack();
Node node = head;
while (node != null || stack.size() != 0) {
if (node != null) {
stack.add(node);
node = node.left;
} else {
node = (Node) stack.pop();
System.out.println(node.data);
node = node.right;
}
}
}后序：
思路：后序的顺序是 “ 左右中”， 反转过来也就是 “ 中左右” 与先序类似，所以方法就是先用类似先序的方法 以 “ 中左右” 的顺序压入栈中，再用另一个栈反转。
public static void method(Node head) {
if (head == null) {
return;
}
Node node = head;
Stack<Node> stack = new Stack();
Stack<Node> result = new Stack();
while (node != null || stack.size() != 0) {
if (node == null) {
node = stack.pop();
}
result.add(node);
if (node.left != null) {
stack.add(node.left);
}
node = node.right;
}
while (result.size() != 0) {
System.out.println(result.pop().data);
}
}2、按层遍历二叉树。
思路：
输出当前节点，并将当前节点的左右节点都放入队列中
public static void method(Node head) {
Queue<Node> queue = new ArrayBlockingQueue<>(100);
Node node = head;
while (queue.size() != 0 || node != null) {
System.out.println(node.getData());
if (node.left != null) {
queue.add(node.left);
}
if (node.right != null) {
queue.add(node.right);
}
node = queue.poll();
}
}
3、求一个节点的后继（中序遍历时，当前节点的下一个节点）。二叉树结构如下：有一个parent指针指向父节点。
public class Node {
public int value;
public Node left;
public Node right;
public Node parent;
public Node(int data) { this.value = data; }
}思路：
1、当前节点有右节点的话，后继就是当前节点右子树的最左节点。
2、否则的话，就找当前子树是左子树（不是的话继续向上找）的父节点。
public static Node method(Node head) {
Node node = head;
// 返回右子树的最左子树
if (node.right != null) {
node = node.right;
while (node.left != null) {
node = node.left;
}
return node;
}
// 返回当前子树为左子树的父节点
while (node.parent != null) {
if (node == node.parent.left) {
return node.parent;
}
node = node.parent;
}
return null;
}4、二叉树的序列化和反序列化。
（1）先序：
非递归 先序 序列化
思路：类比先序遍历。
public static String method(Node head) {
StringBuilder stringBuilder = new StringBuilder();
Node node = head;
Stack<Node> stack = new Stack<>();
while (stack.size() != 0 || node != null) {
if (node == null) {
stringBuilder.append("null_");
node = stack.pop();
}
stringBuilder.append(node.getData() + "_");
if (node.right != null) {
stack.add(node.right);
} else {
stringBuilder.append("null_");
}
node = node.left;
}
return stringBuilder.toString();
}1_2_4_null_null_5_8_null_null_9_null_null_3_6_null_null_7_null_递归 先序 序列化
public static String method2(Node node) {
StringBuilder stringBuilder = new StringBuilder();
if (node == null) {
return "null_";
}
stringBuilder.append(node.getData() + "_");
stringBuilder.append(method2(node.left));
stringBuilder.append(method2(node.right));
return stringBuilder.toString();
}递归 先序 反序列化
思路：类似于遍历。
public static Node method(String string) {
Queue<String> queue = new LinkedList<>();
String[] splits = string.split("_");
for (String split : splits) {
queue.add(split);
}
return method4(queue);
}
public static Node method4(Queue<String> queue) {
if (queue.peek().equals("null")) {
queue.poll();
return null;
}
Node node = new Node(Integer.parseInt(queue.poll()));
node.left = method4(queue);
node.right = method4(queue);
return node;
}------------------------------------------------------------------------------------------------------------------------------------------------------------------------
（2）分层
非递归 按层 序列化
思路：遍历。
public static String method4(Node head) {
Node node = head;
StringBuilder stringBuilder = new StringBuilder();
Queue<Node> queue = new LinkedList<>();
if (node != null) {
stringBuilder.append(node.data + "_");
queue.add(node);
} else {
stringBuilder.append("null_");
}
while (!queue.isEmpty()) {
node = queue.poll();
if (node.left != null) {
queue.add(node.left);
stringBuilder.append(node.left.data + "_");
}else {
stringBuilder.append("null_");
}
if (node.right != null) {
queue.add(node.right);
stringBuilder.append(node.right.data + "_");
} else {
stringBuilder.append("null_");
}
}
return stringBuilder.toString();
}非递归 按层 反序列化
public static Node method(String string) {
String[] splits = string.split("_");
Queue<Node> nodeQueue = new LinkedList<>();
Node node;
int index = 0;
node = helpMethod(splits[index++]);
Node head = node;
if (node != null) {
nodeQueue.offer(node);
}
while (!nodeQueue.isEmpty()) {
node = nodeQueue.poll();
node.left = helpMethod(splits[index++]);
node.right = helpMethod(splits[index++]);
if (node.left != null) {
nodeQueue.offer(node.left);
}
if (node.right != null) {
nodeQueue.offer(node.right);
}
}
return head;
}5、判断是否为平衡二叉树。
平衡二叉树：每个节点的左右子树高度相差不大于1（<= 1）。
思路：递归，每深入一层，当前高度加1，左右子树高度差 <= 1 时，返回高的子树高度，否则返回-1.
public static boolean method(Node head) {
Node node = head;
int balance = isBalance(node, 1);
if (balance != -1) {
return true;
}
return false;
}
public static int isBalance(Node head, int level) {
Node node = head;
if (node == null) {
return level - 1;
}
int leftHeight = isBalance(node.left, level+1);
int rightHeight = isBalance(node.right, level+1);
if (Math.abs(leftHeight - rightHeight) <= 1) {
return Math.max(leftHeight, rightHeight);
} else {
return -1;
}
}6、判断是否为搜索二叉树（中序遍历有序）
思路1：中序遍历一遍，再看是否有序
public static boolean method(Node head) {
Node node = head;
Queue<Integer> queue = new LinkedList<>();
method1(node, queue);
int temp = queue.poll();
for (Integer integer : queue) {
if (integer < temp) {
return false;
}
temp = integer;
}
return true;
}
public static Queue<Integer> method1(Node head, Queue<Integer> queue) {
Node node = head;
if (node == null) {
return null;
}
method1(node.left, queue);
queue.add(node.data);
method1(node.right, queue);
return queue;
}思路2、根据非递归中序遍历，遍历时看当前数是否大于等于上一个数。
public static boolean method(Node head) {
Node node = head;
Stack<Node> stack = new Stack<>();
while (node.left != null) {
node = node.left;
}
int temp = node.data;
node = head;
while (!stack.isEmpty() || node != null) {
if (node == null) {
node = stack.pop();
if (node.data >= temp) {
temp = node.data;
} else {
return false;
}
node = node.right;
}
if (node != null) {
stack.add(node);
node = node.left;
}
}
return true;
}7、判断一棵树是否为完全二叉树（叶子节点从左向右）
思路：分层遍历，记一个标记 isleaf ，如果当前节点为叶子节点， 之后的节点就不能有子树。
public static boolean method(Node head) {
Queue<Node> queue = new LinkedList<>();
Node node = head;
Boolean isLeaf = false;
if (node != null) {
queue.add(node);
}
while (!queue.isEmpty()) {
node = queue.poll();
if (node.left != null) {
if (isLeaf == true) {
return false;
}
queue.add(node.left);
} else {
isLeaf = true;
}
if (node.right != null) {
if (isLeaf == true) {
return false;
}
queue.add(node.right);
}else {
isLeaf = true;
}
}
return true;
}8、求一棵完全二叉树的节点个数。要求时间复杂度小于O（n）。
思路：当前节点右子树的最左节点如果存在的话，左子树就是满二叉树。
否则，右子树就是满二叉树。
满二叉树很容易算，然后再看不满的那一边
时间复杂度为（logn)^2 ,因为每次都是按层数遍历一遍
public static int getNumber(Node head) {
return getNumber(head, 1, getHeight(head));
}
/**
* @param node
* @param level 当前节点所在层数
* @param height 最大的所求完全二叉树的高度（不变）
* @return
*/
public static int getNumber(Node node, int level, int height) {
int num = 0;
if (node == null) {
return 0;
}
// 当前树右子树的最左节点存在
if (getHeight(node.right) + level == height) {
// 左子树为满二叉树
num += (int) Math.pow(2, height - level);
// 右子树重复当前过程
num += getNumber(node.right, level + 1, height);
} else {
num += Math.pow(2, getHeight(node.right));
num += getNumber(node.left, level + 1, height);
}
return num;
}
/**
* 获取当前完全二叉树的高度（最左节点的高度）
* @param head
* @return
*/
public static int getHeight(Node head) {
Node node = head;
int height = 0;
while (node != null) {
height++;
node = node.left;
}
return height;
}
344
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
