算法通关村第九关——透彻理解二叉树中序遍历的应用

1.有序数组转为二叉搜索树

LeetCode108给你一个整数数组nums,其中元素已经按升序排列，请你将其转换为一棵高度平衡二叉搜索树。
高度平衡二叉树是一裸满足「每个节点的左右两个子树的高度差的绝对值不超过1」的二叉树。

public static TreeNode sortedArrayToBST(int[] nums) {
        return dfs(nums, 0, nums.length - 1);
    }

    private static TreeNode dfs(int[] nums, int lo, int hi) {
        if (lo > hi) {
            return null;
        }
        // 以升序数组的中间元素作为根节点 root。
        int mid = lo + (hi - lo) / 2;
        TreeNode root = new TreeNode(nums[mid]);
        // 递归的构建 root 的左子树与右子树。
        root.left = dfs(nums, lo, mid - 1);
        root.right = dfs(nums, mid + 1, hi);
        return root;
    }

2.寻找两个正序数组的中位数

LeetCode4给定两个大小分别为m和n的正序（从小到大）数组nums1和nums2。请你找出并返回这两个正序数组的中位数。算法的时间复杂度应该为O(log(m+n)。

k=（m+n）/2，可以归纳出以下几种情况：

因此我们可以归纳出以下几种情况：

·如果LA[k/2-1]<LB[k/2-1],则比LA[k/2-1]小的数最多只有A的前k/2-1个数和LB的前k/2-1个
数，即比LA[k/2-1]小的数最多只有k-2个，因此LA[k/2-1]不可能是第k个数，LA[0]到
LA[k/2-1]也都不可能是第k个数，可以全部排除。
·如果LA[k/2-1]>LB[k/2-1],则可以排除LB[0]到LB[k/2-1]。也就是一次砍掉一半。
·如果LA[k/2-1]=LB[k/2-1],则可以归入第一种情况处理。

处理边界问题：

·如果LA[k/2-1]或者B[k/2-1]越界，那么我们可以选取对应数组中的最后一个元素。在这种情况
下，我们必须根据排除数的个数减少k的值，而不能直接将k减去k/2。
·如果k=1,我们只要返回两个数组首元素的最小值即可。第3

class Solution{
	public double findMedianSortedArrays(int[] nums1,int[] nums2){
		int length1 = nums1.length,length2 = nums2.length;
		int totalLength = length1 + length2;
		if (totalLength % 2 == 1){
			int midIndex = totalLength / 2;
			double median = getKthElement(nums1,nums2,midIndex +1);
			return median;
		} else {
			int midIndex1 = totalLength / 2 - 1, midIndex2 = totalLength / 2;
			double median =(getKthElement(nums1,nums2,midIndex1 + 1)+getKthElement(nums1,nums2,midIndex2 + 1)) / 2.0;
			return median;
		}
	}

	public int getKthElement(int[] nums1,int[] nums2,int k){
		int length1 = nums1.length, length2 = nums2.length;
		int index1 = 0,index2 = 0;
		while (true){
			//边界情况
			if (index1 == length1){
				return nums2[index2 + k - 1];
			}
			if (index2 == length2){
				return nums1[index1 + k - 1];
			}
			if(k == 1){
				return Math.min(nums1[index1],nums2[index2]);
			}
			//正常情况
			int half = k / 2;
			int newIndex1 = Math.min(index1 + half, length1) - 1;
			int newIndex2 = Math.min(index2 + half, length2) - 1;
			int pivot1 = nums1[newIndex1], pivot2 = nums2[newIndex2];
			if (pivot1 <= pivot2){
				k -= (newIndex1 - index1 + 1);
				index1 = newIndex1 + 1;
			} else {
				k -= (newIndex2 - index2 + 1);
				index2 = newIndex2 + 1;
			}
		}
	}
}