最新Java实现链式存储的二叉树，招银网络java面试

最后

我想问下大家当初选择做程序员的初衷是什么？有思考过这个问题吗？高薪？热爱？

既然入了这行就应该知道，这个行业是靠本事吃饭的，你想要拿高薪没有问题，请好好磨练自己的技术，不要抱怨。有的人通过培训可以让自己成长，有些人可以通过自律强大的自学能力成长，如果你两者都不占，还怎么拿高薪？

架构师是很多程序员的职业目标，一个好的架构师是不愁所谓的35岁高龄门槛的，到了那个时候，照样大把的企业挖他。为什么很多人想进阿里巴巴，无非不是福利待遇好以及优质的人脉资源，这对个人职业发展是有非常大帮助的。

如果你也想成为一名好的架构师，那或许这份Java核心架构笔记你需要阅读阅读，希望能够对你的职业发展有所帮助。

中高级开发必知必会：

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

int j = height(node.getRchild());

return (i<j)?(j+1):(i+1);

}

}

//得到节点的个数

public int size(TreeNode node){

if(node == null){

return 0;

}else{

return 1+ size(node.getLchild())+size(node.getRchild());

}

}

//递归实现先序遍历 NLR

public void preOrder(TreeNode node){

if(node != null){

System.out.print(node.getData() + " ");

preOrder(node.getLchild());

preOrder(node.getRchild());

}

}

//非递归实现先序遍历 NLR

public void nonRecPreOrder(TreeNode node){

Stack<TreeNode> nodeStack = new Stack<TreeNode>();

TreeNode nodeTemp = node; //nodeTemp作为遍历指针

while(nodeTemp != null || !nodeStack.isEmpty()){ //当nodeTemp非空或栈非空时循环

if(nodeTemp != null){ //根指针非空，遍历左子树

nodeStack.push(nodeTemp); //根指针进栈

System.out.print(nodeStack.peek().getData() + " "); //根指针退栈，访问根节点

nodeTemp = nodeTemp.getLchild(); //每遇到非空二叉树先向左走

}else{ //再向右子树走

nodeTemp = nodeStack.pop();

nodeTemp = nodeTemp.getRchild();

}

}

}

//递归实现中序遍历 LNR

public void inOrder(TreeNode node){

if(node != null){

inOrder(node.getLchild());

System.out.print(node.getData() + " ");

inOrder(node.getRchild());

}

}

//非递归实现中序遍历 LNR

public void nonRecInOrder(TreeNode node){

Stack<TreeNode> nodeStack = new Stack<TreeNode>();

TreeNode nodeTemp = node; //nodeTemp作为遍历指针

while(nodeTemp != null || !nodeStack.isEmpty()){ //当nodeTemp非空或栈非空时循环

if(nodeTemp != null){ //根指针非空，遍历左子树

nodeStack.push(nodeTemp); //根指针进栈

nodeTemp = nodeTemp.getLchild(); //每遇到非空二叉树先向左走

}else{

nodeTemp = nodeStack.pop(); //根指针退栈，访问根节点

System.out.print(nodeTemp.getData() +" ");

nodeTemp = nodeTemp.getRchild(); //再向右子树走

}

}

}

//递归实现后序遍历 LNR

public void postOrder(TreeNode node){

if(node != null){

postOrder(node.getLchild());

postOrder(node.getRchild());

System.out.print(node.getData() + " ");

}

}

//非递归实现后序遍历 LNR

public void nonRecPostOrder(TreeNode node){

Stack<TreeNode> nodeStack = new Stack<TreeNode>();

TreeNode nodeTemp = node; //nodeTemp作为遍历指针

TreeNode preNode = null; //表示最近一次访问的节点

while(nodeTemp != null || !nodeStack.isEmpty()){ //当nodeTemp非空或栈非空时循环

while(nodeTemp != null){ //一直向左走，遍历左子树

nodeStack.push(nodeTemp);

nodeTemp = nodeTemp.getLchild();

}

nodeTemp = nodeStack.peek();

if(nodeTemp.getRchild()==null || nodeTemp.getRchild() == preNode){ //右子树为空或右子树已被访问时，该节点出栈

nodeTemp = nodeStack.pop();

System.out.print(nodeTemp.getData()+" ");

preNode = nodeTemp; //将该节点赋值给最近一个访问节点

nodeTemp = null; //此处很重要，将刚出栈节点设置为空，对应于while循环的条件之一，否则陷入死循环

}else{

nodeTemp = nodeTemp.getRchild(); //遍历右子树

}

}

}

