二叉搜索树与双向链表

 对于二叉树进行非递归中序遍历，在遍历的同时调整结点之间的指针，使之成为双向链表

/*
struct TreeNode {
	int val;
	struct TreeNode *left;
	struct TreeNode *right;
	TreeNode(int x) :
			val(x), left(NULL), right(NULL) {
	}
};*/
#include <stack>
class Solution {
public:
    TreeNode* Convert(TreeNode* pRootOfTree) {
        if(!pRootOfTree) return pRootOfTree;
		TreeNode *p=pRootOfTree, *pre=NULL;
		stack<TreeNode*> s;
		bool isf=true;
		while(p || !s.empty()){
			while(p){
				s.push(p);
				p=p->left;
			}
			p=s.top(); s.pop(); //最左的叶子结点先出栈
			if(isf){ //双链表的第一个节点
				pRootOfTree=p;
				pre=pRootOfTree;
				isf=false;
			}else{
				pre->right=p;
				p->left=pre;
				pre=p;
			}
			p=p->right;//第一次之后，p=NULL,因此会执行出栈6...
		}
		return pRootOfTree;
    }
};

合并二叉树

class Solution {
public:
    /**
     * 
     * @param t1 TreeNode类 
     * @param t2 TreeNode类 
     * @return TreeNode类
     */
    TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {
        if(!t1) return t2;
        if(!t2) return t1;
        TreeNode* newh=new TreeNode(t1->val+t2->val);//根相加
        newh->left=mergeTrees(t1->left, t2->left);//对应左边合并
        newh->right=mergeTrees(t1->right, t2->right);//对应右边合并
        return newh;
    }
};

 二叉树的镜像

递归交换左右子节点

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param pRoot TreeNode类 
     * @return TreeNode类
     */
    TreeNode* Mirror(TreeNode* pRoot) {
        if(!pRoot) return pRoot;
        TreeNode* tmp=pRoot->left;
        pRoot->left=pRoot->right;
        pRoot->right=tmp;
        Mirror(pRoot->left);
        Mirror(pRoot->right);
        return pRoot;
    }
};

 判断是不是二叉搜索树

判断是不是二叉搜索树的方法：

1. 中序遍历二叉树，得到一个递增的序列，就是二叉搜索树。因为中序遍历二叉树得到的序列就是二叉树中节点的值从小到大排列的结果。

2. 对于每个节点，它的左子树中的所有节点的值都小于它的值，右子树中的所有节点的值都大于它的值。递归判断每个节点是否满足这个条件。

递归判断

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * @param root TreeNode类 
     * @return bool布尔型
     */
    bool isValidBST(TreeNode* root) {
        return isValidBST(root, nullptr, nullptr);
    }
    bool isValidBST(TreeNode* r, TreeNode* min, TreeNode* max){
        if(!r) return true;
        if((min && r->val<=min->val) || (max && r->val>=max->val)) return false;//不满足左边<r 或 右边>r  ===>  false
        //递归检查左右子树
        return (isValidBST(r->left, min, r) && isValidBST(r->right, r, max));
    }
};