两个链表的第一个公共结点，数字在升序数组中出现的次数，二叉树的深度，平衡二叉树（剑指offer36-39）c++版本

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

struct ListNode {
	int val;
	struct ListNode *next;
	ListNode(int x) :
		val(x), next(NULL) {
	}
};
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
		val(x), left(NULL), right(NULL) {
	}
};

class Solution {
public:	
	//JZ36 两个链表的第一个公共结点
	ListNode* FindFirstCommonNode(ListNode* pHead1, ListNode* pHead2);
	//JZ37 数字在升序数组中出现的次数
	int GetNumberOfK(vector<int> data, int k);
	int firstofk(vector<int> data, int k, int begin, int end);
	int lastofk(vector<int> data, int k, int begin, int end);
	//JZ38 二叉树的深度
	int TreeDepth(TreeNode* pRoot);
	//JZ39 平衡二叉树
	bool IsBalanced_Solution(TreeNode* pRoot);
	bool isbalanced(TreeNode* pRoot, int &depth);
};

//JZ36 两个链表的第一个公共结点
ListNode* Solution::FindFirstCommonNode(ListNode* pHead1, ListNode* pHead2) {
	//分别计算两个链表的长度，求其长度差。长链表先遍历，直到剩余的链表跟短链表一样长。
	//链表的公共结点必定位于剩余的链表中（侧着的Y形）
	if (!pHead1 || !pHead2)	return nullptr;
	int len1 = 0, len2 = 0;
	ListNode* pNode1 = pHead1; 
	ListNode *pNode2 = pHead2;
	while (pNode1) {
		pNode1 = pNode1->next;
		len1++;
	}		
	while (pNode2) {
		pNode2 = pNode2->next;
		len2++;
	}
	int deltalen = len2 - len1;
	pNode1 = pHead1, pNode2 = pHead2;
	int i = 0;
	if (deltalen < 0) {
		while (i < -deltalen) {
			pNode1 = pNode1->next;
			i++;
		}
	}
	else
		while (i < deltalen) {
			pNode2 = pNode2->next;
			i++;
		}
	while (pNode1) {
		if (pNode1 == pNode2)
			return pNode1;
		pNode1 = pNode1->next;
		pNode2 = pNode2->next;
	}
	return nullptr;
}
//JZ37 数字在升序数组中出现的次数
int Solution::GetNumberOfK(vector<int> data, int k) {
	//分别找到k在数组中起始位置和终止位置，使用二分法
	int len = data.size();
	if (len == 0 || k < data[0] || data[len - 1] < k)	return 0;
	int first = firstofk(data, k, 0, len - 1);
	int last = lastofk(data, k, 0, len - 1);
	if (first == -1 || last == -1)	return 0;
	return (last - first + 1);
}
int Solution::firstofk(vector<int> data, int k, int begin, int end) {
	if (end < begin)	return -1;
	if (begin == end && data[begin] == k)	return begin;
	int mid = (begin + end) >> 1;
	int result = -1;
	if (data[mid] == k) {
		if (mid == 0 || data[mid - 1] < k)	result = mid;
		else
		{
			result = firstofk(data, k, begin, mid - 1);
		}
	}
	else if (data[mid] > k)	result = firstofk(data, k, begin, mid - 1);
	else
	{
		result = firstofk(data, k, mid + 1, end);
	}
	return result;
}
int Solution::lastofk(vector<int> data, int k, int begin, int end) {
	if (end < begin)	return -1;
	if (begin == end && data[begin] == k)	return begin;
	int mid = (begin + end) >> 1;
	int result = -1;
	if (data[mid] == k) {
		if (mid == end || data[mid + 1] > k)	result = mid;
		else
		{
			result = lastofk(data, k, mid+1, end);
		}
	}
	else if (data[mid] > k)	result = lastofk(data, k, begin, mid - 1);
	else
	{
		result = lastofk(data, k, mid + 1, end);
	}
	return result;
}
//JZ38 二叉树的深度
int Solution::TreeDepth(TreeNode* pRoot) {
	//递归求解
	if (!pRoot)	return 0;
	int depth = 0;
	depth = max(TreeDepth(pRoot->left), TreeDepth(pRoot->right))+1;
	return depth;
}
//JZ39 平衡二叉树
bool Solution::IsBalanced_Solution(TreeNode* pRoot) {
	int depth = 0;
	return isbalanced(pRoot, depth);
}
bool Solution::isbalanced(TreeNode* pRoot, int &depth) {//深度是结点到叶结点之间的路径长度，后根遍历
	if (!pRoot) {
		depth = 0;
		return true;
	}
	int left, right;
	if (isbalanced(pRoot->left, left) && isbalanced(pRoot->right, right)) {
		int diff = left - right;
		if (diff <= 1 && diff >= -1) {
			depth = 1 + (left > right ? left : right);
			return true;
		}
	}
	return false;
}


//JZ36 两个链表的第一个公共结点
void test1() {
	ListNode* pHead1 = new ListNode(1);
	pHead1->next = new ListNode(2);
	pHead1->next->next = new ListNode(3);
	ListNode* p = new ListNode(4);
	pHead1->next->next->next = p;
	p->next = new ListNode(5);
	p->next->next = new ListNode(6);
	ListNode* pHead2 = new ListNode(7);
	pHead2->next = p;
	Solution s;
	cout << (s.FindFirstCommonNode(pHead1, pHead2))->val;
	return;
}
//JZ37 数字在升序数组中出现的次数
void test2() {
	vector<int> temp = { 1,3,3,3,3,4,5 };
	int k = 2;
	Solution s;
	cout << s.GetNumberOfK(temp, k);
	return;
}
//JZ38 二叉树的深度
void test3() {
	TreeNode* root = new TreeNode(1);
	root->left = new TreeNode(2);
	root->right = new TreeNode(3);
	Solution s;
	cout << s.TreeDepth(root);
	return;
}

int main() {
	//test1();
	//test2();
	test3();
	//test4();
	system("pause");
	return 0;
}