二叉树的结构体类:
public class BinaryTree{
private int data;
private BinaryTree leftNode;
private BinaryTree rightNode;
public void setData(int data){
this.data = data;
}
public int getData(){
return data;
}
public void setLeftNode(BinaryTree leftNode){
this.leftNode = leftNode;
}
public BinaryTree getLeftNode(){
return leftNode;
}
public void setRightNode(BinaryTree rightNode){
this.rightNode = rightNode;
}
public BinaryTree getRightNode(){
return rightNode;
}
}
二叉树的前序递归遍历:
import java.util.Stack;
public class PreOrder{
//二叉树的前序递归遍历:根左右
public static void preOrder(BinaryTree pRoot){
if(pRoot != null){
System.out.println(pRoot.getData());
preOrder(pRoot.getLeftNode());
preOrder(pRoot.getRightNode());
}
}
//二叉树的前序非递归遍历:借助于栈
public static void preOrders(BinaryTree pRoot){
if(pRoot == null){ //如果二叉树根结点为空直接返回
return;
}
Stack<BinaryTree> stack = new Stack<BinaryTree>();
stack.push(pRoot);
while(!stack.isEmpty()){
BinaryTree node = stack.pop();
System.out.println(node.getData());
if(node.getRightNode() != null){//栈是先进后出故右结点需要先进栈左结点再进栈
stack.push(pRoot.getRightNode());
}
if(node.getLeftNode() != null){
stack.push(pRoot.getLeftNode());
}
}
}
}
二叉树的中序遍历:
import java.util.Stack;
public class InOrder{
//二叉树中序递归遍历:左根右
public static void inOrder(BinaryTree pRoot){
if(pRoot != null){
inOrder(pRoot.getLeftNode());
System.out.println(pRoot.getData());
inOrder(pRoot.getRightNode());
}
}
//二叉树的中序非递归遍历:左根右,借助于栈
public static void inOrders(BinaryTree pRoot){
if(pRoot == null){ //如果二叉树为空直接返回
return;
}
Stack<BinaryTree> stack = new Stack<BinaryTree>();
BinaryTree cur = pRoot;
while(true){
while(cur!=null){//让左结点一直进栈,直到左叶子结点
stack.push(cur);
cur = cur.getLeftNode();
}
if(stack.isEmpty()){ //循环终止条件,栈为空,说明遍历结束
break;
}
cur = stack.pop();
System.out.println(cur.getData());
cur = cur.getRightNode();
}
}
}
二叉树的后序遍历
import java.util.Stack;
public class PostOrder{
//二叉树的后序递归遍历:左右根
public static void postOrder(BinaryTree pRoot){
if(pRoot != null){
postOrder(pRoot.getLeftNode());
postOrder(pRoot.getRightNode());
System.out.println(pRoot.getData());
}
}
//二叉树的后序非递归遍历:左右根,借助于两个栈可以实现
public static void postOrders(BinaryTree pRoot){
if(pRoot == null){
return ;
}
Stack<BinaryTree> stack = new Stack<BinaryTree>();
Stack<BinaryTree> stack1 = new Stack<BinaryTree>();
stack.push();
while(!stack.isEmpty()){
BinaryTree node = stack.pop();
stack1.push(node);
if(node.getLeftNode()!=null){
stack.push(node.getLeftNode());
}
if(node.getRightNode()!=null){
stack.push(node.getRightNode());
}
}
while(!stack1.isEmpty()){
System.out.println(stack1.pop().getData());
}
}
}
二叉树的层序遍历
import java.util.LinkedList;
import java.util.Queue;
public class BFS{
//二叉树层序遍历,不换行输出
public static void bfs(BinaryTree pRoot){
if(pRoot == null){
return;
}
Queue<BinaryTree> queue = new LinkedList<BinaryTree>();//借助队列的先进先出特性
queue.offer(pRoot);
while(!queue.isEmpty()){
BinaryTree node = queue.poll();
System.out.print(node.getData()+" ");
if(node.getLeftNode()!=null){
queue.offer(node.getLeftNode());
}
if(node.getRightNode()!=null){
queue.offer(node.getRightNode());
}
}
}
//二叉树的层序遍历,换行输出
public static void bfs1(BinaryTree pRoot){
if(pRoot == null){
return;
}
Queue<BinaryTree> queue = new LinkedList<BinaryTree>();//借助于队列的先进先出特性
queue.offer(pRoot);
while(!queue.isEmpty()){
int len = queue.size();
for(int i = 0; i < len; i++){
BinaryTree node queue.poll();
System.out.print(node.getData()+" ");
if(node.getLeftNode()!=null){
queue.offer(node.getLeftNode());
}
if(node.getRightNode()!=null){
queue.offer(node.getRightNode());
}
}
System.out.println();
}
}
}
//借助于递归求解二叉树的深度
public static int treeDepth(BinaryTree pRoot){
if(pRoot == null){
return 0;
}
int nLeft = treeDepth(pRoot.getLeft());
int nRight = treeDepth(pRoot.getRight());
return (nLeft > nRight) ? (nLeft + 1) : (nRight + 1);
}
//借助于非递归用队列求解二叉树的深度
//借助于非递归用队列求解二叉树的深度
public static int treeDepths(BinaryTree pRoot){
if(pRoot == null){
return 0;
}
Queue<BinaryTree> queue = new LinkedList<BinaryTree>();
queue.offer(pRoot);
int level = 0;//记录层数
while(!queue.isEmpty()){
int last = 0;
int nLast = queue.size();
while(last < nLast){
BinaryTree node = queue.poll();
last++;
if(node.getLeft()!=null){
queue.offer(node.getLeft());
}
if(node.getRight()!=null){
queue.offer(node.getRight());
}
}
level++;
}
return level;
}
纯记事本手写,欢迎来搞事