leetcode算法题-剑指Offer篇（18）

1、0～n-1中缺失的数字

1.1 题目描述：

一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字都在范围0～n-1之内。在范围0～n-1内的n个数字中有且只有一个数字不在该数组中，请找出这个数字。

1.2 题解

1.2.1 二分法

  public int missingNumber(int[] nums) {
        int i=0,j=nums.length-1;
        while(i<=j){
            int mid=(i+j)/2;
            if(nums[mid]==mid)i++;
            else j--;
        }
        return i;
    }

1.2.2 遍历

public int missingNumber(int[] nums) {
        if (nums[0]==1) return 0;
        for (int i = 0;i<nums.length;i++){
            if (nums[i]!=i) return i;
        }
        return nums.length;
    }

2、二叉搜索树的第k大节点

2.1 题目描述：

给定一棵二叉搜索树，请找出其中第k大的节点。

2.2 题解

2.2.1 倒中序遍历

     public int kthLargest(TreeNode root, int k) {
        ArrayList<Integer> list = new ArrayList<>();
        help(root, list);
        return list.get(k-1);
    }

    public void help(TreeNode root, ArrayList<Integer> list) {
        if (root != null) {//按右子节点、父节点、左子节点的顺序存入list
            help(root.right,list);
            list.add(root.val);
            help(root.left,list);
        }
    }

2.2.2 倒中序遍历(优解)

  	int res, k;
    public int kthLargest(TreeNode root, int k) {
        this.k = k;
        dfs(root);
        return res;
    }
    void dfs(TreeNode root) {
        if(root == null) return;
        dfs(root.right);
        if(k == 0) return;
        if(--k == 0) res = root.val;
        dfs(root.left);
    }

3、二叉树的深度

3.1 题目描述：

输入一棵二叉树的根节点，求该树的深度。从根节点到叶节点依次经过的节点（含根、叶节点）形成树的一条路径，最长路径的长度为树的深度。

3.2 题解

3.2.1 深度遍历

  public int maxDepth(TreeNode root) {
            int count=0;
            int[] res=new int[1];
            help(root,count,res);

            return res[0];
        }
        void help(TreeNode root,int count,int[] res){
            if(root==null){
                if(count>res[0])
                    res[0]=count;
            }
            else{
                count++;
                help(root.left,count,res);
                help(root.right,count,res);
            }
        }

3.2.2 深度遍历（优解）

 public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        return Math.max(maxDepth(root.left), maxDepth(root.right)) + 1;
    }

3.2.3 层次遍历

 public int maxDepth(TreeNode root) {
        if(root == null) return 0;
        List<TreeNode> queue = new LinkedList<>() {{ add(root); }}, tmp;
        int res = 0;
        while(!queue.isEmpty()) {
            tmp = new LinkedList<>();
            for(TreeNode node : queue) {
                if(node.left != null) tmp.add(node.left);
                if(node.right != null) tmp.add(node.right);
            }
            queue = tmp;
            res++;
        }
        return res;
    }