递归与非递归方式判断二叉树是否对称&& 按行打印二叉树【java实现】



import java.util.LinkedList;
import java.util.Stack;

public class MirrorTree {

 
 private static class Node{
  int data;
  Node leftNode;
  Node rightNode;
  public Node(int data){
   this.data=data;
  }  
 }
 public static LinkedList<Node> buildtree(int []a){
  LinkedList<Node> nodes=new LinkedList<Node>();
  for(int i=0;i<a.length;i++){
   nodes.add(new Node(a[i]));
  }
  for(int i=0;i<(a.length-1)/2;i++){
   nodes.get(i).leftNode=nodes.get(2*i+1);
   nodes.get(i).rightNode=nodes.get(2*i+2);
  }
  return nodes;
 }
 
 //递归方式判断左右子树是否对称
 public static boolean isSymmetric(Node left,Node right){
  if(left==null&&right==null){
   return true;
  }
  if(left==null||right==null){
   return false;
  }
  if(left.data!=right.data){
   return false;
  }
  boolean i1=isSymmetric(left.rightNode, right.leftNode);
  boolean i2=isSymmetric(left.leftNode, right.rightNode);
  return i1&&i2;
 }
 public static boolean isSymmetric(Node node){
  if(node==null){
   return true;
  }
  return isSymmetric(node.leftNode, node.rightNode);
 }
 
 //迭代方式
 public static boolean isMirror(Node node){
  if(node==null){
   return true;
  }
  Stack<Node> leftStack=new Stack<Node>();
  Stack<Node> rightStack=new Stack<Node>();
  leftStack.push(node.leftNode);
  rightStack.push(node.rightNode);
  
  while(leftStack.size()>0&&rightStack.size()>0){
   Node leftNode=leftStack.pop();
   Node rightNode=rightStack.pop();
   if(leftNode==null&&rightNode==null){
    continue;
   }
   if(leftNode==null||rightNode==null){
    return false;
   }
   if(leftNode.data==rightNode.data){
    leftStack.push(leftNode.rightNode);
    leftStack.push(leftNode.leftNode);
    rightStack.push(rightNode.leftNode);
    rightStack.push(rightNode.rightNode);
   }else{
    return false;
   }
  }
  return true;
 }

public static ArrayList<ArrayList<Integer>> printtreeinmultiline(Node node){
  ArrayList<ArrayList<Integer>> lists=new ArrayList<>();
  if(node==null){
   return lists;
  }
  Queue<Node> nodes=new LinkedList<Node>();
  ArrayList<Integer> list=new ArrayList<>();
  nodes.add(node);
  int start=0;
  int end=1;
  while(!nodes.isEmpty()){
   Node n1=nodes.poll();
   list.add(n1.data);
   if(n1.leftNode!=null){
    nodes.add(n1.leftNode);
   }
   if(n1.rightNode!=null){
    nodes.add(n1.rightNode);
   }
   start++;
   if(start==end){
    end=nodes.size();
    start=0;
    lists.add(list);
    list=new ArrayList<>();
   }
  }
  return lists;  
 }
 
 public static void printmultilines(ArrayList<ArrayList<Integer>> a){
  for(int i=0;i<a.size();i++){
   ArrayList<Integer> al=a.get(i);
   for(int j=0;j<al.size();j++){
    System.out.print(al.get(j)+" ");
   }
   System.out.println();
  }
 }
 
 public static void printmultilineszhi(ArrayList<ArrayList<Integer>> a){
  int n=a.size();
  for(int i=0;i<n;i++){
   if(i%2==0){
    ArrayList<Integer> al1=a.get(i);
    for(int j=0;j<al1.size();j++){
     System.out.print(al1.get(j)+" ");
    }
   }else{
    ArrayList<Integer> al2=a.get(i);
    for(int k=al2.size()-1;k>=0;k--){
     System.out.print(al2.get(k)+" ");
    }
   }
   System.out.println();
  }
 }
 

 
 public static void main(String[] args) {
  int a1[]={1,2,3,4,5,6,7,8,9,10,11,12,13,14,15};
  LinkedList<Node> nodes=buildtree(a1);
  Node rootNode=nodes.get(0);
  System.out.println(isMirror(rootNode));
  System.out.println("------------");
  ArrayList<ArrayList<Integer>> al=printtreeinmultiline(rootNode);
  printmultilines(al);
  System.out.println("------------");
  printmultilineszhi(al);
 }

}