Java实现以下方法：
- 树的节点数量：size
- 判断是否为空：isEmpty
- 树的高度：getHeight
- 对树进行递归先序遍历：preTraversal
- 对树进行递归中序遍历：middleTraversal
- 对树进行递归后序遍历：postTraversal
- 借助队列实现层序遍历：orderByQueue
- 借助栈实现非递归先序遍历：preTraByStack
- 借助栈实现非递归中序遍历：inOrderByStack
- 借助栈实现非递归后序遍历：postTraByStack
ps：
- 关于树：
- 关于栈：
- 关于队列基本知识和循环队列：
- 关于双向队列：
树的interface：
package com.yao;
/**
* 定义二叉树可以实现的基本功能
*
*/
public interface Tree {
public int size();
public boolean isEmpty();
public int getHeight();
public void preTraversal();
public void middleTraversal();
public void postTraversal();
public void orderByQueue(); //借助队列实现层次遍历
public void preTraByStack(); //借助栈实现非递归遍历二叉树,使用先序进行遍历
void inOrderByStack(); //借助栈实现非递归遍历二叉树,使用中序进行遍历
void postTraByStack(); //借助栈实现非递归遍历二叉树,使用后序进行遍历
}
定义二叉树结点
数据+左子结点+右子结点+构造方法
package com.yao;
import lombok.AllArgsConstructor;
import lombok.Data;
//二叉树的基本结点
@Data
@AllArgsConstructor
public class Node {
Object data;
Node leftChild;
Node rightChild;
}定义一颗二叉树
存储方式：链表
PS：顺序表（数组）存储树，对于不增删，接近完全二叉树的二叉树，也是可行的
树的节点数量：size
@Override
public int size() {
return this.size(root);
}
private int size(Node node) {
if(node==null){
return 0;
}else{
int le = size(node.leftChild);
int ri = size(node.rightChild);
return ri+le+1;
}
}
判断是否为空：isEmpty
@Override
public boolean isEmpty() {
return root == null;
}树的高度：getHeight
@Override
public int getHeight() {
return this.getHeight(root);
}
private int getHeight(Node node) {
if(node == null){
return 0;
}else{
int ai = this.getHeight(node.leftChild);
int bi = this.getHeight(node.rightChild);
return ai>bi?ai+1:bi+1;
}
}或者
对树进行递归先序遍历：preTraversal
@Override
public void preTraversal() {
//进一步封装完善方法
//首先必须考虑代码健壮性
if(root !=null){
System.out.println("先序递归遍历：");
pre(root);
System.out.println();
}else{
System.out.println("此二叉树为空");
}
}
private void pre(Node node) {
if(node!=null){
//输出二叉树根节点
System.out.print(node.data+" ");
//继续相应地遍历左子树和右子树
this.pre(node.leftChild);
this.pre(node.rightChild);
}
}先、中、后序栈遍历的逻辑很关键，仔细分析这张图
规律：
- 按照⊗走就是先序遍历
- 按照☆走就是中序遍历
- 按照∆走就是后序遍历
- 根节点A的左中右，分别是⊗☆∆
- 所有节点逆时针都是⊗☆∆的顺序
- 先序：第一次碰到结点就输出：⊗
- 中序：必须是第二次碰到结点输出：☆之前必须要⊗
- 后序：必须是第三次碰到结点才输出：∆之前必须要有⊗☆
栈的逻辑
- 沿着左子树深入
- 先序遍历：先push，然后马上pop
- 中序遍历：push
- 后序遍历：push
- 当左分支分不下去
- 先序遍历：左分支深入不下去，则返回
- 中序遍历：pop该结点，然后从该结点右子树深入
- 后序遍历：继续push，往右分支深入
借助栈实现非递归先序遍历：preTraByStack
@Override
public void preTraByStack() {
System.out.println("先序栈遍历：");
Deque<Node> de = new LinkedList<>();//新建栈
Node node = root;
de.push(node);
while(node != null&&de.size()>0){
node = de.pop();
System.out.print(node.data+" ");
if(node.leftChild!=null && node.rightChild!=null){
de.push(node.rightChild);
de.push(node.leftChild);
}else if(node.leftChild!=null &&node.rightChild == null){
de.push(node.leftChild);
}else if(node.leftChild ==null &&node.rightChild != null){
de.push(node.rightChild);
}
}
System.out.println();
}借助栈实现非递归中序遍历：inOrderByStack
@Override
public void inOrderByStack() {
System.out.println("中序栈遍历:");
// 创建栈,和先序遍历类似，直接入栈直到没有最左左子树可以入栈
Deque<Node> stack = new LinkedList<Node>();
Node node = root;
//添加暂时完毕，开始pop元素
while(node!=null || stack.size()>0 ){
while(node!=null){
stack.push(node);
node = node.leftChild;
}
//一边pop并且一边进行判断，右结点不会null的，右子树，继续按照添加方法，将最左结点全部添加进去
if(stack.size()>0){
Node pop = stack.pop();
System.out.print(pop.data+" ");
if(pop.rightChild!=null){
node = pop.rightChild;
}
}
}
System.out.println();
}借助栈实现非递归后序遍历：postTraByStack
@Override
public void postTraByStack() {
System.out.println("后序非递归遍历，借助栈");
//新建栈，先进后出,将根结点入栈,双端队列
Deque<Node> stack = new LinkedList<>();
//新建一个list，记录结点的状态是否已经被访问过
ArrayList<Node> list = new ArrayList<>();
// stack.push(root);
Node proot;
Node node = root;
int flag;
//首先检查完树的左子树，再右子树，最后将根节点输出
while(node != null || stack.size()>0){
//将最左子树添加完毕
while(node != null){
stack.push(node);
node = node.leftChild;
}
//和中序遍历相似，为先输出左结点，但是做结点输出完毕之后，不能直接将根结点弹出，而是必须先将右结点弹出，
//最后再将根结点弹出来，就会牵扯到一个根结点的访问状态的问题，是否已经被遍历过了
//利用一个list集合记录已将被遍历过的根结点，防止产生死循环
if(stack.size()> 0 ){
Node peek = stack.peek();
if(peek.rightChild!=null){
boolean con = list.contains(peek);
if(con ==true){
Node pop = stack.pop();
System.out.print(pop.data+" ");
}else{
list.add(peek);
node = peek.rightChild;
}
}else{
Node pop = stack.pop();
System.out.print(pop.data+" ");
}
}
}
}借助队列实现层序遍历：orderByQueue
package com.yao;
import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
import java.util.ArrayList;
import java.util.Deque;
import java.util.LinkedList;
import java.util.Queue;
/**
* 采用双链表法实现二叉树
*/
@Data
@AllArgsConstructor
@NoArgsConstructor
public class LinkedBinaryTree implements Tree{
//为此棵数，创建根节点
private Node root;
@Override
public int size() {
return this.size(root);
}
private int size(Node node) {
if(node==null){
return 0;
}else{
int le = size(node.leftChild);
int ri = size(node.rightChild);
return ri+le+1;
}
}
@Override
public boolean isEmpty() {
return root == null;
}
@Override
public int getHeight() {
return this.getHeight(root);
}
private int getHeight(Node node) {
if(node == null){
return 0;
}else{
int ai = this.getHeight(node.leftChild);
int bi = this.getHeight(node.rightChild);
return ai>bi?ai+1:bi+1;
}
}
@Override
public void preTraversal() {
//进一步封装完善方法
//首先必须考虑代码健壮性
if(root !=null){
System.out.println("先序递归遍历：");
pre(root);
System.out.println();
}else{
System.out.println("此二叉树为空");
}
}
private void pre(Node node) {
if(node!=null){
//输出二叉树根节点
System.out.print(node.data+" ");
//继续相应地遍历左子树和右子树
this.pre(node.leftChild);
this.pre(node.rightChild);
}
}
@Override
public void middleTraversal() {
if(root !=null){
System.out.println("中序递归遍历：");
middle(root);
System.out.println();
}else{
System.out.println("此二叉树为空");
}
}
private void middle(Node node) {
if(node!=null){
//输出二叉树根节点
this.middle(node.leftChild);
System.out.print(node.data+" ");
this.middle(node.rightChild);
}
}
@Override
public void postTraversal() {
if(root !=null){
System.out.println("后序递归遍历：");
pos(root);
System.out.println();
}else{
System.out.println("此二叉树为空");
}
}
private void pos(Node node) {
if(node!=null){
//输出二叉树根节点
this.pos(node.leftChild);
this.pos(node.rightChild);
System.out.print(node.data+" ");
}
}
@Override
public void orderByQueue() {
//新建一个队列，存放二叉树结点
Queue qu = new LinkedList();
Node node = root;
qu.add(node);
//遍历输出每一层，同时将下一层的结点加入到对列中,队列现有的个数，就是每层节点的个数
while(qu.size()!=0){
for(int i = 0;i<qu.size();i++)
{
Node po = (Node) qu.poll();
System.out.print(po.data+" ");
if(po.leftChild != null)
qu.add(po.leftChild);
if(po.rightChild != null)
qu.add(po.rightChild);
}
}
System.out.println();
}
@Override
public void preTraByStack() {
System.out.println("先序栈遍历：");
Deque<Node> de = new LinkedList<>();//新建栈
Node node = root;
de.push(node);
while(node != null&&de.size()>0){
node = de.pop();
System.out.print(node.data+" ");
if(node.leftChild!=null && node.rightChild!=null){
de.push(node.rightChild);
de.push(node.leftChild);
}else if(node.leftChild!=null &&node.rightChild == null){
de.push(node.leftChild);
}else if(node.leftChild ==null &&node.rightChild != null){
de.push(node.rightChild);
}
}
System.out.println();
}
public void postTree(){
System.out.println("借助外部方法实现后序遍历：");
Deque<Node> stack =new LinkedList<Node>();
Node node = root;
Node proot;//标记栈顶元素前一个被访问的元素
int flag;//root的左孩子未被访问；
if(node!=null){
do{
while(node!=null){//将root所有左孩子全部入栈
stack.push(root);
node=node.leftChild;
}
//执行到此处，栈顶元素没有左孩子或者左子树已经被访问过；
proot=null;//标记栈顶元素前一个被访问的元素，或者此时为最左下边，该元素前一个被访问的元素肯定为空。
flag=1;//root的左孩子已经被访问；或者root为null
while(!stack.isEmpty() && flag==1){
node=stack.peek(); //取到栈顶元素，但是不出栈；
if(node.rightChild==proot){
node=stack.pop();
System.out.print(node.data+" ");
proot=node;
}else{
node=node.rightChild;
flag=0;//root左边孩子未被访问；
}
}
}while(!stack.isEmpty());
}
}
@Override
public void postTraByStack() {
System.out.println("后序非递归遍历，借助栈");
//新建栈，先进后出,将根结点入栈,双端队列
Deque<Node> stack = new LinkedList<>();
//新建一个list，记录结点的状态是否已经被访问过
ArrayList<Node> list = new ArrayList<>();
// stack.push(root);
Node proot;
Node node = root;
int flag;
//首先检查完树的左子树，再右子树，最后将根节点输出
while(node != null || stack.size()>0){
//将最左子树添加完毕
while(node != null){
stack.push(node);
node = node.leftChild;
}
//和中序遍历相似，为先输出左结点，但是做结点输出完毕之后，不能直接将根结点弹出，而是必须先将右结点弹出，
//最后再将根结点弹出来，就会牵扯到一个根结点的访问状态的问题，是否已经被遍历过了
//利用一个list集合记录已将被遍历过的根结点，防止产生死循环
if(stack.size()> 0 ){
Node peek = stack.peek();
if(peek.rightChild!=null){
boolean con = list.contains(peek);
if(con ==true){
Node pop = stack.pop();
System.out.print(pop.data+" ");
}else{
list.add(peek);
node = peek.rightChild;
}
}else{
Node pop = stack.pop();
System.out.print(pop.data+" ");
}
}
}
}
@Override
public void inOrderByStack() {
System.out.println("中序栈遍历:");
// 创建栈,和先序遍历类似，直接入栈直到没有最左左子树可以入栈
Deque<Node> stack = new LinkedList<Node>();
Node node = root;
//添加暂时完毕，开始pop元素
while(node!=null || stack.size()>0 ){
while(node!=null){
stack.push(node);
node = node.leftChild;
}
//一边pop并且一边进行判断，右结点不会null的，右子树，继续按照添加方法，将最左结点全部添加进去
if(stack.size()>0){
Node pop = stack.pop();
System.out.print(pop.data+" ");
if(pop.rightChild!=null){
node = pop.rightChild;
}
}
}
System.out.println();
}
}
https://blog.youkuaiyun.com/eeeemon/article/details/109663628
255
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
