java学习第 26 天，二叉树深度遍历的栈实现 (前序和后序)

最新推荐文章于 2024-05-17 21:51:18 发布
最新推荐文章于 2024-05-17 21:51:18 发布
阅读量54 收藏
点赞数
分类专栏： java的学习之路 文章标签： java 二叉树 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_15346435/article/details/118003425
版权

1，前序与中序的区别, 仅仅在于输出语句的位置不同.
2，二叉树的遍历, 总共有 6 种排列:

  1. 左中右 (中序);
  2. 左右中 (后序);
  3. 中左右 (前序);
  4. 中右左;
  5. 右左中;
  6. 右中左.
    我们平常关心的是前三种, 是因为我们习惯于先左后右. 如果要先右后左, 就相当于左右子树互换, 这个是很容易做到的.

这里java代码分成两部分
第一部分是队列和算法部分借用以前写过的代码。

package java21to30;

import java.util.Arrays;

public class D24_BinaryCharTree {
	char value;
	D24_BinaryCharTree leftChild;
	D24_BinaryCharTree rightChild;

	public D24_BinaryCharTree(char paraName) {
		value = paraName;
		leftChild = null;
		rightChild = null;
	}

	public void preOrderVisitWithStack() {
		D25_ObjectStack tempStack = new D25_ObjectStack();
		D24_BinaryCharTree tempNode = this;
		while (!tempStack.isEmpty() || tempNode != null) {
			if (tempNode != null) {
				System.out.print("" + tempNode.value + " ");
				tempStack.push(tempNode);
				tempNode = tempNode.leftChild;
			} else {
				tempNode = (D24_BinaryCharTree) tempStack.pop();
				tempNode = tempNode.rightChild;
			} // Of if
		} // Of while
	}

	public void inOrderVisitWithStack() {
		D25_ObjectStack tempStack = new D25_ObjectStack();
		D24_BinaryCharTree tempNode = this;
		while (!tempStack.isEmpty() || tempNode != null) {
			if (tempNode != null) {
				tempStack.push(tempNode);
				tempNode = tempNode.leftChild;
			} else {
				tempNode = (D24_BinaryCharTree) tempStack.pop();
				System.out.print("" + tempNode.value + " ");
				tempNode = tempNode.rightChild;
			} // Of if
		} // Of while
	}

	public void postOrderVisitWithStack() {
		D25_ObjectStack tempStack = new D25_ObjectStack();
		D24_BinaryCharTree tempNode = this;
		D25_ObjectStack tempOutputStack = new D25_ObjectStack();

		while (!tempStack.isEmpty() || tempNode != null) {
			if (tempNode != null) {
				tempOutputStack.push(new Character(tempNode.value));
				tempStack.push(tempNode);
				tempNode = tempNode.rightChild;
			} else {
				tempNode = (D24_BinaryCharTree) tempStack.pop();
				tempNode = tempNode.leftChild;
			}
		}
		while (!tempOutputStack.isEmpty()) {
			System.out.print("" + tempOutputStack.pop() + " ");
		}
	}

	public static D24_BinaryCharTree manualConstructTree() {
		D24_BinaryCharTree resultTree = new D24_BinaryCharTree('a');
		D24_BinaryCharTree tempTreeB = new D24_BinaryCharTree('b');
		D24_BinaryCharTree tempTreeC = new D24_BinaryCharTree('c');
		D24_BinaryCharTree tempTreeD = new D24_BinaryCharTree('d');
		D24_BinaryCharTree tempTreeE = new D24_BinaryCharTree('e');
		D24_BinaryCharTree tempTreeF = new D24_BinaryCharTree('f');
		D24_BinaryCharTree tempTreeG = new D24_BinaryCharTree('g');

		resultTree.leftChild = tempTreeB;
		resultTree.rightChild = tempTreeC;
		tempTreeB.rightChild = tempTreeD;
		tempTreeC.leftChild = tempTreeE;
		tempTreeD.leftChild = tempTreeF;
		tempTreeD.rightChild = tempTreeG;

		return resultTree;
	}

