[高频] 四.基础算法和数据结构II

662. Guess Number Game：点击打开链接

/* The guess API is defined in the parent class GuessGame.
   @param num, your guess
   @return -1 if my number is lower, 1 if my number is higher, otherwise return 0
      int guess(int num); */

public class Solution extends GuessGame {
    /**
     * @param n an integer
     * @return the number you guess
     */
    public int guessNumber(int n) {
        int start=1;
        int end=n;
        while(start+1<end){
            int mid=start+(end-start)/2;
            if(guess(mid)==0){
                return mid;
            }else if(guess(mid)==-1){                  //my number is lower than your guess
                end=mid;
            }else if(guess(mid)==1){
                start=mid;
            }
        }
        
        if(guess(start)==0){
            return start;
        }
        return end;
    }
}

61. Search for a Range：点击打开链接

思路：二分法，先找start点，再找end点

public class Solution {
    /** 
     *@param A : an integer sorted array
     *@param target :  an integer to be inserted
     *return : a list of length 2, [index1, index2]
     */
    public int[] searchRange(int[] A, int target) {
       if(A.length==0) {
           return new int[]{-1,-1};
       }

       int[] result=new int[2];
       int start=0,end=A.length-1;                   //找start点
       while(start+1<end){
           int mid=start+(end-start)/2;
           if(A[mid]==target){                       //因为找start点，在左边界，找到target后继续向左边界找
               end=mid;
           }else if(A[mid]<target){
               start=mid;
           }else{
               end=mid;
           }
       }
       if(A[start]==target){                         //因为是要找start点，因此要先写start，尽量从start方向找到
           result[0]=start;
       }else if(A[end]==target){
           result[0]=end;
       }else{
           result[0]=result[1]=-1;
           return result;
       }
       
       start=0;                                      //找end点
       end=A.length-1;
       while(start+1<end){
           int mid=start+(end-start)/2;
           if(A[mid]==target){                       //因为找end点，在右边界，找到target后继续向右边界找
               start=mid;
           }else if(A[mid]<target){
               start=mid;
           }else{
               end=mid;
           }
       }
       if(A[end]==target){                           //因为是要找end点，因此要先写end，尽量从end方向找到
           result[1]=end;
       }else if(A[start]==target){
           result[1]=start;
       }else{
           result[0]=result[1]=-1;
           return result;
       }
       return result;
    }
}

661. Convert BST to Greater Tree：点击打开链接

思路：BST的中序遍历，节点访问顺序是从小到大的

         将中序遍历左根右的顺序你过来，变成右根左，节点访问顺序是从大到小的，这样就可以反向计算累加的和，并更新结点的值

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root the root of binary tree
     * @return the new root
     */
    public TreeNode convertBST(TreeNode root) {                 //non-recursion
        if(root==null){
            return null;
        }
        
        Stack<TreeNode> stack=new Stack<>();
        TreeNode cur=root;
        int sum=0;
        while(cur!=null || !stack.isEmpty()){
            while(cur!=null){
                stack.push(cur);
                cur=cur.right;
            }
            cur=stack.pop();                                   
            cur.val+=sum;                                      //更新当前值
            sum=cur.val;                                       //更新sum
            cur=cur.left;
        }
        return root;
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    int sum=0;
    public TreeNode convertBST(TreeNode root) {                 //recursion
        helper(root);
        return root;    
    }
    
    private void helper(TreeNode root){
        if(root==null){
            return;
        }
        
        helper(root.right);
        root.val+=sum;
        sum=root.val;
        helper(root.left);
    }
}

448. Inorder Successor in Binary Search Tree：点击打开链接

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
public class Solution {
    public TreeNode inorderSuccessor(TreeNode root, TreeNode p) {
        if(root==null || p==null){
            return null;
        }
        if(root.val<=p.val){
            return inorderSuccessor(root.right, p);
        }else{
            TreeNode left=inorderSuccessor(root.left, p);
            return (left!=null)?left:root;
        }
    }
}

650. Binary Tree Leaves Order Traversal：点击打开链接

          1                   1    2             1     1
         / \                 /                     \
        2   3               2      1               3   0
       / \                 / \
      4   5               4   5    0

Output：[[4,5,3],[2],[1]

思路：根据左右子树的相对位置，拿到每一个节点的高度，相同高度的节点值放同一个list

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
public class Solution {
    /**
     * @param root the root of binary tree
     * @return collect and remove all leaves
     */
    List<List<Integer>> result=new ArrayList<>();
    public List<List<Integer>> findLeaves(TreeNode root) {
        if(root==null){
            return result;
        }
        getHeight(root);
        return result;
    }
    
    private int getHeight(TreeNode root){
        int leftHeight=root.left!=null?getHeight(root.left)+1:0;             //其实这样就是左右根的遍历，后序遍历
        int rightHeight=root.right!=null?getHeight(root.right)+1:0;          //而且根是上一层的，所有就能保证从左到右的顺序
        
        int height=Math.max(leftHeight,rightHeight);
        
        if(result.size()<=height){
            result.add(new ArrayList<Integer>());
        }
        result.get(height).add(root.val);                                    //倒着放，先放高度2，再放1，再放0
        return height;                                                       //因为先拿到高度2，然后才是后面的高度
    }
}

651. Binary Tree Vetical Order Traversal：点击打开链接

思路：从根节点开始，给序号0，然后开始层序遍历，凡是左子节点序号减1，凡是右子节点序号加 1，这样就可以把相同列的节点值放在一起

         用map建立序号和所有与该序号对应的节点值

/**
 * Definition of TreeNode:
 * public class TreeNode {
 *     public int val;
 *     public TreeNode left, right;
 *     public TreeNode(int val) {
 *         this.val = val;
 *         this.left = this.right = null;
 *     }
 * }
 */
class Node{
    TreeNode node;
    int pos;
    Node(TreeNode node,int pos){
        this.node=node;
        this.pos=pos;
    }
}
public class Solution {
    /**
     * @param root the root of binary tree
     * @return the vertical order traversal
     */
     
    public List<List<Integer>> verticalOrder(TreeNode root) {
        List<List<Integer>> result=new ArrayList<>();
        if(root==null){
            return result;
        }
        
        Map<Integer,List<Integer>> map=new HashMap<>();
        Queue<Node> queue=new LinkedList<>();
        int maxVal=Integer.MIN_VALUE;                                         //确定pos的左右边界
        int minVal=Integer.MAX_VALUE;
        queue.offer(new Node(root,0));
        while(!queue.isEmpty()){
            Node cur=queue.poll();
            minVal=Math.min(minVal,cur.pos);
            maxVal=Math.max(maxVal,cur.pos);
            if(!map.containsKey(cur.pos)){
                List<Integer> list=new ArrayList<>();
                list.add(cur.node.val);
                map.put(cur.pos,list);
            }else{
                map.get(cur.pos).add(cur.node.val);
            }
            
            if(cur.node.left!=null){
                queue.offer(new Node(cur.node.left,cur.pos-1));
            }
            if(cur.node.right!=null){
                queue.offer(new Node(cur.node.right,cur.pos+1));
            }
        }
        
        for(int i=minVal;i<=maxVal;i++){
            List<Integer> list=map.get(i);
            result.add(list);
        }
        return result;
    }
}