Java数据结构——二叉树深度遍历的栈实现

已于 2022-03-10 15:22:41 修改
阅读量493 收藏
点赞数 2
分类专栏： Java数据结构 文章标签： java 二叉树 深度优先遍历
于 2022-01-07 17:47:37 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_51184516/article/details/122368240
版权

文章目录

深度遍历

1. 创建通用型栈

  • ObjectStack
//package cb;

/**
 * 这是一个通用类型的栈
 * @author NoBug
 * @version 3.0
 */
public class ObjectStack {
	
	/**
	 * MAXSIZE = 100
	 */
	public static final int MAXSIZE = 100;
	
	/**
	 * 这是栈的实际占量，整型
	 */
	int stacksize;
	
	/**
	 * 栈存放数据的数组
	 */
	Object[] data;
	
	/**
	 * 构造一个空栈
	 */
	public ObjectStack() {
		this.stacksize = 0;
		this.data = new Object[MAXSIZE];
	} // of construct
	
	/**
	 * toString()
	 */
	public String toString() {
		String result = "";
		
		for(int i=0; i<this.stacksize; i++) {
			result += data[i] + " ";
		}
		
		return result;
	} // of toString
	
	/**
	 * push
	 * @author 己千之
	 * @param elem 类型Object
	 * @return 成功或失败
	 */
	public boolean push(Object elem) {
		
		// 栈满
		if(this.stacksize==MAXSIZE) {
			System.out.println("Stack full.");
			return false;
		}
		
		this.data[this.stacksize] = elem;
		this.stacksize++;
		
		return true;
	}//of push
	
	/**
	 * pop
	 * @author 己千之
	 * @return Object类型
	 */
	public Object pop() {
		
		// 栈空
		if(this.stacksize==0) {
			System.out.println("StackEmpty.");
		}
		
		Object elem = data[this.stacksize-1];
		this.stacksize--;
		
		return elem;
	}//of pop
	
	/**
	 * 判断栈是否为空
	 * @author 己千之
	 * @return true or false 空或者不空
	 */
	public boolean isEmpty() {
		
		// Stack is empty
		if(this.stacksize==0) {
			return true;
		}
		else {
			return false;
		}
	}//of isEmpty
	
}
  • 测试类
//package cb;

public class Test_ObjectStack {

	public static void main(String[] args) {
		ObjectStack S = new ObjectStack();
		S.push(1);
		S.push('b');
		S.push(2);
		S.push("ad");
		S.push(12.1);
		System.out.println(S.isEmpty());
		System.out.println(S.toString());
	}

}
  • 效果图

在这里插入图片描述

2. 二叉树深度遍历的栈实现

  • 深度遍历：前面已经讲过，是前序遍历，中序遍历，后序遍历。

  • 代码

	/**
	 * 中序遍历的栈实现
	 */
	public void inorderTraversalWithStack() {
		ObjectStack stack = new ObjectStack();
		BinaryTree tempNode = this;
		while(!stack.isEmpty() || tempNode != null) {
			if(tempNode != null) {
				
				// 入栈
				stack.push(tempNode);
				tempNode = tempNode.lchild;
			} else {
				
				// 出栈
				tempNode = (BinaryTree) stack.pop();
				System.out.print(tempNode.data + " ");
				tempNode = tempNode.rchild;
			}
		} // end while
		
	} // of inorderTraversalWithStack
	
	/**
	 * 先序遍历的栈实现
	 */
	public void preorderTraversalWithStack() {
		ObjectStack stack = new ObjectStack();
		BinaryTree tempNode = this;
		while(!stack.isEmpty() || tempNode != null) {
			if(tempNode != null) {
				System.out.print(tempNode.data + " ");
				stack.push(tempNode);
				tempNode = tempNode.lchild;
			} else {
				tempNode = (BinaryTree) stack.pop();
				tempNode = tempNode.rchild;
			}
		} // end while
		
	} // of preorderTraversalWithStack
	
	/**
	 * 后序遍历的栈实现
	 */
	public void postorderTraversalWithStack() {
		ObjectStack stack = new ObjectStack();
		BinaryTree tempNode = this;
		ObjectStack tempStack = new ObjectStack();
		while(!stack.isEmpty() || tempNode != null) {
			if(tempNode != null) {
				tempStack.push(tempNode.data);
				stack.push(tempNode);
				tempNode = tempNode.rchild;
			} else {
				tempNode = (BinaryTree) stack.pop();
				tempNode = tempNode.lchild;
			}
		} // end while
		
		while(!tempStack.isEmpty()) {
			System.out.print(tempStack.pop() + " ");
		}
		
	} // of postorderTraversalWithStack
  • 源码
