二叉树（二）
6．二叉树中节点值的和为指定整数的所有路径
从树的根节点开始往下一直到叶子节点所经过的节点形成的一条路径。例如输入整数22和。如下二叉树：
10
/ \
5 12
/ \
4 7
则打印出两条路径：10, 12 和 10, 5, 7
// sum 当前路径之和
// num 求的路径和
public void printPath(BTreeNode root, int sum, Stack<Integer> stack, int num) {
if (root != null) {
sum = sum + root.data;
stack.push(root.data);
printPath(root.left, sum, stack, num);
printPath(root.right, sum, stack, num);
if(sum == num &&root.left==null&&root.right==null) {
for (int i : stack) {
System.out.print(i + " ");
}
System.out.println();
}
stack.pop();
}
}
public static void main(String[] args) {
BinaryTreePath btp = new BinaryTreePath();
BTreeNode root = btp.createTree(root);
Stack<Integer> stack = new Stack<Integer>();
int num = 22;
int sum = 0;
btp.printPath(root, sum, stack, num);
}
}
7. 按层打印二叉树的每个结点，同一层的结点从左到右打印，不同层之间换行
public void printByLevel(Node root) {
if (root != null) {
Queue<Node> queue = new LinkedList<Node>();
Node flag = new Node();// 作分割标志
Node tempNode = null;
queue.offer(root);
queue.offer(flag);
while (queue.size() > 1) {//避免flag始终有时，死循环
tempNode = queue.poll();
if (tempNode != flag) {
System.out.print(tempNode.getData()+" ");
if (tempNode.getLeft() != null) {
queue.offer(tempNode.getLeft());
}
if (tempNode.getRight() != null) {
queue.offer(tempNode.getRight());
}
} else {
System.out.println();
queue.offer(flag);
}
}
}
}
递归方式：
public int printNodeAtLevel(Node root, int level) {
if (root == null || level < 0) {
return 0;
}
if (0 == level) {
System.out.print(root.getData()+" ");
return 1;
}
return printNodeAtLevel(root.getLeft(), level - 1)
+ printNodeAtLevel(root.getRight(), level - 1);
}
public void printBylevel_(Node root) {
for (int level = 0;; level++) {
if (printNodeAtLevel(root, level) == 0)
break;
System.out.println();
}
}
8. 二叉查找树转变成排序的双向链表
10/ \
6 14
/ \ / \
4 8 12 16
转换成双向链表
4=6=8=10=12=14=16
static ListNode head;
static ListNode rear;
public static void Tree2List(BSTreeNode tree) {
if (null != tree.getLeft()) {
Tree2List(tree.getLeft());
}
ListNode node = new ListNode();
node.setValue(tree.getValue());
if (null != head) {
rear.setRight(node);
node.setLeft(rear);
rear = node;
} else {
head = node;
rear = node;
}
if (null != tree.getRight()) {
Tree2List(tree.getRight());
}
}
9. 将二叉树的左右子树交换
public void change（Tree node）｛
if（node为空 || 没有左子树 && 没有右子树）
return
swap(node.left, node.right)
if（有左子树）
change（node.left）；
if（有右子树）
change（node.right）；
｝
10. 根据前序遍历和中序遍历的结果构造二叉树
public Node buildTree(int[] preOrder, int begin1, int end1, int[] inOrder, int begin2, int end2) {
if (begin1 > end1 || begin2 > end2) {
return null;
}
int rootData = preOrder[begin1];// 根节点为前序的第一个
Node root = new Node(rootData);
int div = getIndex(inOrder, rootData, begin2, end2);// 找到分割处
int offSet = div - begin2;// 偏移量,左孩子的前序有offSet个
Node left = buildTree(preOrder, begin1 + 1, begin1 + offSet, inOrder, begin2, begin2 + offSet - 1);
Node right = buildTree(preOrder, begin1 + offSet + 1, end1, inOrder, div + 1, end2);
root.setLeft(left);
root.setRight(right);
return root;
}
public int getIndex(int[] arr, int value, int begin, int end) {
for (int i = begin; i <= end; i++) {
if (arr[i] == value)
return i;
}
return -1;
}
调用： int[] preOrder = { 7, 10, 4, 3, 1, 2, 8, 11 }; // 前序
int[] inOrder = { 4, 10, 3, 1, 7, 11, 8, 2 }; // 中序
rootNode = test.buildTree(preOrder, 0, preOrder.length - 1, inOrder, 0, preOrder.length - 1);
11．判断整数序列是不是二叉查找树的后序遍历结果
最后一个结点必为根结点，然后根据二叉排序树的性质找到它的左右孩子，然后再递归查找.public boolean check(int[] a, int begin, int end) {
if (a == null || begin == end)// 空二叉树和只有根节点的二叉树也是二叉查找树
return true;
if (begin < 0 || end >= a.length) {
return false;
}
int root = a[end];
int left = begin;
// 左子树均小于根节点
for (; left < end; left++) {
if (a[left] > root)
break;
}
// 右子树均大于根节点
int right = left;// left位置是第一个比root大的节点
for (; right < end; right++) {
if (a[right] < root)
return false;
}
boolean leftFlag = true, rightFlag = true;
if (left - begin > 1) {// left - begin为左子树节点的个数，小于2可以忽略
// 递归左边的序列
leftFlag = check(a, begin, left - 1);
}
if (end - left > 1) {// end - left为右子树节点的个数，小于2可以忽略
// 递归右边的序列
rightFlag = check(a, left, end - 1);
}
return leftFlag && rightFlag;
}