二叉树的翻转及对称

二叉树的翻转其实就是在遍历的基础上将重要的操作更替为了swap（）函数，以实现左右孩子的翻转操作。

判断二叉树是否对称则需要理解其中的思想：分为外侧和内侧，外侧和外侧比较，内侧和内侧比较。同时需要注意代码的逻辑性进行编写。

代码仅实现单个接口，需要另取函数去调用！

//翻转二叉树(递归)
	TreeNode* reverseTree(TreeNode* root) {
		if (root == NULL) return root;
		swap(root->left, root->right);
		if (root->left) reverseTree(root->left);
		if (root->right) reverseTree(root->right);
		return root;
	}
	//翻转二叉树（迭代）
	TreeNode* ReverseTree(TreeNode* root) {
		stack<TreeNode*> s;
		if (root == NULL) return root;
		s.push(root);
		while (!s.empty()) {
			TreeNode* node = s.top();
			s.pop();
			swap(node->left, node->right);
			if (node->right) s.push(node->right);
			if (node->left) s.push(node->left);
		}
		return root;
	}

	//对称二叉树（镜像）递归法
	bool CompareTree(TreeNode* left, TreeNode* right) {
		if (left == NULL && right != NULL) return false;
		else if (left != NULL && right == NULL) return false;
		else if (left == NULL && right == NULL) return true;
		else if (left->val != right->val) return false;
		bool lefttree = CompareTree(left->left, right->right);
		bool righttree = CompareTree(left->right, right->left);
		bool treesame = lefttree && righttree;
		return treesame;
	}

	//对称二叉树（镜像）迭代法
	bool compareTree(TreeNode* root) {
		if (root == NULL) return true;
		queue<TreeNode*> q;
		q.push(root->left);
		q.push(root->right);
		while (!q.empty()) {
			TreeNode* leftnode = q.front(); q.pop();
			TreeNode* rightnode = q.front(); q.pop();
			if (!leftnode && !rightnode) {
				continue;
			}
			if (!leftnode || !rightnode || leftnode->val != rightnode->val) {
				return false;
			}

			q.push(leftnode->left);
			q.push(rightnode->right);
			q.push(leftnode->right);
			q.push(rightnode->left);

		}
		return true;
	}