	public D24_BinaryCharTree(char[] paraDataArray, int[] paraIndicesArray) {
		int tempNumNodes = paraDataArray.length;
		D24_BinaryCharTree[] tempAllNodes = new D24_BinaryCharTree[tempNumNodes];
		for (int i = 0; i < tempNumNodes; i++) {
			tempAllNodes[i] = new D24_BinaryCharTree(paraDataArray[i]);
		}
		for (int i = 1; i < tempNumNodes; i++) {
			for (int j = 0; j < i; j++) {
				System.out.println("indices " + paraIndicesArray[j] + " vs. " + paraIndicesArray[i]);
				if (paraIndicesArray[i] == paraIndicesArray[j] * 2 + 1) {
					tempAllNodes[j].leftChild = tempAllNodes[i];
					System.out.println("Linking " + j + " with " + i);
					break;
				} else if (paraIndicesArray[i] == paraIndicesArray[j] * 2 + 2) {
					tempAllNodes[j].rightChild = tempAllNodes[i];
					System.out.println("Linking " + j + " with " + i);
					break;
				}
			}
		}
		value = tempAllNodes[0].value;
		leftChild = tempAllNodes[0].leftChild;
		rightChild = tempAllNodes[0].rightChild;
	}

	public void preOrderVisit() {
		System.out.print("" + value + " ");

		if (leftChild != null) {
			leftChild.preOrderVisit();
		}
		if (rightChild != null) {
			rightChild.preOrderVisit();
		}
	}

	public void inOrderVisit() {
		if (leftChild != null) {
			leftChild.inOrderVisit();
		}
		System.out.print("" + value + " ");

		if (rightChild != null) {
			rightChild.inOrderVisit();
		}
	}

	public void postOrderVisit() {
		if (leftChild != null) {
			leftChild.postOrderVisit();
		}
		if (rightChild != null) {
			rightChild.postOrderVisit();
		}
		System.out.print("" + value + " ");
	}

	public int getDepth() {
		if ((leftChild == null) && (rightChild == null)) {
			return 1;
		}
		int tempLeftDepth = 0;
		if (leftChild != null) {
			tempLeftDepth = leftChild.getDepth();
		}
		int tempRightDepth = 0;
		if (rightChild != null) {
			tempRightDepth = rightChild.getDepth();
		}
		if (tempLeftDepth >= tempRightDepth) {
			return tempLeftDepth + 1;
		} else {
			return tempRightDepth + 1;
		}
	}

	public int getNumNodes() {
		if ((leftChild == null) && (rightChild == null)) {
			return 1;
		}
		int tempLeftNodes = 0;
		if (leftChild != null) {
			tempLeftNodes = leftChild.getNumNodes();
		}
		int tempRightNodes = 0;
		if (rightChild != null) {
			tempRightNodes = rightChild.getNumNodes();
		}
		return tempLeftNodes + tempRightNodes + 1;
	}

	char[] valuesArray;
	int[] indicesArray;

	public void toDataArrays() {
		int tempLength = getNumNodes();

		valuesArray = new char[tempLength];
		indicesArray = new int[tempLength];
		int i = 0;
		D22_CircleObjectQueue tempQueue = new D22_CircleObjectQueue();
		tempQueue.enqueue(this);
		D22_CircleObjectQueue tempIntQueue = new D22_CircleObjectQueue();
		tempIntQueue.enqueue(0);

		D24_BinaryCharTree tempTree = (D24_BinaryCharTree) tempQueue.dequeue();
		int tempIndex = (int) tempIntQueue.dequeue();
		while (tempTree != null) {
			valuesArray[i] = tempTree.value;
			indicesArray[i] = tempIndex;
			i++;

			if (tempTree.leftChild != null) {
				tempQueue.enqueue(tempTree.leftChild);
				tempIntQueue.enqueue(tempIndex * 2 + 1);
			}
			if (tempTree.rightChild != null) {
				tempQueue.enqueue(tempTree.rightChild);
				tempIntQueue.enqueue(tempIndex * 2 + 2);
			}
			tempTree = (D24_BinaryCharTree) tempQueue.dequeue();
			if (tempTree != null)
				tempIndex = (int) tempIntQueue.dequeue();
		}
	}

