二叉树的相关程序 Java

二叉树的先序遍历，中序遍历，后序遍历

输出单层节点、检查是否为BST、中序遍历寻找下一个节点

import java.util.ArrayList;
import java.util.Stack;


public class Main {
//先序遍历
public void  PreOrder(TreeNode root){
System.out.print(root.val+" ");
if(root.left!=null){
PreOrder(root.left);
}
if(root.right!=null){
PreOrder(root.right);
}
}
public void PreOrder1(TreeNode root){
Stack<TreeNode> s = new Stack<TreeNode>();
TreeNode p = root;
while(p!=null || !s.empty()){
while(p!=null){
System.out.print(p.val+" ");
s.push(p);
p = p.left;
}
if(!s.empty()){
p = s.pop();
p = p.right;
}
}

}
//中序遍历
public void InOrder(TreeNode root){
if(root.left!=null){
InOrder(root.left);
}
System.out.print(root.val+" ");
if(root.right!=null){
InOrder(root.right);
}
}
public void InOrder1(TreeNode root){
Stack<TreeNode> s = new Stack<TreeNode>();
TreeNode p = root;
while(p!=null|| !s.empty()){
while(p!=null){
s.push(p);
p=p.left;
}
if(!s.empty()){
p = s.peek();
System.out.print(p.val+" ");
s.pop();
p = p.right;
}
}
}
//后序遍历
public void PostOrder(TreeNode root){
if(root.left!=null){
PostOrder(root.left);
}
if(root.right!=null){
PostOrder(root.right);
}
System.out.print(root.val+" ");
}
public void PostOrder1(TreeNode root){
Stack<TreeNode> s = new Stack<TreeNode>();
TreeNode cur ;
TreeNode pre = null;
s.push(root);
while(!s.isEmpty()){
cur = s.peek();
if((cur.left==null&&cur.right==null)||(pre!=null &&(pre==cur.left ||pre==cur.right))){
System.out.print(cur.val+" ");
s.pop();
pre = cur;
}else {
if(cur.left!=null)
s.push(cur.left);
if(cur.right!=null)
s.push(cur.right);
}
}
}
public void levelOrder(TreeNode root){
ArrayList<TreeNode> treeList = new ArrayList<TreeNode>();
//TreeNode p = root;
treeList.add(root);
while(!treeList.isEmpty()){
TreeNode q = treeList.get(0);
System.out.print(q.val+" ");
treeList.remove(0);
if(q.left!=null) treeList.add(q.left);
if(q.right!=null) treeList.add(q.right);
}
System.out.println();
}
/*
* 对于一棵二叉树，请设计一个算法，创建含有某一深度上所有结点的链表。
* 给定二叉树的根结点指针TreeNode* root，以及链表上结点的深度，请返回一个链表ListNode，代表该深度上所有结点的值，
* 请按树上从左往右的顺序链接，保证深度不超过树的高度，树上结点的值为非负整数且不超过100000。
*/
public ListNode levelOrderWithdept(TreeNode root,int dept){
ArrayList<TreeNode> treeList = new ArrayList<TreeNode>();
ArrayList<Integer> numList = new ArrayList<Integer>();
ArrayList<Integer> result = new ArrayList<Integer>();
//ArrayList<TreeNode> treeListResult = new ArrayList<TreeNode>();
//ArrayList<ListNode> resultList = new ArrayList<ListNode>();
int dep = 1;
int front=0;
int rear=0;
int lastIndex = rear;
if(root!=null){
treeList.add(root);
numList.add(dep);
}

dep++;
while(front<=rear){

TreeNode p = treeList.get(front);
System.out.println(p.val+" ");


if(p.left!=null){
treeList.add(p.left);
numList.add(dep);
rear++;
}
if(p.right!=null){
treeList.add(p.right);
numList.add(dep);
rear++;
}
if(front == lastIndex){
lastIndex=rear;
dep++;
}
front++;
}
/*for(int i = 0;i<numList.size();i++){
System.out.println(numList.get(i));
}*/
for(int i = 0;i<numList.size();i++){
if(numList.get(i)==dept){
result.add(i);
}
}
ListNode x = new ListNode(treeList.get(result.get(0)).val);
x.next = null;
ListNode p = x;
for(int k = 1;k<result.size();k++){
//resultList.add(treeList.get(result.get(k))) ;
ListNode q = new ListNode(treeList.get(result.get(k)).val);
q.next = null;
p.next = q;
p = q;
}
return x;
}
public boolean judgeBST(TreeNode root){
if(root == null)
return true;
else if((root.left!=null && root.left.val>root.val) )
return false;
else if((root.right!=null && root.right.val<root.val) )
return false;
else return judgeBST(root.left)&&judgeBST(root.right);
}
public int InOrder2(TreeNode root, int num){
Stack<TreeNode> s = new Stack<TreeNode>();
ArrayList<TreeNode> relt = new ArrayList<TreeNode>();
TreeNode p = root;
while(p!=null|| !s.empty()){
while(p!=null){
s.push(p);
p=p.left;
}
if(!s.empty()){
p = s.peek();
//System.out.print(p.val+" ");
relt.add(p);
s.pop();
p = p.right;
}
}
int i = 0;
for( i = 0;i<relt.size();i++){
if(relt.get(i).val==num)
break;
}
return relt.get(i+1).val;
}
/*
* 测试
*/
public static void main(String[] args) {
// TODO Auto-generated method stub


TreeNode root = new TreeNode(5);
TreeNode l1 = new TreeNode(6);
TreeNode l2 = new TreeNode(7);
TreeNode l3 = new TreeNode(8);
TreeNode l4 = new TreeNode(9);
TreeNode l5 = new TreeNode(10);
TreeNode l6 = new TreeNode(11);
TreeNode l7 = new TreeNode(12);
TreeNode l8 = new TreeNode(13);
TreeNode l9 = new TreeNode(14);
TreeNode l10 = new TreeNode(15);
root.left = l1;
root.right = l2;

l1.left = l3;
l1.right = l4;

l2.left = l5;
l2.right = l6;

l3.left = l7;
l3.right = l8;

l4.left = l9;
l4.right = l10;
//先序遍历
new Main().PreOrder(root);
System.out.println();
new Main().PreOrder1(root);
System.out.println();
//中序遍历
new Main().InOrder(root);
System.out.println();
new Main().InOrder1(root);
System.out.println();
//后序遍历
new Main().PostOrder(root);
System.out.println();
new Main().PostOrder1(root);
System.out.println();
//层次遍历
new Main().levelOrder(root);
System.out.println();
//输出单层节点


new Main().levelOrderWithdept(root,4);
ListNode x = new Main().levelOrderWithdept(root, 3);
while(x!=null){
System.out.println(x.val);
x = x.next;
}


System.out.println(new  Main().judgeBST(root));
TreeNode root1 = new TreeNode(5);
TreeNode n1 = new TreeNode(3);
TreeNode n2 = new TreeNode(6);
root1.left = n1;
root1.right = n2;
System.out.println(new  Main().judgeBST(root1));

System.out.println(new Main().InOrder2(root, 9));
}


}
class TreeNode{
int val;
TreeNode left;
TreeNode right;
public TreeNode(int val){
this.val = val;
}
}
/*
 * 为以链表形式显示节点
 */
class ListNode{
int val;
ListNode next = null;
ListNode(int val){
this.val = val;
}
}