二叉搜索树 & 653. 两数之和 IV - 输入 BST

今天借助本题，复习一下二叉搜索树这一知识点，并体会利用set和BST的性质来巧妙解决问题的方法。

一、二叉搜索树（Binary Search Tree）
    二叉搜索树是一种特殊的二叉树。如果一棵树是二叉搜索树，那么它的左子树和右子树都是一棵二叉搜索树，并且它左子树的所有键值都小于根节点的键值、右子树的所有键值都大于根节点的键值。

    二叉搜索树的一个基本操作就是进行查找。它的过程与顺序数组的二分查找类似，比根节点大，则右移；比根节点小，则左移。
（P.S. BST中最小元素一定在最左结点、最大元素一定在最右结点）

Treenode* find(Treenode* BSTnode, int x){
	while(BSTnode != NULL){
		if(x > BSTnode->val){ 
		//显然，当x大于当前根结点的值时，x只可能出现在右侧
			BSTnode = BSTnode->rightchild; //向右推进
		}
		else if(x < BSTnode->val){
			BSTnode = BSTnode->leftchild;
		}
		else{
			break;
		}
	}
	return BSTnode; //没找到返回NULL
}

二叉搜索树的建立
    有了对BST的查找操作的实现思路，对其进行建立就不困难了。因为，一棵二叉搜索树的插入新节点，就是要在当前已经存在的二叉搜索树中先查到一个合适的空位（如果已经存在这个值，可以不进行插入操作），然后新建一个叶子结点。
    这个空位如何确定呢？根据BST的性质，同时回忆刚刚的find函数，一个根结点的左子树上的值一定小于这个根节点，右子树上的值一定大于这个根节点，同时，这个待插入结点还不在树上，那么我们一定可以找到一个为null的“空位”，这个空位正好满足find的要求。由此，我们可以给出建树的代码。

//上一个find采用的是非递归方法，这次采用递归方法来建树
TreeNode insertNode(Treenode* root, int x){
	if (root==NULL){ 
	//特殊情况root为空，这包含两种情况，一是建树的开始，直接建立整个树的根节点
	//另一种情况是递归的终止条件，找到了“空位”即将插入结点
	root = (Treenode*)malloc(sizeof(struct Treenode));
	root->data = x;
	root->left = root->right = NULL; //永远不要忘了链表的结束！
	}
	else{
	//在这里就要借鉴find的思路了、寻找X直到root为null，即为要添加新节点的空位。
  	if (x < root->value){ 
  	//递归的理解：发现待插元素小于根节点的值，因此应向左推进，直到root = null
		root = insertNode(root->left,x);
	}
	else if( x > root->node){
		root = insertNode(root->right,x);
	}
	else{
		//这里可以什么都不做 
	}
	//注意，这里要返回根节点的值，是为了追踪root最终插入到了哪里。
	//这里为了与find函数思想保持一致，故保留了相似的结构
	return root;
	}
}

二叉搜索树的删除操作
        BST的删除操作比较复杂。
    首先，容易想到，如果要删除的是叶子结点，那么一定可以直接进行删除操作。因为这并不会影响整个树的正确性。
    第二种情况是待删除的结点只有一个子树/叶子结点。考虑BST上，沿着一个方向的值是单调的。那么，删除这个结点的话，如果把它的子结点重新接到它的父节点上，一定不会改变这个单调性。因此，删除时，要将其父节点的指针指向它的子节点即可。
    最后，如果要删除的结点具有两个子树。此时的一种解决办法是——从将被删除结点的左子树或是右子树的结点之间选出一个新结点。这个新节点可以选择右子树的最小元素或是左子树的最大元素（同时，这个新选中的结点一定最多只有一个子节点），之后调用情况2的方法进行操作即可。

下面展示部分逻辑

if (node->left && node->right){ //第三种情况
	min = getMin(node->right); //这里去右子树的最小值
	node->data = min->data;
	Delete(node->right,min->data); //在右子树中，删除具有最小值的结点
}
else if (node->left == null && node->right==NULL){ //第一种情况
	temp = node;
	node = null;
	free(temp);
}
else{
	temp = node;
	if (node->left == NULL)	node = node->right;
	else node = node->left;
	free(temp);
}

---

二、653. 两数之和 IV - 输入 BST
    题目思路分析： 本题的目标非常明确，问在二叉搜索树中是否存在两个结点，他们的和为X。
