public int height(TreeNode node){
if(node == null){
return 0;
}else{
int i = height(node.getLchild());
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);
}
Java核心架构进阶知识点
面试成功其实都是必然发生的事情,因为在此之前我做足了充分的准备工作,不单单是纯粹的刷题,更多的还会去刷一些Java核心架构进阶知识点,比如:JVM、高并发、多线程、缓存、Spring相关、分布式、微服务、RPC、网络、设计模式、MQ、Redis、MySQL、设计模式、负载均衡、算法、数据结构、kafka、ZK、集群等。而这些也全被整理浓缩到了一份pdf——《Java核心架构进阶知识点整理》,全部都是精华中的精华,本着共赢的心态,好东西自然也是要分享的
内容颇多,篇幅却有限,这就不在过多的介绍了,大家可根据以上截图自行脑补
加入社区:https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0
发、多线程、缓存、Spring相关、分布式、微服务、RPC、网络、设计模式、MQ、Redis、MySQL、设计模式、负载均衡、算法、数据结构、kafka、ZK、集群等。而这些也全被整理浓缩到了一份pdf——《Java核心架构进阶知识点整理》,全部都是精华中的精华,本着共赢的心态,好东西自然也是要分享的
[外链图片转存中…(img-aUKlwvf6-1725664928792)]
[外链图片转存中…(img-E7SasVKu-1725664928793)]
[外链图片转存中…(img-6qnsoe9F-1725664928794)]
内容颇多,篇幅却有限,这就不在过多的介绍了,大家可根据以上截图自行脑补
加入社区:https://bbs.csdn.net/forums/4304bb5a486d4c3ab8389e65ecb71ac0