java二叉树递归_JAVA二叉树的几种遍历(递归，非递归)实现

首先二叉树是树形结构的一种特殊类型，它符合树形结构的所有特点。本篇博客会针对二叉树来介绍一些树的基本概念，二叉树的基本操作(存储，返回树的深度，节点个数，每一层的节点个数)，二叉树的四种遍历(层次，先序，中序，后序)

一.基本概念

二叉树有5种基本形态：

注：二叉树有序树，就是说一个节点的左右节点是有大小之分的，我们通常设定为左孩子一定大于右孩子，下面的实现都是基于这个规则的。二叉树分为三种：满二叉树，完全二叉树，不完全二叉树

二叉树的四种遍历：层次，先序，中序，后序首先是非递归实现上图的满二叉树：1.先序：根左右，用栈来实现，下面是它的流程图和入栈出栈的状态图(n是每个节点的值) 输出：12，10，9，11，15，14，16

2.中序：左根右，用栈来实现，中序的堆栈状态和先序一样，只是输出的位置不同，先序在入栈前输出，中序在出栈后输出 输出：9，10，11，12，14，15，16

3.后序：左右根，采用了两个栈 输出：9，11，10，14，16，15，12

下面是实现的代码：

//创建一个节点类

class Node {

public int key;//节点的值

public String Data;//节点存储的内容

public Node leftNode;//左孩子

public Node rightNode;//右孩子

//节点类的构造方法

public Node(int key,String Data){

this.key=key;

this.Data=Data;

this.leftNode=null;

this.rightNode=null;

}

//得到数据

public int getKey(){

return key;

}

}

public class BinaryTree {

public Node root;

public int h=0;

//插入数据

public void insert(int key,String Data){

//实例化一个节点

Node newNode=new Node(key, Data);

//判断此二叉树是否有根节点

if(root==null){

root=newNode;

}

else

{

Node current=root;

Node parent;

while(true){

parent=current;

//判断大小，决定新节点是放在左边还是右边

if(key

current=current.leftNode;//往左子树方向找

if(current==null){

parent.leftNode=newNode;//找到叶子节点

return;

}//叶子节点的If end;

}//左子树的If end;

else{

current=current.rightNode;

if(current==null){

parent.rightNode=newNode;

return;

}//叶子

}//右子树

}

}

}//insert end;

//打印

public void printlTree(Node node){

System.out.print("*");

System.out.print(node.getKey());

}

//深度

public int Height(Node node){

if(node==null){

return 0;

}

else{

int i=Height(node.leftNode);

int j=Height(node.rightNode);

return (i>j)?(i+1):(j+1);

}

}

//节点个数

public int NodeNum(Node node){

if(node==null){

return 0;

}

return NodeNum(node.leftNode)+NodeNum(node.rightNode)+1;

}

//第K层节点的个数

public int getLeafNodeNum(Node node,int i){

if(node==null){

return 0;

}

else{

if(i==0){

return 1;

}

else{

int numLeft=getLeafNodeNum(node.leftNode,i-1);

int numRight=getLeafNodeNum(node.rightNode,i-1);

return (numLeft+numRight);

}

}

}

//分层遍历

public void LevelOrder(Node node){

Queue queue=new LinkedList();

if(node==null){

return;

}

queue.add(node);

while(!queue.isEmpty()){

Node temp=queue.poll();

System.out.print("*");

System.out.print(temp.getKey());

if(temp.leftNode!=null){

queue.add(temp.leftNode);

}

if(temp.rightNode!=null){

queue.add(temp.rightNode);

}

}

}

//递归前序遍历

public void preOrder(Node node){

if(node!=null){

printlTree(node);

preOrder(node.leftNode);

preOrder(node.rightNode);

}

}

//非递归前序遍历

public void NpreOrder(Node node){

Stack sk=new Stack();

Node n=node;

while(!sk.isEmpty()||n!=null){

if(n!=null){

System.out.print("<<

System.out.print(n.getKey());

sk.push(n);

n=n.leftNode;

}

else{

n=sk.pop();;

n=n.rightNode;

}

}

}

//中序遍历

public void inOrder(Node node){

if(node!=null){

preOrder(node.leftNode);

printlTree(node);

preOrder(node.rightNode);

}

}

//非递归的中序遍历

public void NinOrder(Node node){

Stack s=new Stack();

Node n=node;

while(n!=null||!s.isEmpty()){

if(n!=null){

s.push(n);

n=n.leftNode;

}

else{

n=s.pop();

System.out.println(n.getKey());

n=n.rightNode;

}

}

}

//后序遍历

public void postOrder(Node node){

if(node!=null){

preOrder(node.leftNode);

preOrder(node.rightNode);

printlTree(node);

}

}

//非递归后序遍历

public void NpostOrder(Node node){

Stack s1=new Stack();//第一次入栈

Stack s2=new Stack();//第二次入栈

Node n=node;

while(!s1.isEmpty()||n!=null){

if(n!=null){

s1.push(n);

s2.push(n);

n=n.rightNode;

}

else{

n=s1.pop();

n=n.leftNode;

}

}

while(!s2.isEmpty()){

System.out.println("((("+s2.pop().getKey());

}

}

public static void main(String[] args) {

BinaryTree bt=new BinaryTree();

bt.insert(12, "A");

bt.insert(10, "B");

bt.insert(15, "C");

bt.insert(9, "D");

bt.insert(11, "E");

bt.insert(14, "F");

bt.insert(16, "G");

System.out.println("这个二叉树的深度："+bt.Height(bt.root));

System.out.println("这个二叉树的节点个数："+bt.NodeNum(bt.root));

System.out.println("前序遍历：");

bt.preOrder(bt.root);

System.out.println();

System.out.println("非递归前序遍历：");

bt.NpreOrder(bt.root);

System.out.println();

System.out.println("中序遍历：");

bt.inOrder(bt.root);

System.out.println();

System.out.println("非递归中序遍历：");

bt.NinOrder(bt.root);

System.out.println();

System.out.println("后序遍历：");

bt.postOrder(bt.root);

System.out.println();

System.out.println("非递归后序遍历：");

bt.NpostOrder(bt.root);

System.out.println();

System.out.println("分层遍历：");

bt.LevelOrder(bt.root);

System.out.println();

System.out.println("第二层有"+bt.getLeafNodeNum(bt.root, 2));

}

}

代码亲测可以运行(＾－＾)V

这些只是二叉树的一部分内容，希望可以帮助一些初学数据结构的亲，如果有错误的地方可以帮忙提出来的哦！！