DAY18-力扣刷题

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

105. 从前序与中序遍历序列构造二叉树 - 力扣（LeetCode）

给定两个整数数组 preorder 和 inorder ，其中 preorder 是二叉树的先序遍历， inorder 是同一棵树的中序遍历，请构造二叉树并返回其根节点。

class Solution {


        public int priIndex;

        public TreeNode buildTree(int[] preorder, int[] inorder) {

            return buildTreeChild(preorder,inorder,0,inorder.length-1);
        }

        private TreeNode buildTreeChild(int[] preorder,int[] inorder,int inbegin,int inend) {

            //1. 没有左树 或者 没有右树了
            if(inbegin > inend) {
                return null;
            }
            //2.创建根节点
            TreeNode root = new TreeNode(preorder[priIndex]);

            //3.从中序遍历当中 找到根节点所在的下标
            int rootIndex = findIndex(inorder,inbegin,inend,preorder[priIndex]);
            if(rootIndex == -1) {
                return null;
            }

            priIndex++;
            //4. 创建左子树 和  右子树
            root.left = buildTreeChild(preorder,inorder,inbegin,rootIndex-1);

            root.right = buildTreeChild(preorder,inorder,rootIndex+1,inend);

            return root;
        }

        private int findIndex(int[] inorder,int inbegin,int inend,int key) {
            for(int i = inbegin;i <= inend;i++) {
                if(inorder[i] == key) {
                    return i;
                }
            }
            return -1;
        }
    }

2.从中序与后序遍历序列构造二叉树 

从中序与后序遍历序列构造二叉树

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗 二叉树 。

 class Solution {


    public int postIndex ;
    public TreeNode buildTree(int[] inorder, int[] postorder) {

        postIndex = postorder.length-1;

        return buildTreeChild(postorder,inorder,0,inorder.length-1);
    }

    private TreeNode buildTreeChild(int[] postorder,int[] inorder,int inbegin,int inend) {

        //1. 没有左树 或者 没有右树了
        if(inbegin > inend) {
            return null;
        }
        //2.创建根节点
        TreeNode root = new TreeNode(postorder[postIndex]);

        //3.从中序遍历当中 找到根节点所在的下标
        int rootIndex = findIndex(inorder,inbegin,inend,postorder[postIndex]);
        if(rootIndex == -1) {
            return null;
        }

        postIndex--;
        //4. 创建左子树 和  右子树

        root.right = buildTreeChild(postorder,inorder,rootIndex+1,inend);

        root.left = buildTreeChild(postorder,inorder,inbegin,rootIndex-1);

        return root;
    }

    private int findIndex(int[] inorder,int inbegin,int inend,int key) {
        for(int i = inbegin;i <= inend;i++) {
            if(inorder[i] == key) {
                return i;
            }
        }
        return -1;
    }
}

3.二叉树的层序遍历2

方法一：广度优先搜索

给你二叉树的根节点 root ，返回其节点值 自底向上的层序遍历 。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）

class Solution {
    public List<List<Integer>> levelOrderBottom(TreeNode root) {
        List<List<Integer>> levelOrder = new LinkedList<List<Integer>>();
        if (root == null) {
            return levelOrder;
        }
        Queue<TreeNode> queue = new LinkedList<TreeNode>();
        queue.offer(root);
        while (!queue.isEmpty()) {
            List<Integer> level = new ArrayList<Integer>();
            int size = queue.size();
            for (int i = 0; i < size; i++) {
                TreeNode node = queue.poll();
                level.add(node.val);
                TreeNode left = node.left, right = node.right;
                if (left != null) {
                    queue.offer(left);
                }
                if (right != null) {
                    queue.offer(right);
                }
            }
            levelOrder.add(0, level);
        }
        return levelOrder;
    }
}

 4.将有序数组转化为二叉搜索树

108. 将有序数组转换为二叉搜索树 - 力扣（LeetCode）

给你一个整数数组 nums ，其中元素已经按 升序 排列，请你将其转换为一棵平 二叉搜索树。

方法一：中序遍历，总是选择中间位置左边的数字作为根节点

class Solution {
    public TreeNode sortedArrayToBST(int[] nums) {
        return helper(nums, 0, nums.length - 1);
    }

    public TreeNode helper(int[] nums, int left, int right) {
        if (left > right) {
            return null;
        }

        // 总是选择中间位置左边的数字作为根节点
        int mid = (left + right) / 2;

        TreeNode root = new TreeNode(nums[mid]);
        root.left = helper(nums, left, mid - 1);
        root.right = helper(nums, mid + 1, right);
        return root;
    }
}

5.有序链表转换二叉搜索树

方法一：分治

class Solution {
    public TreeNode sortedListToBST(ListNode head) {
        return buildTree(head, null);
    }

    public TreeNode buildTree(ListNode left, ListNode right) {
        if (left == right) {
            return null;
        }
        ListNode mid = getMedian(left, right);
        TreeNode root = new TreeNode(mid.val);
        root.left = buildTree(left, mid);
        root.right = buildTree(mid.next, right);
        return root;
    }

    public ListNode getMedian(ListNode left, ListNode right) {
        ListNode fast = left;
        ListNode slow = left;
        while (fast != right && fast.next != right) {
            fast = fast.next;
            fast = fast.next;
            slow = slow.next;
        }
        return slow;
    }
}