树的前序、中序、后序遍历的JAVA实现

【注】后续实现第二种方法暂时未解出

  1 package com.exe4.offer;
  2
  3 import java.util.Stack;
  4
  5 /**
  6  * 前序、中序、后序遍历方法
  7  * @author WGS
  8  *
  9  */
 10 public class BianliOfBinarryTree {
 11      public static class TreeNode {
 12             int val = 0;
 13             TreeNode left = null;
 14             TreeNode right = null;
 15
 16             public TreeNode(int val) {
 17                 this.val = val;
 18
 19             }
 20      }
 21     /**
 22      * 方法一:大话数据结构中简便方法,可实现操作。
 23      * @param args
 24      */
 25
 26     public void preOrder(TreeNode node){
 27         if(node==null) return;
 28         System.out.print(node.val+"  ");
 29         preOrder(node.left);
 30         preOrder(node.right);
 31     }
 32     public void inOrder(TreeNode node){
 33         if(node==null) return;
 34         inOrder(node.left);
 35         System.out.print(node.val+"  ");
 36         inOrder(node.right);
 37     }
 38     public void postOrder(TreeNode node){
 39         if(node==null) return;
 40         postOrder(node.left);
 41         postOrder(node.right);
 42         System.out.print(node.val+"  ");
 43     }
 44     /**
 45      * 方法二:剑指offer中的方法:加入栈操作
 46      * @param args
 47      */
 48     public void preOrder2(TreeNode node){
 49         Stack<TreeNode> stack=new Stack<TreeNode>();
 50
 51         while(node!=null || !stack.empty()){
 52             //先遍历左子树
 53             while(node!=null){
 54                 System.out.print(node.val+"  ");
 55                 stack.push(node);
 56                 node=node.left;//左子树遍历结束后,node==null,跳出此循环
 57             }
 58             //左子树遍历结束,继续遍历右子树
 59             if(!stack.isEmpty()){
 60                 node=stack.pop();//一直返回,直到根节点处,node==null,即stack==isEmpty()
 61                 node=node.right;
 62             }
 63         }
 64     }
 65     public void inOrder2(TreeNode node){
 66         Stack<TreeNode> stack=new Stack<TreeNode>();
 67         while(node!=null || !stack.isEmpty()){
 68
 69             while(node!=null){
 70                 stack.push(node);//8 6  5
 71                 node=node.left;    //6  5  null
 72             }
 73
 74             if(!stack.isEmpty()){
 75                 node=stack.pop();//5  6
 76                 System.out.print(node.val+"  ");//5  6
 77                 node=node.right;//null
 78             }
 79         }
 80     }
 81     //后序遍历暂时还不会
 82     /*public void postOrder2(TreeNode node){
 83         Stack<TreeNode> stack=new Stack<TreeNode>();
 84         while(node!=null ||  !stack.isEmpty()){
 85             while(node!=null){
 86                 stack.push(node);//8 6 5  7
 87                 node=node.left;//6 5 null null
 88             }
 89             if(!stack.isEmpty()){
 90                 node=stack.pop();//5 6     7
 91                 node=node.right;//null 7  null
 92
 93             }
 94
 95         }
 96     }*/
 97
 98     public static void main(String[] args) {
 99             TreeNode root = new TreeNode(8);
100             TreeNode node1 = new TreeNode(6);
101             TreeNode node2 = new TreeNode(10);
102             TreeNode node3 = new TreeNode(5);
103             TreeNode node4 = new TreeNode(7);
104             TreeNode node5 = new TreeNode(9);
105             TreeNode node6 = new TreeNode(11);
106
107             root.left = node1;
108             root.right = node2;
109             node1.left = node3;
110             node1.right = node4;
111             node2.left = node5;
112             node2.right = node6;
113
114             BianliOfBinarryTree bianli=new BianliOfBinarryTree();
115             bianli.preOrder(root);
116             System.out.println("《《前序遍历-------");
117             bianli.inOrder(root);
118             System.out.println("《《中序遍历-------");
119             bianli.postOrder(root);
120             System.out.println("《《后序遍历-------");
121             bianli.preOrder2(root);
122             System.out.println("方法二:《《前序遍历-------");
123             bianli.inOrder2(root);
124             System.out.println("方法二:《《中序遍历-------");
125            // bianli.postOrder2(root);
126             System.out.println("方法二:《《后序遍历-------");
127     }
128
129 }
时间: 2024-10-10 05:56:16

树的前序、中序、后序遍历的JAVA实现的相关文章

算法实验-二叉树的创建和前序-中序-后序-层次 遍历

对于二叉树的创建我是利用先序遍历的序列进行创建 能够对于树节点的内容我定义为char型变量 '0'为空,即此处的节点不存在 头文件 Tree.h //链式二叉树的头文件 #pragma once #include<iostream> #include<queue> using namespace std; class BinaryTreeNode { public: char data; BinaryTreeNode *leftChild,*rightChild; BinaryTr

二叉树的前序中序后序遍历相互求法

