剑指offerC++ (22题往后)

22.从上往下打印二叉树

• 题目 从上往下打印出二叉树的每个节点，同层节点从左至右打印。
• 思路 用队列
• 总结 空的vector 可以{}，也可以生成 vector<int> result

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

	}

};
class Solution {
public:
	vector<int> PrintFromTopToBottom(TreeNode* root) {
		vector<int> result;
		if (root == NULL)
		{
			return {};
		}
		queue<TreeNode*> q;
		q.push(root);
		while (!q.empty())
		{
			TreeNode* tmp = q.front();
			q.pop();
			result.push_back(tmp->val);
			if (tmp->left) q.push(tmp->left);
			if (tmp->right) q.push(tmp->right);

		}
		return result;
	}

};

---

23.二叉搜索树的后序遍历序列

• 题目 输入一个整数数组，判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
• 思路 递归

class Solution {
public:
	bool VerifySquenceOfBST(vector<int> sequence) {
		if (sequence.empty()) return false;
		return _VerifySquenceOfBST(sequence);

	}
	bool _VerifySquenceOfBST(vector<int> sequence)
	{
		int len = sequence.size();
		if (len <= 0) return true;
		int rootval = sequence.back();
		int split;
		for (int i = 0; i < len; i++)
		{
			if (sequence[i] >= rootval)
			{
				split = i;
				break;
			}
		}
		for (int i = split + 1; i < len-1; i++)
		{
			if (sequence[i] <= rootval)
				return false;
		}
		vector<int> seqleft(sequence.begin(), sequence.begin() + split);
		vector<int> seqright(sequence.begin() + split, sequence.end() - 1);
		return _VerifySquenceOfBST(seqleft) && _VerifySquenceOfBST(seqright);
	}
};

---

24. 二叉树中和为某一值的路径

• 题目 二叉树中和为某一值的路径
• 思路 按照先序遍历将结点加入路径，如果当前结点是叶子结点则判断当前路径和是否为目标数，若满足条件，则把当前路径保存下来，并弹出结点；每一次递归返回父结点时，也回退一个结点。
• 总结 记得pop_back()，不是非常理解，要再练，空指针可以用nullptr，vector<int> res是{}，vector<int> res()就是0。

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
class Solution {
public:
	vector<vector<int> > FindPath(TreeNode* root, int expectNumber)
	{
		if (root == NULL)return {};
		vector<vector<int>>res;
		vector<int>path;
		_FindePath(root, expectNumber, res, path);
		return res;

		
	}
	void _FindePath(TreeNode* root, int expectNumber, vector<vector<int>>&res, vector<int> &path)
	{
		if (root->left == NULL && root->right == NULL)
		{
			if (root->val == expectNumber) 
			{
				path.push_back(root->val);
				res.push_back(path);
				path.pop_back();
			}
			return;
		}
		path.push_back(root->val);
		if (root->left)
		{
			_FindePath(root->left, expectNumber-root->val, res, path);
		}
		if (root->right)
		{
			_FindePath(root->right, expectNumber-root->val, res, path);
		}
		path.pop_back();
	}
};

25.复杂链表的复制

• 题目 输入一个复杂链表（每个节点中有节点值，以及两个指针，一个指向下一个节点，另一个特殊指针random指向一个随机节点），请对此链表进行深拷贝，并返回拷贝后的头结点。（注意，输出结果中请不要返回参数中的节点引用，否则判题程序会直接返回空）
• 思路 没ac，先pass

26.二叉搜索树与双向链表

• 题目 输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。要求不能创建任何新的结点，只能调整树中结点指针的指向。
• 思路 中序遍历，连接左右就ok

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

class Solution {
public:
	TreeNode* Convert(TreeNode* pRootOfTree)
	{
		if (pRootOfTree == NULL)return NULL;
		if (pRootOfTree->left == NULL && pRootOfTree->right == NULL) return NULL;
		TreeNode* left = Convert(pRootOfTree->left);
		TreeNode *p = left;
		while (p && p->right)
		{
			p = p->right;
		}
		if (left)//这里要判断
		{
			p->right = p;
			pRootOfTree->left = p;
		}
		TreeNode* right = Convert(pRootOfTree->right);
		if (right)
		{
			pRootOfTree->right = right;
			right->left = pRootOfTree;
		}
		return left ? left : pRootOfTree;


	}
};