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

最新推荐文章于 2021-07-06 16:16:15 发布
最新推荐文章于 2021-07-06 16:16:15 发布
阅读量97 收藏
点赞数
分类专栏： 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
头很凉快
关注
专栏目录
[力扣]144. 二叉树的前序遍历java
12-21
二叉树遍历是针对二叉树进行操作的一种基本算法，主要有三种类型：前序遍历、中序遍历和后序遍历。本问题主要关注的是前序遍历，它是二叉树遍历的一种常见方式。 **前序遍历**的顺序是：先访问根节点，然后递归地...
Java二叉搜索树遍历操作详解【前序、中序、后序、层次、广度优先遍历】
08-19
不同的遍历算法可以满足不同的需求，例如前序遍历可以用于二叉树的遍历和搜索，中序遍历可以用于二叉树的遍历和排序，后序遍历可以用于二叉树的遍历和操作，层次遍历可以用于二叉树的遍历和层次操作。
已知二叉树的前序和中序遍历，打印后序遍历
03-26
这里我们将重点讨论如何在已知二叉树的前序和中序遍历的情况下，通过非递归算法实现后序遍历。 **前序遍历**：根节点 -> 左子树 -> 右子树 **中序遍历**：左子树 -> 根节点 -> 右子树 **后序遍历**：左子树 -> 右子...
满二叉树的前序遍历C++实现
最新发布
06-05
因此，满二叉树的前序遍历、中序遍历和后序遍历均可以通过递归方式实现。 以前序遍历为例，满二叉树的前序遍历顺序为：根、左、右。 在具体实现过程中，我们可以通过构造一个满二叉树，然后进行前序遍历来获取遍历...
Java实现 LeetCode 814 二叉树剪枝 （遍历树）
12-20
在二叉树中，我们可以采用不同的遍历策略来访问每个节点，主要有三种遍历方法：前序遍历、中序遍历和后序遍历。 对于这个问题，我们可以利用后序遍历来解决。后序遍历的特点是先遍历左子树，再遍历右子树，最后访问...
java学习第25天，第一节，通用性对象栈
qq_15346435的博客
06-14 1158
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 1138
代码的有点难度整个代码需要花费时间来整理思路，一定要搞懂搞透才能开始下一步 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 679
以前电脑上没有安装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 256
1，矩阵对象的创建。 2，getRows等:getter,setter在java里面很常用,主要是为了访问控制。 3，整数矩阵的加法、乘法。 4，Exception的抛出与捕获机制。 5，用this调用其它的构造方法以减少冗余代码。 6，代码看起来多,但矩阵运算我们以前写过。 7，把数据类型修改成double,获得DoubleMatrix.java,以后会很有用。 8，getIdentityMatrix:单位矩阵。 9，resultMatrix.data[i][i]:成员变量的访问权限:在同一类里面是可以直
java学习第三天，掌握基本的if then else 语句
qq_15346435的博客
05-23 246
package java1to10; public class D3_IfThenElse { public static void main(String[] args) { // TODO Auto-generated method stub int tempInt1 = 5, tempInt2 = 0; // 判断tempInt1,给tempInt2赋值 if (tempInt1 >= 0) { tempInt2 = tempInt1; } else { t
java学习第32天，图的连通性检测
qq_15346435的博客
06-26 156
1，适用于有向图. 反正无向图是有向图的特殊形式。 2，0次方的时候是单位矩阵。 3，为每一个方法写一个独立的测试方法，测试代码有时比正常使用的代码更多。 4，第一个测试用例是无向图，第二个是有向图。可以看到，后者从节点1不能到达节点0。 5，Matrix基础代码准备好之后，其它的算法真的很方便。 package java31to40; public class D32_Graph { D31_IntMatrix connectivityMatrix; public static void main
java学习第一天，编写第一个java程序HelloWorld.java迈出第一步
qq_15346435的博客
05-22 146
打开心爱的编译器，新建第一个java项目。取一个好听的名字 ** 创建项目 ** 1、File-New-Project 选择“Java Project” 红框这里有可能需要更改一下，改到你安装的那个jdk版本，项目名称取一个具有标识性的，这就完成了第一次项目的创建。 在src中创建一个包New–>Package并且给包命名。 这样在包中就可以创建类进行编写代码了。 在javaD1中创建类New–>Class 这样就是一个完整的创建过程。接下来就是撸代码了。 这是我的java代码，
java学习第36天，邻连表
qq_15346435的博客
06-27 124
1，相当于图的压缩存储. 每一行数据用一个单链表存储. 2，重写了广度优先遍历. 可以发现, 使用队列的机制不变. 仅仅是把其中的 for 循环换成了 while, 避免检查不存在的边. 如果图很稀疏的话, 可以降低时间复杂度. package java31to40; import java21to30.D22_CircleObjectQueue; public class D36_AdjacencyList { class AdjacencyNode { int column; Adjace
java学习第14天，理解栈的概念
qq_15346435的博客
06-03 114
package java11to20; public class D14_CharStack { public static final int Max = 25; int depth = 0; char[] data; public static void main(String[] args) { // TODO Auto-generated method stub D14_CharStack Stack = new D14_CharStack(); for (char chDa
java学习第16天，递归算法
qq_15346435的博客
06-07 106
递归算法非常基础也非常实用，在实际应用中非常普遍。该代码很简单，但是对于理解递归思想非常好，就是通过一段代码的反复调用来实现某些功能，能够用少量的代码做很多事情，并且易读性很强。 package java11to20; public class D16_Recursion { public static void main(String args[]) { int count = 5; System.out.println(String.format("0 到 %s 和为：%s", count,
java学习第39天，关键路径
qq_15346435的博客
07-06 100
1，拓扑排序是关键路径的一部分。 2，关键路径长度, 其实是最远路径长度。然而，它并非最短路径的对偶问题。 3，正向算每个节点的最早开始时间, 逆向算每个节点的最晚开始时间, 设计太了。 4，最晚开始时间的初始化容易弄错, 经典算法是不好对付的。 需要连接第38天的代码，在这里贴出来 package java31to40; import java.util.Arrays; public class D38_Net { public static final int MAX_DISTANCE = 100
java学习第22天，二叉树的存储
qq_15346435的博客
06-12 100
二叉树的存储并非一个简单的问题. 引用 (指针) 是无法存储到文件里面的. 完全满二叉树的角度广度优先遍历的角度来考虑这个问题: 每个节点都有一个 name 及其在二叉树中的位置. 令根节点的位置为 0; 则第 2 层节点的位置依次为 1 至 2; 第 3 层节点的位置依次为 3 至 6. 以此类推. 空使用 0 来表示, 可以用一个向量来存储: [a, b, c, 0, d, e, 0, 0, 0, f, g] 优点: 仅需要一个向量, 简单直接. 缺点: 对于实际的二叉树, 很多子树为空, 导致大量的
java学习第41天，顺序查找与折半查找
qq_15346435的博客
07-06 98
顺序查找使用岗哨可以节约一半的时间. 为此, 第 0 个位置不可以放有意义的数据, 即有效数据只有 length - 1 个。 顺序查找时间复杂度为 O ( n ) O(n)O(n)。 折半查找时间复杂度为 O ( log ⁡ n ) O(\log n)O(logn)。 书上为简化起见, 只关注键. 这里使用键值对来表示一条完整的数据. 实际应用中可以把 content 改成任何想要的数据类型 package java41to50; public class D41_DataArray { clas.
java学习第21天，二叉树
qq_15346435的博客
06-10 98
二叉树的先序，中序和后序遍历，这里要多看看数据结构。 package java21to30; public class D21_BinaryCharTree { char value; D21_BinaryCharTree leftChild; D21_BinaryCharTree rightChild; public static void main(String[] args) { D21_BinaryCharTree tree = manualConstructTree(); Sy
Java实现二叉树非递归遍历：前序、中序、后序
"这篇文档详细阐述了如何在Java中使用非递归方法遍历二叉树，主要包括前序遍历、中序遍历和后序遍历三种方式，所有方法都借助栈作为辅助数据结构来实现。" 在二叉树遍历中，非递归方法是一种常见的优化策略，它可以...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值