面试题54，二叉搜索树的第k大节点；面试题53：在排序数组中查找数字

/**
 * 题目二：找到0~n-1中缺失的数字
 *      一个长度为n-1的递增排序数组中的所有数字都是唯一的，并且每个数字
 *      都在范围0~n-1中。在范围0~n-1内的n个数字中有且仅有一个数字不在该数组中，请找出这个数字.
 */
public class GetMissingNumber {
    public static int getMissingNumber(int[] array,int length){
        if(array == null || length <= 0){
            return -1;
        }
        return getMissingNumber(array,length,0,length - 1);
    }

    public static int getMissingNumber(int[] array, int length, int start, int end){
        if(start > end){
            return -1;
        }
        int middleIndex = (start + end)/2;
        int data = array[middleIndex];
        if(middleIndex == data){
            start = middleIndex + 1;
        }else{
            if((middleIndex > 0 && array[middleIndex - 1] == middleIndex - 1) || middleIndex == 0){
                return middleIndex;
            }else{
                end = middleIndex - 1;
            }
        }
        return getMissingNumber(array,length,start,end);
    }

    public static void main(String[] args) {
        int[] array = {0,1,2,3,5,6};
        System.out.println(getMissingNumber(array, array.length));
    }
}

/**
 * 面试题53：题目一：数字在排序数组中出现的次数
 *      统计一个数字在排序数组中出现的次数。例如，输入排序数组{1，2，3，3，3，3，4，5}
 *      和数字3，由于3在这个数组中出现了4次。所以输出4
 */
public class GetNumberOfK {
    public static int getFirstK(int[] array,int start,int end,int k){
        if(start > end){
            return -1;
        }
        int index = (start + end) / 2;
        if(array[index] == k){
            if((index  > 0 && array[index - 1] != k ) || index == 0 ){
                return index;
            }else{
                end = index - 1;
            }
        }else if(array[index] > k){
            end = index - 1;
        }else{
            start = index + 1;
        }
        return getFirstK(array,start,end,k);
    }

    public static int getLastK(int[] array,int start,int end,int k){
        if(start > end){
            return -1;
        }
        int index = (start + end) / 2;
        int middleData = array[index];
        if(middleData == k){
            if((index < array.length - 1 && array[index + 1] != k) ||
                    index == array.length - 1){
                return index;
            }else{
                start = index + 1;
            }
        }else if(middleData > k){
            start = index + 1;
        }else{
            end = index - 1;
        }
        return getLastK(array,start,end,k);
    }

    public static int getNumberOfK(int[] array,int k){
        int number = 0;
        if(array == null || array.length <= 0){
            return -1;
        }else{
            int first = getFirstK(array,0, array.length - 1,k);
            int last = getLastK(array,0,array.length - 1,k);
            number = last - first + 1;
        }
        return number;

    }

    public static void main(String[] args) {
        int[] array = {1,2,3,3,3,3,4,5};
        System.out.println(getNumberOfK(array, 3));
    }
}

/**
 * 题目三：数组中数值和下表相等的数字
 *      假设一个单调递增的数组中的每个元素都是整数并且是唯一的，
 *      请编程实现一个函数，找出数组中任意一格数值等于其下标的元素，例如，在数组中{-3，-1，1，3，5}
 *      数字3和它的下标相等
 */
public class GetNumberSameAsIndex {
    public static int getNumberSameAsIndex(int[] array, int length){
        if(array == null || length <= 0){
            return -1;
        }
        return getNumberSameAsIndex(array, length, 0, length - 1);
    }

    public static int getNumberSameAsIndex(int[] array, int length, int start, int end){
        if(start > end){
            return -1;
        }
        int middleIndex = (start + end) / 2;
        int middleData = array[middleIndex];
        if (middleData == middleIndex){
            return middleData;
        }else if (middleData > middleIndex){
                end = middleIndex - 1;
        }else{
            start = middleIndex + 1;
        }
        return getNumberSameAsIndex(array,length,start,end);
    }

    public static void main(String[] args) {
        int[] array = {-3, -1, 1, 3, 5};
        System.out.println(getNumberSameAsIndex(array, array.length - 1));
    }
}

/**
 * 面试题54：二叉搜索树的第k大节点
 *      给定一棵二叉搜索树，请找出其中第k大的节点。
 */
public class KthNode {
    public static BinaryTreeNode kthNode(BinaryTreeNode pRoot,int k){
        if(pRoot == null | k <= 0){
            return null;
        }
        return kthBodeCore(pRoot, k);
    }

    public static BinaryTreeNode kthBodeCore(BinaryTreeNode pRoot, int k){
        BinaryTreeNode target = null;
        if(pRoot.leftNode != null){
            target = kthBodeCore(pRoot.leftNode, k);
        }

        if(target == null){
            if(k == 1){
                target = pRoot;
            }
            k -- ;
        }

        if(target == null && pRoot.rightNode != null){
            target = kthBodeCore(pRoot.rightNode, k);
        }

        return target;
    }
}