//package cb;


public class BinaryTree {
	
	/**
	 * 数据域
	 */
	Object data;
	
	/**
	 * 左孩子
	 */
	BinaryTree lchild;
	
	/**
	 * 右孩子
	 */
	BinaryTree rchild;
	
	/**
	 * 构造函数，为单个节点，赋值，形成独立的节点
	 * @param elem 
	 */
	public BinaryTree(Object elem) {
		data = elem;
		lchild = null;
		rchild = null;
	} // of construct
	
	/**
	 * 构造函数，创建二叉树的储存结构
	 * @param value 数据域数组
	 * @param key 下标数组
	 */
	public BinaryTree(Object[] value, int[] key) {
		
		// BinaryTree型的数组，装每一个节点
		int node = value.length;
		BinaryTree[] allNodes = new BinaryTree[node];
		for(int i=0; i<node; i++) {
			allNodes[i] = new BinaryTree(value[i]);
		}
		
		// 链接节点
		for(int i=1; i<node; i++) {
			for(int j=0; j<i; j++) {
				if(key[i] == key[j]*2+1) {
					allNodes[j].lchild = allNodes[i];
					break;
				}else if(key[i] == key[j]*2+2) {
					allNodes[j].rchild = allNodes[i];
					break;
				}
			}
		}
		
		// 根节点
		data = allNodes[0].data;
		lchild = allNodes[0].lchild;
		rchild = allNodes[0].rchild;
		
	} // of construct

	/**
	 * 先序遍历
	 */
	public void preorderTraversal() {
		System.out.print(data + " ");
		if(lchild != null) {
			lchild.preorderTraversal();
		}
		if(rchild != null) {
			rchild.preorderTraversal();
		}
	} // of preorderTraversal
	
	/**
	 * 中序遍历
	 */
	public void inorderTraversal() {
		if(lchild != null) {
			lchild.inorderTraversal();
		}
		System.out.print(data + " ");
		if(rchild != null) {
			rchild.inorderTraversal();
		}
	} // of inorderTraversal
	
	/**
	 * 后序遍历
	 */
	public void postorderTraversal() {
		if(lchild != null) {
			lchild.postorderTraversal();
		}
		if(rchild != null) {
			rchild.postorderTraversal();
		}
		System.out.print(data + " ");
	} // of postorderTraversal
	
	/**
	 * 层次遍历
	 * @param T 传进一个二叉树
	 */
	public void levelorderTraversal(BinaryTree T) {
		if(T != null) {
			
			// 不用队列，只能取数组了
			BinaryTree[] B = new BinaryTree[100];
			
			// 根节点第一个
			B[0] = T;
			
			// 巧妙之处 
			int first = 0;
			int after = 1;
			
			// 循环 
			while(first < after) {
				System.out.print(B[first].data + " ");
				if(B[first].lchild != null) {
					B[after] = B[first].lchild;
					after++;
				} // end if
				if(B[first].rchild != null) {
					B[after] = B[first].rchild;
					after++;
				} // end if
				
				first++;			
			} // end while
		} // end if
		
	} // of LevelorderTraversal
	
	/**
	 * @author 己千之
	 * 对照层次遍历，和这个方法，可以很轻松的写出二叉树的结构
	 * @param T
	 */
	public void structOfBinary(BinaryTree T) {
		if(T != null) {
			
			// 不用队列，只能取数组了
			BinaryTree[] B = new BinaryTree[100];
			
			// 根节点第一个
			B[0] = T;
			
			// 巧妙之处 
			int first = 0;
			int after = 1;
			
			// 循环 
			while(first < after) {
				System.out.println(B[first].data + " ");
				
				if(B[first].lchild != null) {
					B[after] = B[first].lchild;
					after++;
				}else {
					System.out.println(B[first].data + "这个节点的左节点是空的 ");
				}
				
				if(B[first].rchild != null) {
					B[after] = B[first].rchild;
					after++;
				}else {
					System.out.println(B[first].data + "这个节点的右节点是空的 ");
				}
				
				first++;			
			} // end while
		} // end if
	}
	
