根据先序和中序还原(重建)一个二叉树


站长推荐:程序员必备10TBJava大数据机器学习人工智能从入门到精通视频教程下载


package tree.BinaryTree;

import java.util.Arrays;

/**
* 根据先序和中序还原一个二叉树
*
* @author yuzhiyun
*
*/

public class ReCreateBinaryTree {

public static void main(String[] args) {
// 先序
int[] preOrder = { 1,2,4,7,3,5,6,8 };
// 中序
int[] midOrder = { 4,7,2,1,5,3,8,6 };
/**
* 思路是这样的, preOrder第一个元素1就是根节点啦 遍历midOrder找到1,那么1前面的元素(4,7,2)都是
* 根节点的左子树啦,1后面的元素(5,3,8,6)都是根节点的右子数 当然我们可以得知根节点的左子树的节点数为3,右子树的节点数为4,
* 那么回到preOrder,我们知道1后面的3个元素(2,4,7)是根节点左子树的先序遍历
* 同样的回到midOrder,1前面的3个元素(4,7,2)是根节点左子树的中序遍历
* 这样的话,我们最终得到了左子树的先序遍历和中序遍历,由此可以再次得到该左子树的根节点是谁。
* 这样相当于本题的规模变小了,有了递归的性质,显然递归可以得到结果
*/

TreeNode root = createBinaryTree(preOrder, midOrder);
System.out.print("先序打印");
prePrintBinaryTree(root);

System.out.println("");
System.out.print("中序打印");
inPrintBinaryTree(root);

System.out.println("");
System.out.print("后序打印");
postPrintBinaryTree(root);

}
/**
* 后序打印二叉树,验证二叉树建立是否正确
*/

private static void postPrintBinaryTree(TreeNode root) {
// TODO Auto-generated method stub
if (root.leftChild != null)
postPrintBinaryTree(root.leftChild);

if (root.rightChild != null)
postPrintBinaryTree(root.rightChild);
System.out.print(root.value + " ");
}
/**
* 中序打印二叉树,验证二叉树建立是否正确
*/

private static void inPrintBinaryTree(TreeNode root) {
if (root.leftChild != null)
inPrintBinaryTree(root.leftChild);
System.out.print(root.value + " ");
if (root.rightChild != null)
inPrintBinaryTree(root.rightChild);
}

/**
* 先序打印二叉树,验证二叉树建立是否正确
*/

private static void prePrintBinaryTree(TreeNode root) {
System.out.print(root.value + " ");
if (root.leftChild != null)
prePrintBinaryTree(root.leftChild);
if (root.rightChild != null)
prePrintBinaryTree(root.rightChild);
}

/**
*
* @param pre
* 先序
* @param in
* 后序
* @return 二叉树的根节点
*/

public static TreeNode createBinaryTree(int[] pre, int[] in) {
if (pre.length == 0 || in.length == 0)
return null;
// 获得根节点
TreeNode root = new TreeNode();
root.value = pre[0];
// 获取根节点在中序遍历序列中的index
int rootIndex = getIndexOfArray(pre[0], in);
/**
* 计算leftChild
*/

// leftChild的先序遍历
int[] leftChildPreOrder = new int[rootIndex];
for (int i = 0; i < rootIndex; i++)
leftChildPreOrder[i] = pre[i + 1];
System.out.println("左孩子先序"+Arrays.toString(leftChildPreOrder));
// leftChild的中序遍历
int[] leftChildMidOrder = new int[rootIndex];
for (int j = 0; j < rootIndex; j++)
leftChildMidOrder[j] = in[j ];
System.out.println("左孩子中序"+Arrays.toString(leftChildMidOrder));
root.leftChild = createBinaryTree(leftChildPreOrder, leftChildMidOrder);
/**
* 计算rightChild
*/

// rightChild的先序遍历
int[] rightChildPreOrder = new int[in.length - rootIndex - 1];
for (int j = 0; j < rightChildPreOrder.length; j++)
rightChildPreOrder[j] = pre[j + rootIndex + 1];
// rightChild的中序遍历
int[] rightChildMidOrder = new int[in.length - rootIndex - 1];

for (int k = 0; k < rightChildMidOrder.length; k++)
rightChildMidOrder[k] = in[k + rootIndex + 1];
root.rightChild = createBinaryTree(rightChildPreOrder,
rightChildMidOrder);
// System.out.print(root.value + " ");
return root;
}

/**
* 获取key在数组中的下标
*
* @param i
* @return
*/

private static int getIndexOfArray(int key, int[] midOrder) {
for (int i = 0; i < midOrder.length; i++) {
if (key == midOrder[i])
return i;
}
return 0;
}
}

class TreeNode {
int value;
TreeNode leftChild;
TreeNode rightChild;

TreeNode() {
leftChild = null;
rightChild = null;
}

}
本站声明
本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。


 
© 2014-2018 ITdaan.com 粤ICP备14056181号