【LeetCode】初級演算法：樹

1. 二叉樹的最大深度

用時：0ms

class Solution {
    public int maxDepth(TreeNode root) {
        // 返回左右子樹深度的最大值，再加1
        if(root!=null){
            return Math.max(maxDepth(root.left),maxDepth(root.right))+1;
        }
        return 0;
    }
}

2. 驗證二叉搜尋樹

用時：3ms

class Solution {
    public boolean isValidBST(TreeNode root) {
        ArrayList<Integer> array=new ArrayList<>();
        func(root,array);
        for(int i=1;i<array.size();++i){
            // 兩個元素相同時為false
            if(array.get(i-1)>=array.get(i)){
                return false;
            }
        }
        return true;
    }

    // 中序遍歷後陣列為升序即為true
    public void func(TreeNode root,ArrayList<Integer> array){
        if(root!=null){
            func(root.left,array);
            array.add(root.val);
            func(root.right,array);
        }
    }
}

3. 對稱二叉樹

用時：11ms

class Solution {
    public boolean isSymmetric(TreeNode root) {
        ArrayList<Integer> array=new ArrayList<>();
        StringBuilder direcStr=new StringBuilder();
        inOrder(root,array,direcStr,'1');
        int i=0,j=direcStr.length()-1;
        while(i<j){
            // 如果方向相同，或者陣列不是迴文，則不是對稱
            if(direcStr.charAt(i)==direcStr.charAt(j)||array.get(i)!=array.get(j)){
                return false;
            }
            ++i;
            --j;
        }
        return true;
    }
    
    // 中序遍歷後陣列是迴文的，並且方向也是迴文的
    public void inOrder(TreeNode root,ArrayList<Integer> array,StringBuilder direcStr,char direc){
        if(root!=null){
            inOrder(root.left,array,direcStr,'1');
            array.add(root.val);
            direcStr.append(direc);
            inOrder(root.right,array,direcStr,'0');
        }
    }
}

4. 二叉樹的層次遍歷

用時：1ms

class Solution {
    public List<List<Integer>> levelOrder(TreeNode root) {
        List<List<Integer>> outList=new ArrayList<>();
        inOrder(root,outList,0);
        return outList;
    }
    
    // 先序遍歷的同時將每一層的結點儲存到對應層次的列表
    public void inOrder(TreeNode root,List<List<Integer>> outList,int deepth){
        if(root==null) return;
        
        // 如果深度大於外列表長度，表示左邊沒有右邊深
        while(outList.size()<=deepth){
            outList.add(new ArrayList<Integer>());
        }
        
        outList.get(deepth).add(root.val);
        inOrder(root.left,outList,deepth+1);
        inOrder(root.right,outList,deepth+1);
    }
}

5. 將有序陣列轉換為二叉搜尋樹

用時：1ms

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return convert(nums,0,nums.length-1);
    }
    
    // 每次都將子陣列的中間值作為子樹根節點
    public TreeNode convert(int[] nums,int s,int e){
        if(s>e) return null;
        int center=(s+e+1)/2; // 根據示例，偶數陣列以右邊作為center
        TreeNode curRoot=new TreeNode(nums[center]);
        curRoot.left=convert(nums,s,center-1);
        curRoot.right=convert(nums,center+1,e);
        return curRoot;
    }
}