	/**
	 * 二叉树的深度
	 * @return depth 
	 * 			二叉树的深度
	 */
	public int getDepth() {
		
		// 只有根节点
		if((lchild == null)&&(rchild == null)) {
			return 1;
		} // end if
		
		// 左
		int lDepth = 0;
		if(lchild != null) {
			lDepth = lchild.getDepth();
		} // end if
		
		// 右
		int rDepth = 0;
		if(rchild != null) {
			rDepth = rchild.getDepth();
		} // end if
		
		// 左右比较
		if(lDepth >= rDepth) {
			return lDepth+1;
		}
		else {
			return rDepth+1;
		}
		
	} // of getDepth
	
	/**
	 * 二叉树的节点数
	 * @return node
	 * 			二叉树的节点数
	 * 			左 + 右 + 1
	 */
	public int getNode() {
		
		// 只有根节点
		if((lchild == null)&&(rchild == null)) {
			return 1;
		} // end if
		
		// 左节点遍历
		int lNode = 0;
		if(lchild != null) {
			lNode = lchild.getNode();
		} // end if
		
		// 右节点遍历
		int rNode = 0;
		if(rchild != null) {
			rNode = rchild.getNode();
		} // end if
		
		return lNode+rNode+1;
	} // of getNode
	
	/**
	 * 中序遍历的栈实现
	 */
	public void inorderTraversalWithStack() {
		ObjectStack stack = new ObjectStack();
		BinaryTree tempNode = this;
		while(!stack.isEmpty() || tempNode != null) {
			if(tempNode != null) {
				
				// 入栈
				stack.push(tempNode);
				tempNode = tempNode.lchild;
			} else {
				
				// 出栈
				tempNode = (BinaryTree) stack.pop();
				System.out.print(tempNode.data + " ");
				tempNode = tempNode.rchild;
			}
		} // end while
		
	} // of inorderTraversalWithStack
	
	/**
	 * 先序遍历的栈实现
	 */
	public void preorderTraversalWithStack() {
		ObjectStack stack = new ObjectStack();
		BinaryTree tempNode = this;
		while(!stack.isEmpty() || tempNode != null) {
			if(tempNode != null) {
				System.out.print(tempNode.data + " ");
				stack.push(tempNode);
				tempNode = tempNode.lchild;
			} else {
				tempNode = (BinaryTree) stack.pop();
				tempNode = tempNode.rchild;
			}
		} // end while
		
	} // of preorderTraversalWithStack
	
	/**
	 * 后序遍历的栈实现
	 */
	public void postorderTraversalWithStack() {
		ObjectStack stack = new ObjectStack();
		BinaryTree tempNode = this;
		ObjectStack tempStack = new ObjectStack();
		while(!stack.isEmpty() || tempNode != null) {
			if(tempNode != null) {
				tempStack.push(tempNode.data);
				stack.push(tempNode);
				tempNode = tempNode.rchild;
			} else {
				tempNode = (BinaryTree) stack.pop();
				tempNode = tempNode.lchild;
			}
		} // end while
		
		while(!tempStack.isEmpty()) {
			System.out.print(tempStack.pop() + " ");
		}
		
	} // of postorderTraversalWithStack

}
  • 测试类
package cb;

public class Test_BinaryTree {
	
	public static void main(String[] args) {
		Object[] valueArray = {1, 2, 3, 4, 5};
		int[] indexArray = {0, 1, 2, 3, 6};
		BinaryTree BiTree1 = new BinaryTree(valueArray, indexArray);
		System.out.print("先序遍历：");
		BiTree1.preorderTraversalWithStack();;
		System.out.println();
		
		System.out.print("中序遍历：");
		BiTree1.inorderTraversalWithStack();
		System.out.println();
		
		System.out.print("后序遍历：");
		BiTree1.postorderTraversalWithStack();
		System.out.println();
	}
}
  • 效果图