	public void toDataArraysObjectQueue() {
		int tempLength = getNumNodes();

		valuesArray = new char[tempLength];
		indicesArray = new int[tempLength];
		int i = 0;
		D22_CircleObjectQueue tempQueue = new D22_CircleObjectQueue();
		tempQueue.enqueue(this);
		D22_CircleObjectQueue tempIntQueue = new D22_CircleObjectQueue();
		Integer tempIndexInteger = new Integer(0);
		tempIntQueue.enqueue(tempIndexInteger);

		D24_BinaryCharTree tempTree = (D24_BinaryCharTree) tempQueue.dequeue();
		int tempIndex = ((Integer) tempIntQueue.dequeue()).intValue();
		System.out.println("tempIndex = " + tempIndex);
		while (tempTree != null) {
			valuesArray[i] = tempTree.value;
			indicesArray[i] = tempIndex;
			i++;

			if (tempTree.leftChild != null) {
				tempQueue.enqueue(tempTree.leftChild);
				tempIntQueue.enqueue(new Integer(tempIndex * 2 + 1));
			}
			if (tempTree.rightChild != null) {
				tempQueue.enqueue(tempTree.rightChild);
				tempIntQueue.enqueue(new Integer(tempIndex * 2 + 2));
			}
			tempTree = (D24_BinaryCharTree) tempQueue.dequeue();
			if (tempTree == null) {
				break;
			}
			tempIndex = ((Integer) tempIntQueue.dequeue()).intValue();
		}
	}

	public static void main(String args[]) {
		D24_BinaryCharTree tempTree = manualConstructTree();
		System.out.println("\r\n先序遍历:");
		tempTree.preOrderVisit();
		System.out.println("\r\n中序遍历:");
		tempTree.inOrderVisit();
		System.out.println("\r\n后序遍历:");
		tempTree.postOrderVisit();

		System.out.println("\r\n\r\n深度: " + tempTree.getDepth());
		System.out.println("节点个数: " + tempTree.getNumNodes());
		tempTree.toDataArrays();
		System.out.println("值是: " + Arrays.toString(tempTree.valuesArray));
		System.out.println("指数是:" + Arrays.toString(tempTree.indicesArray));
		tempTree.toDataArraysObjectQueue();
		System.out.println("对象序列.");
		System.out.println("值: " + Arrays.toString(tempTree.valuesArray));
		System.out.println("指数是: " + Arrays.toString(tempTree.indicesArray));

		char[] tempCharArray = { 'A', 'B', 'C', 'D', 'E', 'F' };
		int[] tempIndicesArray = { 0, 1, 2, 4, 5, 12 };
		D24_BinaryCharTree tempTree2 = new D24_BinaryCharTree(tempCharArray, tempIndicesArray);

		System.out.println("\r\n先序遍历:");
		tempTree2.preOrderVisit();
		System.out.println("\r\n中序遍历:");
		tempTree2.inOrderVisit();
		System.out.println("\r\n后序遍历:");
		tempTree2.postOrderVisit();
	}
}

第二部分：通过调用以前的方法来实现我们想要的输出。

package java21to30;

import java.util.Arrays;

