分治法题目（二叉树为主）

归并排序

/* 初始版本，升序排序 */
/* 时间复杂度：O(nlbn) 将n个待排序记录归并次数为lbn，一趟归并O(n)
   空间复杂度：O(n) 递归栈最大深度为[lbn] + 1 ，而辅助数组大小为n
   稳定：无论最好还是最坏情况时间复杂度都是O(nlbn)
*/

void Merge(int* arr, int n){
	int temp[n]; //辅助数组
	int b=0;  //辅助数组的起始位置
	int mid=n/2;  //mid将数组从中间划分，前一半有序，后一半有序
	int first=0, second=mid;  //两个有序序列的起始位置
	while(first < mid && second < n){
		if(arr[first] <= arr[second])
			temp[b++] = arr[first++];
		else
			temp[b++] = arr[second++];
	}
	while(first < mid)
		temp[b++] = arr[first++];
	while(second < n )
		temp[b++] = arr[second++];
	for(int i=0; i < n; ++i)
		arr[i] = temp[i];

}
void MergeSort(int* arr, int n){
		if(n <=1 ) return;
		MergeSort(arr, n/2);
		MergeSort(arr + n/2, n-n/2);
		Merge(arr, n);
} 

快速排序

选定一个基准base(一般选择当前数组最左侧元素)，在数组两端设置指针，从左往右寻找大于基准的数，从右往左找小于基准的数，交换两个数，直至左端指针与右端指针重合。将基准数与当前位置的数进行交换，继续递归基准左边和基准右边数组，直至排序完成。

vector<int> quickSort(vector<int>& list, int left, int right){
	if (left >= right) return;
	int i=left;
	int j=right;
	int base = list[left];
	while(i < j){
		while(a[j] >= base && i<j)
			--j;
		while(a[i] <= base && i<j)
			++i;
		if(i < j){
			int temp = a[i];
			a[i]=a[j];
			a[j]=temp;
		}		
	}
	a[left]=a[i];
	a[i]=base;
	quickSort(a, left, i-1);
	quickSort(a, i+1, right);
}

寻找二叉树最大深度

有两个注意点

1. 利用分治法进行递归，可以分为左子树和右子树，从下往上进行计数。
2. 递归的返回条件，节点为空时返回0。

int maxDepth(treeNode* root){
	if (nullptr==root) return 0;
	left = maxDepth(root->left);
	right = maxDepth(root->right);
	return max(left,right)+1;
}

判断二叉树是否高度平衡

高度平衡树定义：任一节点对应的两棵子树的最大高度差<= 1。
解题思路：分治法，左子树平衡&&右子树平衡&&左右两边高度<=1。
这里就有一个问题，函数既要返回左子树的高度，又要返回左子树是否平衡，需要返回两个数据，可以考虑结构体。但是可以取巧使用一个变量，代表左子树的高度(>0)，-1代表不平衡。

int treeDepth(treeNode* root){
	if (nullptr==root) return 0;
	int left = treeDepth(root->left);
	int right = treeDepth(root->right);	
	if(-1 == left || -1== right || left - right > 1 || right - left > 1) return -1;
	return left>right? left+1:right+1;
}
bool isBalanced(treeNode* root){
	if(-1 == treeDepth(root)) return false;
	return true;
}

二叉树—寻找最近公共祖先

题目描述：给定一个二叉树，找到该树中两个指定节点的最近公共祖先。
分析
当root是p,q的最近公共祖先，则分为以下几种情况:

1. p和q在root的两侧，即分别位于左、右子树
2. p=root，且q在root的左或右子树中；
3. q=root，且p在root的左或右子树中；

采用递归对二叉树进行先序遍历，当遇到节点p或q时返回。从底至顶回溯，当节点p，q在节点root的两侧时，节点root即为公共祖先，向上返回root。
递归分析：

1. 终止条件：
   • 越过叶子结点，返回null。
   • 找到p或q结点，返回p或q。
2. 开始递归
   • 递归左子树，返回值记为left。
   • 递归右子树，返回值记为right。
3. 进行判断并返回
   • left和right都为空，则root的左/右子树中都不包含p、q，返回null
   • left和right都不为空，则root为最近公共祖先。
   • left为空，right不为空：p,q都不在root的左子树中，直接返回right。具体可分为以下两种情况：
     • p、q其中一个在root的右子树中。
     • p、q两个都在root的右子树中。
   • left不为空，right为空，与上一种情况同理。

TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
        if(NULL==root) return NULL;
        if(p==root || q==root) return root;
        TreeNode* left = lowestCommonAncestor(root->left, p, q);
        TreeNode* right = lowestCommonAncestor(root->right, p, q);
        if(NULL != left && NULL != right) 
        	return root;
        if(NULL != left)
        	return left;
        if(NULL != right)
        	return right;
        return NULL;
    }

判断二叉搜索树

题目描述：输入一个二叉树的根节点，判断是否为二叉搜索树。
二叉搜索树定义：

• 节点的左子树只包含小于当前节点的数。
• 节点的右子树只包含大于当前节点的数。
• 任一节点都需满足上述条件

解题思路1：中序遍历，判断是否为升序序列。
解题思路2：分治法，判断当前节点是否满足，判断左子树、右子树是否满足。
采用递归对二叉树进行遍历，这里有一个容易出错的点，当前节点在左子树中时–不只是小于父亲节点的值，而是小于根节点的值，在右子树中同理。
递归分析：
1. 越过叶子结点，返回true。
2. 判断当前节点是否在（l,r）界限内，注意为开区间，如果当前节点的值与上界或下界相等，也是不满足条件的。
3. 判断左子树和右子树。

void helper(TreeNode* root, long lower, long upper){
		if (nullptr==root) return true;
		if (root->val <= lower || root->val >= upper) return false;
		return helper(root->left, lower, root->val) && helper(root->right, root->val, upper);
}

void isValidBST(TreeNode* root){
		//-2^31 <= Node.val <= 2^31 - 1
		//LONG_MIN=-2^63   LONG_MAX=2^63-1
		return helper(root, LONG_MIN, LONG_MAX);
}