在这里插入图片描述

姜满月
关注
  • 2
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
104.二叉树的最大深度（附带后序遍历递归方法的栈运行图）
qq_60225495的博客
04-06 619
104.二叉树的最大深度1 递归 1 递归 https://leetcode-cn.com/problems/maximum-depth-of-binary-tree/solution/hua-jie-suan-fa-104-er-cha-shu-de-zui-da-shen-du-b/ https://programmercarl.com/0104.%E4%BA%8C%E5%8F%89%E6%A0%91%E7%9A%84%E6%9C%80%E5%A4%A7%E6%B7%B1%E5%BA%A6.html
数据结构——二叉树的实现.zip
09-18
这个压缩包文件"数据结构——二叉树的实现.zip"显然包含了关于二叉树实现的详细内容，特别是二叉链表和左子右兄弟两种不同的实现方法。 首先，我们来探讨二叉链表的实现。二叉链表是最基础的二叉树存储方式，每个...
[数据结构]史上最详细!用栈实现二叉树的建立以及先/中/后序遍历_C语言
weixin_73038327的博客
11-19 1025
链栈的数据域存放的是树结点的指针 BiTNode* data;top指针始终指向头结点, 入栈时对头结点进行后插操作。
104. 利用后序遍历（非递归）求二叉树的最大深度
weixin_46864174的博客
04-23 1724
利用后序遍历的非递归算法 后序遍历在出入栈是，是先将左孩子进栈，处理完毕后出栈，再将右孩子入栈，最后再处理根结点。所以在非递归的后序遍历过程中，栈的深度即为当前的深度。利用这个特性，我们可以编写出一下 ...
求左叶子树之和
lixiansen1511的博客
09-19 467
package com.huike; public class TreeNode { int val;//节点值 TreeNode left;//左节点 TreeNode right;//右节点 //构造方法对节点初始化 TreeNode(int x) { val = x; } TreeNode(){ } public Tr.
数据结构——深度优先遍历（栈）
m0_61635175的博客
09-19 1960
数据结构——深度优先遍历（栈）
Java实现 LeetCode 814 二叉树剪枝 （遍历树）
12-20
在本题中，我们需要解决的是LeetCode的第814题——二叉树剪枝。题目要求我们给定一个二叉树，其中每个节点的值为0或1，然后删除所有不包含1的子树，返回修改后的二叉树。这里的子树指的是以某个节点为根的所有后代...
《数据结构——C++实现》（第二版）课本源代码.zip
最新发布
06-16
《数据结构——C++实现》（第二版）是一本深入讲解这一主题的教材，提供了源代码供读者实践和学习。 本书的C++实现部分，旨在帮助读者掌握各种基本和高级数据结构，如数组、链表、栈、队列、树（二叉树、平衡树）、...
day14-Java（二叉树深度遍历的栈实现）
nooooooooooob的博客
03-07 407
文章目录二叉树深度遍历的栈实现一、Object类栈的创建二、中序遍历实现三、代码与数据测试 二叉树深度遍历的栈实现 一、Object类栈的创建 这个与之前的通用性队列实现相似，只需char[] data–>Object[] data,注意在适当的地方使用强制类型转换即可。前两天强制代码没有写清楚，这里再写一下： tempNode = (BinaryCharTree) tempStack.pop(); 表示ObjectStack类型转换为BinaryCharTree类型。 二、中序遍历实现 In-o
Java第27天——二叉树的深度遍历的栈实现（前序和后序）
gdy的博客
01-04 478
我找到为什么了
Day13——二叉树深度遍历的栈实现
Z__XY_的博客
04-12 2006
如果明白了之前递归深度遍历二叉树，那也能容易想到用栈实现二叉树深度遍历。 本篇博客以这棵树为例： 中序遍历 中序遍历顺序：左子树，当前结点，右子树。 从根结点A开始，先将它压栈，发现它有左孩子，则处理左孩子： 接着是A的左孩子结点B，先将它压栈，它没有左孩子，弹出一个栈顶元素（刚刚压入的B），访问该结点，发现该结点有右孩子，则继续处理右孩子： 接着将B的右孩子结点D压栈，D没有左孩子，则弹出一个栈顶元素（刚刚压入的D），访问该结点，发现D没有右孩子，表明此时A的左子树访问结束，弹出A： 接着是处
Java第25天——二叉树深度遍历的栈实现（中序）
gdy的博客
01-02 484
还是深度遍历，想要看泛型可以看21天
深度优先遍历的栈实现
水到渠成
03-07 1672
——PickingupJewels 捡珠宝是典型的需要回溯的深度优先遍历，它要求找出能获得最多珠宝的路径，并且将该路径输出。          这个题比较难的两点是怎么不走环路和怎么回溯。回溯相对简单一点，就是出栈以后，你要将它置为未访问过，不用担心重复走它，因为还有方向控制前进的方向。 而对于环路，一开始想得很苦恼，没明白，多设了很多条件，后来还是在老大的帮助下，想通了其实不重复进栈就不会
[深度优先遍历—栈实现]求图中两点是否连通
baidu_17062867的专栏
07-09 1791
[深度优先遍历非递归算法]求图中两点是否连通
java二叉树堆栈遍历_专题：二叉树的遍历（迭代）
weixin_39889788的博客
02-24 172
任何算法的递归版本都可以改成非递归版本，因为函数递归调用其实质就是压栈的过程，那么我们完全可以使用堆栈来模拟这个过程。二叉树的遍历(递归法)很容易实现，本质是采用了栈帧的实现方式，函数调用就是压栈，函数求解就是出栈的过程，那么我们完全可以手动创建栈来模拟这个过程，按照指定遍历顺序迭代的访问二叉树的所有结点。因为前序、中序、后序三种遍历方式在当前函数体内都是先调用f(root.left)，再调用f(...
java 实现树形结构
new_guaika的博客
10-28 3778
实体父类 @Data public class MenuTreeNode<T> { @ApiModelProperty(value = "节点ID") private String node; @ApiModelProperty(value = "父节点ID") private String parentNode; @ApiModelProperty(value = "子标签") private List<T> children;
JAVA学习—二叉树深度遍历的栈实现 (前序和后序)—2021-06-14
seismic_matlab的博客
06-14 1303
JAVA学习—二叉树深度遍历的栈实现 (前序和后序)—2021-06-14 前序与中序的区别, 仅仅在于输出语句的位置不同. 二叉树的遍历, 总共有 6 种排列: 1) 左中右 (中序); 2) 左右中 (后序); 3) 中左右 (前序); 4) 中右左; 5) 右左中; 6) 右中左. 我们平常关心的是前三种, 是因为我们习惯于先左后右. 如果要先右后左, 就相当于左右子树互换, 这个是很容易做到的. 如果将前序的左右子树互换, 就可得到 4) 中右左; 再进行逆序, 可以得到 2) 左右中. 因此,
Python：目录遍历--栈深度遍历
caoxinjian423的博客
09-24 368
#!/usr/bin/env python # coding:UTF-8 """ @version: python3.x @author:曹新健 @contact: 617349013@qq.com @software: PyCharm @file: 深度遍历栈.py @time: 2018/9/7 13:18 """ import os from collections import d...
java二叉树堆栈遍历_二叉树的各种遍历方式，我都帮你总结了，附有队列堆栈图解...
weixin_30538955的博客
02-24 502
今天我来分享一篇关于二叉树的文章(建议收藏，便于巩固基础)。看完此文leetcode至少解决八道题掌握二叉树的前序、中序、后序遍历以及两种不同的实现方式：递归与非递归非递归时遍历与层次遍历时，有详细的图解表示队列/栈中的元素是如何移动的，有助于理解代码的运行二叉树介绍二叉树(binary tree) 是指树中节点的度不大于2的有序树，它是一种最简单且最重要的树。二叉树的递归定义为： 二叉树是一棵空...
Java数据结构复习：二叉树遍历详解
这篇笔记主要探讨了Java中的数据结构——二叉树及其遍历方法。二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在计算机科学中，二叉树广泛应用于搜索、排序和组织数据等方面。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

姜满月

鼓励，鼓励，更加努力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值