public class D26_preOrderVisitWithStack {
	public static void main(String args[]) {
		D24_BinaryCharTree tempTree = D24_BinaryCharTree.manualConstructTree();
		System.out.println("\r先序遍历:");
		tempTree.preOrderVisit();
		System.out.println("\r\n中序遍历:");
		tempTree.inOrderVisit();
		System.out.println("\r\n后序遍历:");
		tempTree.postOrderVisit();

		System.out.println("\r\n\r\n树的深度: " + tempTree.getDepth());
		System.out.println("节点总数: " + tempTree.getNumNodes());

		tempTree.toDataArrays();
		System.out.println("值为: " + Arrays.toString(tempTree.valuesArray));
		System.out.println("指数为: " + Arrays.toString(tempTree.indicesArray));

		tempTree.toDataArraysObjectQueue();
		System.out.println("对象队列。");
		System.out.println("值是: " + Arrays.toString(tempTree.valuesArray));
		System.out.println("指数是: " + Arrays.toString(tempTree.indicesArray));

		char[] tempCharArray = { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K' };
		int[] tempIndicesArray = { 0, 1, 2, 4, 5, 12, 11, 14, 16, 13, 10 };
		D24_BinaryCharTree tempTree2 = new D24_BinaryCharTree(tempCharArray, tempIndicesArray);

		System.out.println("\r\n先序遍历:");
		tempTree2.preOrderVisit();
		System.out.println("\r\n中序遍历:");
		tempTree2.inOrderVisit();
		System.out.println("\r\n后序遍历:");
		tempTree2.postOrderVisit();
		System.out.println("\r\n栈的先序遍历:");
		tempTree2.inOrderVisitWithStack();
		System.out.println("\r\n栈的中序遍历:");
		tempTree2.preOrderVisitWithStack();
		System.out.println("\r\n栈的后序遍历:");
		tempTree2.postOrderVisitWithStack();
	}
}

结果输出：


先序遍历:
a b d f g c e 
中序遍历:
b f d g a e c 
后序遍历:
f g d b e c a 

树的深度: 4
节点总数: 7
值为: [a, b, c, d, e, f, g]
指数为: [0, 1, 2, 4, 5, 9, 10]
tempIndex = 0
对象队列。
值是: [a, b, c, d, e, f, g]
指数是: [0, 1, 2, 4, 5, 9, 10]
indices 0 vs. 1
Linking 0 with 1
indices 0 vs. 2
Linking 0 with 2
indices 0 vs. 4
indices 1 vs. 4
Linking 1 with 3
indices 0 vs. 5
indices 1 vs. 5
indices 2 vs. 5
Linking 2 with 4
indices 0 vs. 12
indices 1 vs. 12
indices 2 vs. 12
indices 4 vs. 12
indices 5 vs. 12
Linking 4 with 5
indices 0 vs. 11
indices 1 vs. 11
indices 2 vs. 11
indices 4 vs. 11
indices 5 vs. 11
Linking 4 with 6
indices 0 vs. 14
indices 1 vs. 14
indices 2 vs. 14
indices 4 vs. 14
indices 5 vs. 14
indices 12 vs. 14
indices 11 vs. 14
indices 0 vs. 16
indices 1 vs. 16
indices 2 vs. 16
indices 4 vs. 16
indices 5 vs. 16
indices 12 vs. 16
indices 11 vs. 16
indices 14 vs. 16
indices 0 vs. 13
indices 1 vs. 13
indices 2 vs. 13
indices 4 vs. 13
indices 5 vs. 13
indices 12 vs. 13
indices 11 vs. 13
indices 14 vs. 13
indices 16 vs. 13
indices 0 vs. 10
indices 1 vs. 10
indices 2 vs. 10
indices 4 vs. 10
Linking 3 with 10

先序遍历:
A B D K C E G F 
中序遍历:
B D K A G E F C 
后序遍历:
K D B G F E C A 
栈的先序遍历:
B D K A G E F C 
栈的中序遍历:
A B D K C E G F 
栈的后序遍历:
K D B G F E C A
头很凉快
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
day15-Java（二叉树前序和后序遍历的栈实现）
nooooooooooob的博客
03-08 514
文章目录二叉树前序和后序遍历的栈实现一、前序遍历的栈实现 二叉树前序和后序遍历的栈实现 一、前序遍历的栈实现 Pre-order visit with stack: A Pre-order visit with stack: A B Pre-order visit with stack: A B D 这里注意与中序遍历的区别，虽然到目前为止，二叉树个节点的遍历顺序与站内元素都与中序遍历一样，但栈的作用完全不一样。在中序遍历中，栈中元素的出栈顺序即为遍历的顺序，而在前序遍历中，栈中元素的进栈顺序即为遍历
[力扣]144. 二叉树的前序遍历java
12-21
二叉树遍历是针对二叉树进行操作的一种基本算法，主要有三种类型：前序遍历、中序遍历和后序遍历。本问题主要关注的是前序遍历，它是二叉树遍历的一种常见方式。 **前序遍历**的顺序是：先访问根节点，然后递归地...
Java第27天——二叉树的深度遍历的栈实现（前序和后序）
gdy的博客
01-04 478
我找到为什么了
java手动构建二叉树并实现广度遍历、深度遍历（前序中序后序）
you do ,you win
04-21 1960
文章目录什么是二叉树属性节点TreeNode手动构建如下所示二叉树遍历广度遍历算法思想实现细节深度遍历先序遍历（根左右）算法思想实现细节中序遍历（左根右）算法思想实现细节后续遍历（左右根）算法思想实现细节 什么是二叉树 在计算机科学中，树是一种重要的非线性数据结构，直观的看，它是数据元素按分支关系组织起来的结构。二叉树是每个节点最多有两个子树的有序树。通常子树的根被称作“左子树”和“右子树”。二叉树常被用做二叉查找树和二叉堆或是二叉排序树。二叉树的每个节点至多只有两颗子树，二叉树有左右之分，次序不能颠倒。
Java学习第26天：二叉树深度遍历的栈实现 (前序和后序)
xiaowuPHD的博客
06-15 1150
主要任务：以为前序和后序要比中序难很多, 其实并没有. 前序与中序的区别, 仅仅在于输出语句的位置不同. 二叉树的遍历, 总共有 6 种排列: 1) 左中右 (中序); 2) 左右中 (后序); 3) 中左右 (前序); 4) 中右左; 5) 右左中; 6) 右中左. 我们平常关心的是前三种, 是因为我们习惯于先左后右. 如果要先右后左, 就相当于左右子树互换, 这个是很容易做到的. 如果将前序的左右子树互换, 就可得到 4) 中右左; 再进行逆序, 可以得到 2) 左右中. 因此, 要把前序的代码改为后
二叉树遍历方法详解：层序遍历、前序遍历、中序遍历和后序遍历
最新发布
www_tlj的专栏
05-17 517
首先，我们定义一个二叉树节点类TreeNode，用于表示二叉树中的每个节点。该类包含节点值、左子节点和右子节点的引用。int val;@Override。
day26--二叉树深度遍历的栈实现 (前序和后序)
weixin_43763325的博客
07-09 76
前序与中序的区别在于输出顺序不同，后序需要一个输出栈存放输出数据， 代码： 测试用例： 运行结果：
Day_26二叉树深度遍历的栈实现 (前序和后序)
DARRENANJIAN的博客
02-13 55
数据结构
JAVA学习—二叉树深度遍历的栈实现 (前序和后序)—2021-06-14
seismic_matlab的博客
06-14 1301
JAVA学习—二叉树深度遍历的栈实现 (前序和后序)—2021-06-14 前序与中序的区别, 仅仅在于输出语句的位置不同. 二叉树的遍历, 总共有 6 种排列: 1) 左中右 (中序); 2) 左右中 (后序); 3) 中左右 (前序); 4) 中右左; 5) 右左中; 6) 右中左. 我们平常关心的是前三种, 是因为我们习惯于先左后右. 如果要先右后左, 就相当于左右子树互换, 这个是很容易做到的. 如果将前序的左右子树互换, 就可得到 4) 中右左; 再进行逆序, 可以得到 2) 左右中. 因此,
java 二叉树的实现以及前序、中序、后续遍历实现
西凉的悲伤博客
10-02 575
二叉树是n个有限元素的集合，该集合或者为空、或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成，是有序树。当集合为空时，称该二叉树为空二叉树。在二叉树中，一个元素也称作一个节点。本文主要讲的是二叉树中的完全二叉树的实现，
Java第25天——二叉树深度遍历的栈实现（中序）
gdy的博客
01-02 481
还是深度遍历，想要看泛型可以看21天
Java二叉搜索树遍历操作详解【前序、中序、后序、层次、广度优先遍历】
08-19
不同的遍历算法可以满足不同的需求，例如前序遍历可以用于二叉树的遍历和搜索，中序遍历可以用于二叉树的遍历和排序，后序遍历可以用于二叉树的遍历和操作，层次遍历可以用于二叉树的遍历和层次操作。
已知二叉树的前序和中序遍历，打印后序遍历
03-26
这里我们将重点讨论如何在已知二叉树的前序和中序遍历的情况下，通过非递归算法实现后序遍历。 **前序遍历**：根节点 -> 左子树 -> 右子树 **中序遍历**：左子树 -> 根节点 -> 右子树 **后序遍历**：左子树 -> 右子...
满二叉树的前序遍历C++实现
06-05
因此，满二叉树的前序遍历、中序遍历和后序遍历均可以通过递归方式实现。 以前序遍历为例，满二叉树的前序遍历顺序为：根、左、右。 在具体实现过程中，我们可以通过构造一个满二叉树，然后进行前序遍历来获取遍历...
Java实现 LeetCode 814 二叉树剪枝 （遍历树）
12-20
在二叉树中，我们可以采用不同的遍历策略来访问每个节点，主要有三种遍历方法：前序遍历、中序遍历和后序遍历。 对于这个问题，我们可以利用后序遍历来解决。后序遍历的特点是先遍历左子树，再遍历右子树，最后访问...
java学习第25天，第一节，通用性对象栈
qq_15346435的博客
06-14 1122
1，改写栈程序, 里面存放对象. 2，该程序应该放在 datastructure.stack 包内. 3，还是依靠强制类型转换, 支持不同的数据类型. 4，增加了 isEmpty() 方法. package java21to30; public class D25_ObjectStack { public static final int MAX_DEPTH = 15; int depth; Object[] data; public static void main(String[] args
java学习第24天，二叉树的建立
qq_15346435的博客
06-14 1097
代码的有点难度整个代码需要花费时间来整理思路，一定要搞懂搞透才能开始下一步 package java21to30; import java.util.Arrays; public class D24_BinaryCharTree { char value; D24_BinaryCharTree leftChild; D24_BinaryCharTree rightChild; public D24_BinaryCharTree(char paraName) { value = paraNa
java学习第一天，eclipse编译器的安装和JDK8电脑环境配置
qq_15346435的博客
05-22 646
以前电脑上没有安装eclipse编译器和jdk。 现在第一步是下载jdk和eclipse。 官方给的最新jdk是16，这个版本比较高。我选择安装jdk8，这也是现在开发中经常用到的版本。 https://www.oracle.com/java/technologies/javase/javase-jdk8-downloads.html 这个是jdk8的官网地址。 下载“Java SE Development Kit 8u291” 因为我的电脑是系统是win10，64位系统所以我选择安装第二个。 下载完jd
java学习第31天，整数矩阵及其运算
qq_15346435的博客
06-26 236
1，矩阵对象的创建。 2，getRows等:getter,setter在java里面很常用,主要是为了访问控制。 3，整数矩阵的加法、乘法。 4，Exception的抛出与捕获机制。 5，用this调用其它的构造方法以减少冗余代码。 6，代码看起来多,但矩阵运算我们以前写过。 7，把数据类型修改成double,获得DoubleMatrix.java,以后会很有用。 8，getIdentityMatrix:单位矩阵。 9，resultMatrix.data[i][i]:成员变量的访问权限:在同一类里面是可以直
Java实现二叉树后序遍历及应用示例
此外，`Tree`类是二叉树的实现，包含了`root`节点，以及对前序（Preorder）、中序（Inorder）和后序遍历的方法。 `postorderHelper`方法是后序遍历的核心，通过递归的方式遍历左子树和右子树，最后打印根节点的值。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值