最简单最简单的想法可能就是进行一个二重循环的遍历，把两棵树都遍历一遍，一定能给出结果。但是这样显然是不好的。不但代码复杂，而且效率很低。实际上，这种方法跟二叉搜索树毫无关系，同时也没有体现题目的重点——两个数的和。因此，我们就应该从二叉搜索树的性质入手、亦或是想一个办法来突出“和”的作用。
    首先，我们来从二叉搜索树的性质入手。本题想求得是和，而且二叉搜索树有很强的顺序特性、很容易就能想到能不能把这个BST转化成数组问题。我们知道，二叉搜索树的中序遍历就是一个有序的数组，而如果有了有序数组，我们要求两数之和，(这里不要用二重循环，要不然时间复杂度没意义了)

class Solution {
public:
	vector<int> array;  
    bool findTarget(TreeNode* root, int k) {
        middleTraverse(root);              
       	int left = 0;
       	int right = array.size()-1;
       	while(left < right){
			if (array[left] + array[right] > k)
				right--;// 和偏大，那么优先减小大的数
			else if (array[left] + array[right] < k)
				left++;
			else
				return true;
		}
		return false;
    }
    void middleTraverse(TreeNode *root){ //中序遍历
        if(root == NULL)
        	return;
        middleTraverse(root->left);
        array.push_back(root->val);
        middleTraverse(root->right);
    }
};

    那么，真的不能只遍历一遍树就实现吗？仔细思考一下。为什么很容易就想到对树进行二重循环遍历。因为我们如果对每一个树的点，都去找一下这棵树中存不存在另外一个点满足——两点之和等于X，那么一定能给出答案。
    这种方法究竟慢在哪里呢？很明显，在第一次遍历的时候，事实上我们已经看到了树的全部结点，但是我们的简单二重循环的思想并没有“记录”他们。因此在判断下一个点时，原先已经遍历（发现过了）的点没有用上。这就是只进行一次遍历的突破口。
    因此，我们如果能让程序记住已经遍历过的结点，能不能解决问题呢？看起来好像还有一个地方与二重循环的时候冲突。可能会想，当遍历刚开始的时候，我都不知道后边的结点是什么呀，这样能判断嘛？难道不是得先全遍历一次，才能记住结点的值吗？ 这恰恰是题目的巧妙之处。题目问的是“两数之和”，那么就是，前边的结点先被记录了下来，虽然当时没有找到合适的“对象”，但是，到了后边，它的另一半不就能发现它了吗？毕竟是两数之和，前面的人奉献，后边的人便找到了它珍贵的另一半呀~ 两个数齐心协力，才让时间复杂度降到了一遍遍历的复杂度啊。
    注意一个问题。在遍历的时候，有一个先判断还是先记录的问题。这里应该先进行判断。否则，对于一种特殊情况——即BST中存在X/2 这个元素，如果先记录再判断，它就会错误地发现自己可以找到“另一半”。但事实上，这只是一个数自己被判断了两次而已。这个问题要注意。

    具体到实现上，那么就是遍历一个树，深度（？序遍历）和广度（层次）遍历都可以，在碰到一个结点的时候，先判断现有记录中是否存在K-val，存在则为true，不存在继续进行遍历，之后把自己也加到记录里边。 直到最后，就能返回出答案。 注意整合两个子树的结果时，应用OR 的逻辑，因存在一对满足条件的数就行。

上代码

// 广度优先遍历
class Solution {
public:
    bool findTarget(TreeNode* root, int k) {
        set<int> nodeset;
        queue<TreeNode*> queue;
        queue.push(root);
        while(!queue.empty()){ 
            TreeNode* node = queue.front();
            if (nodeset.count(k-node->val)!=0){
                return true;
            }
            nodeset.insert(node->val);
            if (node->left != NULL){
                queue.push(node->left);
            }
            if (node->right!=NULL){
                queue.push(node->right);
            }
            queue.pop();
    }
    return false;
    }
}

//深度优先遍历
bool findTarget(TreeNode* root, int k) {
        set<int> nodeSet;
        return find(nodeSet,root,k);
    }
    bool find(set<int> &nodeset,TreeNode* root,int k){
      if (root == NULL){
          return false;
      } 
      if (nodeset.count(k-root->val) != 0){
          return true;
      }
      nodeset.insert(root->val);//务必小心，如果value的值正好是k的一半，就不是“两数之和”了 所以要后加
      return find(nodeset,root->left,k) || find(nodeset,root->right,k);

为了尽量把每个地方和思想说清楚一些，话比较多，请诸位dalao见谅。