题目：对称树的判断

1、对称树例图（以二叉树为例）

 

                                              图1                                                                        图2

2、非对称树例图（以二叉树为例）

                                          图3                                                                         图4

3、分析

我们可以用Object数组存入节点，如图一：[1,2,2,3,4,4,3]，图二：[1,2,2,null,4,4,null]，图三：[1,2,2,3,4,4,null]，图四：[1,2,2,3,null,4,null]

（1）获取树的深度

   /**
     * 获取树的深度
     * @param N  ---- 树的节点数
     * @param f  ---- 树的类别（二叉树、三叉树......）
     * @return
     */
    private static int powN(int N,int f){
       int sum = 0;
        for (int i = 0; i < N/2 ; i++) {
           int j =  (int)Math.pow(f,i);
           sum+=j;
           if (sum == N) return i+1;
        }
        return Integer.MIN_VALUE;
    }

（2）获取当前深度的首位下标

 /**
     * 获取当前起始下标
     * @param k ----- 当前深度
     * @param f ----- 树的类别
     * @return
     */
    private static int startIndex(int k,int f){
        int index = 0;
        if(k == 1) return index;
        for (int i = 0; i < k - 1 ; i++) {
            index += (int)Math.pow(f,i);
        }
        return index;
    }

（3）判断当前数据是否是回文数

/**
     * 判断数组是否回文数
     * @param object
     * @return
     */
    private static boolean judgeArray(Object[] object){
        int i = 0;
        int j = object.length - 1;
        while(i <= j){
            if(object[i] == object[j]){
                i++;
                j--;
                continue;
            }
            return false;
        }
        return true;
    }

4、代码

public class TreeTest {
    public static void main(String[] args) {
       // Object[] o = {1,2,2,3,4,4,3};
        //Object[] o = {1,2,2,3,4,4,3,5,null,7,8,8,7,null,5};
        //Object[] o = {1,2,2,3,4,4,3,5,6,7,8,8,7,null,5};
        Object[] o = {1,2,3,2,8,null,10,11,12,11,10,null,8};
        //boolean b = judge(o,2);
        boolean b = judge(o,3);
        System.out.println("=================" + b);
    }

    private static boolean judge(Object[] object,int f){
        if(object == null || object.length <= 0) return false;
        if(object.length == 1) return true;
        int N = object.length;
        //算出深度
        int K = powN(N,f);
        if(K == Integer.MIN_VALUE) return false;
        //深度遍历
        for (int i = 1; i <= K ; i++) {
            //获取当前深度对应的数组大小
            int z = (int)Math.pow(f,i-1);
            Object[] o = new Object[z];
            int index = startIndex(i, f);
            for (int j = 0; j < z ; j++) {
              // o[j] = object[z + j - 1];
                o[j] = object[index + j];    //复制到新数组判断
            }
            if(!judgeArray(o)) return false;   //一旦当前新数组不满足回文数，立即返回false
        }
        return true;
    }

    /**
     * 判断数组是否回文数
     * @param object
     * @return
     */
    private static boolean judgeArray(Object[] object){
        int i = 0;
        int j = object.length - 1;
        while(i <= j){
            if(object[i] == object[j]){
                i++;
                j--;
                continue;
            }
            return false;
        }
        return true;
    }

    /**
     * 获取树的深度
     * @param N  ---- 树的节点数
     * @param f  ---- 树的类别（二叉树、三叉树......）
     * @return
     */
    private static int powN(int N,int f){
       int sum = 0;
        for (int i = 0; i < N/2 ; i++) {
           int j =  (int)Math.pow(f,i);
           sum+=j;
           if (sum == N) return i+1;
        }
        return Integer.MIN_VALUE;
    }


    /**
     * 获取当前起始下标
     * @param k ----- 当前深度
     * @param f ----- 树的类别
     * @return
     */
    private static int startIndex(int k,int f){
        int index = 0;
        if(k == 1) return index;
        for (int i = 0; i < k - 1 ; i++) {
            index += (int)Math.pow(f,i);
        }
        return index;
    }

}

5、结语：从java层面考虑，本人才疏学浅，只能想到这一个笨方法，嘿嘿嘿。欢迎各位大佬指正批评，并分享你的时间复杂度和空间复杂度达到最优的解决办法。。。谢谢谢谢【旺财】。。。。