二叉树的前中后序遍历,他们的递归非递归.还有广度遍历,参见二叉树的前中后序遍历迭代&广度遍历和二叉树的前中后序遍历简单的递归 现在记录已知二叉树的前序中序后序遍历的两个,求另外一个.一般,这两个中一定有中序遍历. 1.已知前序和中序,求后序遍历: 前序:ABDECFG  中序:DBEAFCG 思路简单:前序的第一个节点就是根节点, 中序中找到根节点的位置,根节点之前是其左子树,之后是右子树   按此顺序,依次在左子树部分遍历,右子树部分遍历 C++ 代码: TreeNode *BinaryTre

算法进阶面试题03——构造数组的MaxTree、最大子矩阵的大小、2017京东环形烽火台问题、介绍Morris遍历并实现前序/中序/后序

接着第二课的内容和带点第三课的内容. (回顾)准备一个栈,从大到小排列,具体参考上一课.... 构造数组的MaxTree [题目] 定义二叉树如下: public class Node{ public int value; public Node left; public Node right; public Node(int data){ this.value=data; } } 一个数组的MaxTree定义如下: ◆ 数组必须没有重复元素 ◆ MaxTree是一颗二叉树,数组的每一个值对应一

前序中序后序遍历非递归实现

#include<iostream> #include<vector> #include<stack> #include<string> #include<algorithm> #include<numeric> using namespace std; class node{ public: int val; node* left; node* right; node():val(0),left(NULL),right(NULL){

已知二叉树前、中序遍历,求后序 / 已知二叉树中、后序遍历,求前序

void solve(int start,int end,int root) { // 前序和中序 -> 后序 // 每次调用solve()函数,传入pre-order的start,end,root if (start > end) // 递归边界 return; int i = start; while (i < end && in.at(i) != pre.at(root)) // 找到左右子树的分割点 i++; solve(start, i - 1, root +

经典白话算法之二叉树中序前序序列(或后序)求解树

这种题一般有二种形式,共同点是都已知中序序列.如果没有中序序列,是无法唯一确定一棵树的. <1>已知二叉树的前序序列和中序序列,求解树. 1.确定树的根节点.树根是当前树中所有元素在前序遍历中最先出现的元素. 2.求解树的子树.找出根节点在中序遍历中的位置,根左边的所有元素就是左子树,根右边的所有元素就是右子树.若根节点左边或右边为空,则该方向子树为空:若根节点 边和右边都为空,则根节点已经为叶子节点. 3.递归求解树.将左子树和右子树分别看成一棵二叉树,重复1.2.3步,直到所有的节点完成定

日常学习随笔-用链表的形式实现普通二叉树的新增、查找、遍历(前、中、后序)等基础功能(侧重源码+说明)

一.二叉树 1.二叉树的概念 二叉树是每个节点最多有两个子树的树结构.通常子树被称作"左子树"(left subtree)和"右子树"(right subtree),其次序不能任意颠倒. 2.性质 (1)若二叉树的层次从0开始,则在二叉树的第i层至多有2^i个结点(i>=0): (2)高度为k的二叉树最多有2^(k+1) - 1个结点(k>=-1). (空树的高度为-1): (3)对任何一棵二叉树,如果其叶子结点(度为0)数为m, 度为2的结点数为n,

二叉树的遍历方法之层序-先序-中序-后序遍历的简单讲解和代码示例

二叉树的基础性质及二叉树的建立参见前面两篇博文: http://blog.csdn.net/why850901938/article/details/51052936 http://blog.csdn.net/why850901938/article/details/51052156 首先为了讲解方便,我建立了如图所示的二叉树: 取名为:树A 1.何为层序遍历? 层序遍历就是按照二叉树的层次由上到下的进行遍历,每一层要求访问的顺序为从左到右: 以树A为例,层序遍历得到的结果为: 5 2 6 1

二叉树的先序-中序-后序遍历(一)-循环----绝对白痴好记的方法

接着上一篇 二叉树的先序-中序-后序遍历(一)-递归 的讲,这篇该循环遍历了. 之前一直没有找到好的方法来循环遍历树,以前我老认为有些递归的能做的东西很难换成循环实现. 后来看了一些别人写的代码,然后又问了朋友,才发现...哦,原来这样的啊,我可以自己弄个栈来维护一下. 想到了可以弄个栈以后,至少在我认为,把递归转成循环已经是可行的了,至于怎么实现,这几天在想(因为太笨,看人家的代码总看一半就不想看),今天找到了一个好用的方法,在这里分享一下. 算法的核心是:你看二叉树的时候心里怎么想的,程序就

二叉树的先序/中序/后序/层次遍历

[简介] 树形结构是一类重要的非线性数据结构,其中以树和二叉树最为常用. 二叉树是每个结点最多有两个子树的有序树.通常子树的根被称作"左子树"(left subtree)和"右子树"(right subtree).二叉树常被用作二叉查找树和二叉堆或是二叉排序树.二叉树的每个结点至多只有二棵子树(不存在度大于2的结点),二叉树的子树有左右之分,次序不能颠倒.二叉树的第i层至多有2的 i -1次方个结点:深度为k的二叉树至多有2^(k) -1个结点:对任何一棵二叉树T,