leetCode刷题day11

一：方法总结

二：题目

98.验证二叉搜索树

给你一个二叉树的根节点 root ，判断其是否是一个有效的二叉搜索树。

 public boolean isValidBST(TreeNode root) {
        return midOrder(root);
    }
    public boolean midOrder(TreeNode node){
        if (node==null)
            return true;
        if (!midOrder(node.left))
            return false;
        if (node.val<=pre)
            return false;
        pre=node.val;
        return midOrder(node.right);
    }

102.二叉树的层序遍历

给你一个二叉树，请你返回其按 层序遍历 得到的节点值。 （即逐层地，从左到右访问所有节点）。

思路：变量level记录层数

 public List<List<Integer>> levelOrder(TreeNode root) {
 List<List<Integer>> ans = new ArrayList<>();
        order(ans,root,0);
        return ans;

    }
    public void order(List<List<Integer>> ans,TreeNode node,int level){
        if (node==null)
            return;
        if (ans.size()==level)
            ans.add(new ArrayList<Integer>());
        ans.get(level).add(node.val);
        order(ans,node.left,level+1);
        order(ans,node.right,level+1);
    }

105.从前序与中序遍历序列构造二叉树

给定一棵树的前序遍历 preorder 与中序遍历  inorder。请构造二叉树并返回其根节点
 

 public TreeNode buildTree(int[] preorder, int[] inorder) {
        Map<Integer, Integer> map = new HashMap<>();
        for (int i=0;i<inorder.length;i++){
            map.put(inorder[i],i);
        }
        TreeNode root=new TreeNode(preorder[0]);
        tree(map, root,0,preorder.length-1,0,preorder);
        return root;

    }
    //i为当前子树的左边界下标，j为当然子树的右边界下标（中序遍历中），n为根在前序遍历的下标
    public void tree(Map<Integer, Integer> map,TreeNode node,int i,int j,int n,int[] preorder){
        int m=map.get(node.val);//根节点在中序中的下标
        if (m-i >0){//中序中左子树长度>0,才能加入左子结点，并向下递归
            node.left=new TreeNode(preorder[n+1]);
            tree(map,node.left,i,m-1,n+1,preorder );
        }

        if (j-m>0) {//中序中右子树长度>0,才能加入右子结点，并向下递归
            node.right=new TreeNode(preorder[n+1+m-i]);//m-i为左子树的长度
        tree(map,node.right,m+1,j,n+1+m-i,preorder);
        }
    }

142.环形链表

给定一个链表，返回链表开始入环的第一个节点。 如果链表无环，则返回 null。
思路：快慢指针，判断环是否存在，快慢指针相遇再将快指针另为head，两个指针依次想后移动，再次相遇的结点即为环的第一个结点

public ListNode detectCycle(ListNode head) {
        if (head == null) {
            return null;
        }
        ListNode slow = head, fast = head;
        while (fast != null) {
            slow = slow.next;
            if (fast.next != null) {
                fast = fast.next.next;
            } else {
                return null;
            }
            if (fast == slow) {
                ListNode ptr = head;
                while (ptr != slow) {
                    ptr = ptr.next;
                    slow = slow.next;
                }
                return ptr;
            }
        }
        return null;
    }