//层次遍历

public void levelOrder(TreeNode root){

Queue<TreeNode> nodeQueue = new LinkedList<TreeNode>();

TreeNode node = null;

nodeQueue.add(root); //将根节点入队

while(!nodeQueue.isEmpty()){ //队列不空循环

node = nodeQueue.peek();

System.out.print(node.getData()+" ");

nodeQueue.poll(); //队头元素出队

if(node.getLchild() != null){ //左子树不空，则左子树入队列

nodeQueue.add(node.getLchild());

}

if(node.getRchild() != null){ //右子树不空，则右子树入队列

nodeQueue.add(node.getRchild());

}

}

}

public static void main(String args[]){

//将一个数组转化为一颗完全二叉树

Object[] array = {1,2,3,4,5,6,7,8};

BinaryTree bt = new BinaryTree();

TreeNode root = bt.buildTree(array);

System.out.print(“树的高度：”);

System.out.println(bt.height(root));

System.out.print(“节点的个数：”);

System.out.println(bt.size(root));

System.out.println(“先序遍历：”);

bt.preOrder(root);

System.out.println(“\n”+“非递归先序遍历：”);

bt.nonRecPreOrder(root);

System.out.println();

System.out.println(“中序遍历：”);

bt.inOrder(root);

System.out.println(“\n”+“非递归中序遍历：”);

bt.nonRecInOrder(root);

System.out.println();

System.out.println(“后序遍历：”);

bt.postOrder(root);

System.out.println(“\n”+“非递归后序遍历：”);

bt.nonRecPostOrder(root);

System.out.println();

System.out.println(“层次遍历：”);

bt.levelOrder(root);

//手工构建一颗二叉树

TreeNode nodeA = new TreeNode(“A”);

TreeNode nodeB = new TreeNode(“B”);

TreeNode nodeC = new TreeNode(“C”);

TreeNode nodeD = new TreeNode(“D”);

TreeNode nodeE = new TreeNode(“E”);

TreeNode nodeF = new TreeNode(“F”);

TreeNode nodeG = new TreeNode(“G”);

TreeNode nodeH = new TreeNode(“H”);

TreeNode nodeI = new TreeNode(“I”);

nodeA.setLchild(nodeB);

nodeA.setRchild(nodeD);

nodeB.setRchild(nodeC);

nodeD.setLchild(nodeE);

nodeD.setRchild(nodeF);

nodeF.setLchild(nodeG);

nodeF.setRchild(nodeI);

nodeG.setRchild(nodeH);

System.out.println(“\n\n”+“*****************”);

System.out.print(“树的高度：”);

System.out.println(bt.height(nodeA));

System.out.print(“节点的个数：”);

System.out.println(bt.size(nodeA));

System.out.println(“先序遍历：”);

bt.preOrder(nodeA);

System.out.println();

System.out.println(“中序遍历：”);

bt.inOrder(nodeA);

System.out.println();

System.out.println(“后序遍历：”);

bt.postOrder(nodeA);

System.out.println();

System.out.println(“层次遍历：”);

bt.levelOrder(nodeA);

}

}

上述程序的运行结果：
参考博客：
https://www.cnblogs.com/CherishFX/p/4617105.html

最后

各位读者，由于本篇幅度过长，为了避免影响阅读体验，下面我就大概概括了整理了

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取

，下面我就大概概括了整理了

[外链图片转存中…(img-cxqvo8AM-1715635909496)]

[外链图片转存中…(img-9MprankP-1715635909496)]

[外链图片转存中…(img-frSvxuMm-1715635909497)]

[外链图片转存中…(img-mfvIl4p3-1715635909497)]

本文已被CODING开源项目：【一线大厂Java面试题解析+核心总结学习笔记+最新讲解视频+实战项目源码】收录

需要这份系统化的资料的朋友，可以点击这里获取