树相关知识

1. 树的结构定义

/**  Definition for a binary tree node.*/
* struct TreeNode { 
*    int val;
*      TreeNode *left;
*      TreeNode *right; 
*      TreeNode(int x) : val(x), left(NULL), right(NULL) {} 
* }; 

2. 二叉树
3. 二叉树的四种遍历：优秀解释
   1）前序遍历

//法一：递归法
class Solution {
public:    

vector<int> preorderTraversal(TreeNode* root) {        
	vector<int> res;        
	traversal(root, res);        
	return res;    
}
    
void traversal(TreeNode* root, vector<int>& res){        
	if (root == NULL)            
		return;
        res.push_back(root->val);        
        preTraversal(root->left, res);        
        preTraversal(root->right, res);    
}    
};

//法二：迭代法
class Solution {
public:
    
vector<int> preorderTraversal(TreeNode* root) { 
       	vector<int> res;        
       	stack<TreeNode*> st;        
        st.push(root);
       	   
        while(!st.empty()){            
       	    TreeNode* node = st.top();
            st.pop();
            if(node != NULL) res.push_back(node->val);
            else continue;
//因为是stack，所以right先进，left后进            
            st.push(node->right);
            st.push(node->left);        
        }        
        return res;
    }
};

2）中序遍历

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

3）后序遍历

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

4）层序遍历
使用一个队列存储每层节点，遍历该节点输出该层

class Solution {
public:    

vector<vector<int>> levelOrder(TreeNode* root) {
       vector<vector<int>> res;        
       if(root == NULL) return res;
       
       queue<TreeNode*> q;        
       q.push(root);
       
       while(!q.empty()){            
       	int size = q.size();
       	vector<int> vec;
//该处千万固定size，因为for中 q 的size是会变化的                   
       	for(int i=0; i < size; i++){
       	    TreeNode* node = q.front();
       	    q.pop();                
       	    vec.push_back(node->val);                
       	    if(node->left != NULL)                    
       	        q.push(node->left);                
       	    if(node->right != NULL)                    
       	        q.push(node->right);            
       	}
           res.push_back(vec);        
       }        
       return res;    
       }
};

3. 重建二叉树： LeetCode原题：medium
   根据一棵树的前序遍历与中序遍历构造二叉树。

class Solution {
public:    

TreeNode* buildTree(vector<int>& preorder, vector<int>& inorder) {        
	if(preorder.size() == 0 || inorder.size() == 0)            
		return NULL;                

	int pEnd = preorder.size() - 1;        
	int inEnd = inorder.size() - 1;        

	return reBuildTree(preorder, 0, pEnd, inorder, 0, inEnd);    
	}
  
TreeNode* reBuildTree(vector<int>& preorder, int pStart, int pEnd, vector<int>& inorder, int inStart, int inEnd){        
	if(inStart > inEnd || pStart > pEnd)            
		return NULL;                
	
	TreeNode* root = new TreeNode(preorder[pStart]);        
	int i = inStart;
// 找到根节点位置	
        while(i <= inEnd && inorder[i] != preorder[pStart]){            
        	i++;        
        }                

// 根据根节点和 inStart 的相对关系找到左右子树的长度
	root->left = reBuildTree(preorder, pStart+1, pStart+i-inStart, inorder, inStart, i-1);        
	root->right = reBuildTree(preorder, pStart+i-inStart+1, pEnd, inorder, i+1, inEnd);        
	return root;    
}
};

4. 删除二叉搜索树的节点：medium
   C++ 递归，引用自该处
   思路

1. 如果目标节点没有子节点，我们可以直接移除该目标节点。
2. 如果目标节只有一个子节点，我们可以用其子节点作为替换。
3. 如果目标节点有两个子节点，我们需要用其中序后继节点或者前驱节点来替换，再删除该目标节点。
   

class Solution {
public:    

TreeNode* deleteNode(TreeNode* root, int key) {
        if(root == NULL) return NULL;

	//key在左子树                
	if(root->val > key){            
	root->left = deleteNode(root->left, key);            
	return root;        
	}

	//key在右子树         
	if(root->val < key){            
	root->right = deleteNode(root->right, key);            
	return root;        
	}

//key在当前root
//root只是没有左子树        
	if(root->left == NULL){            
	TreeNode* tmp = root->right;            
	delete root;            
	return tmp;        
	}
//root只是没有右子树        
	if(root->right == NULL){            
	TreeNode* tmp = root->left;            
	delete root;            
	return tmp;        
	}
//目标点左、右子树都存在        
	TreeNode* tmp = root->right;// 找到右子树中最小的值，即进入右子树后一直向左遍历        
	while(tmp->left) tmp = tmp->left;        
	swap(root->val, tmp->val);        
	root->right = deleteNode(root->right, key);  // 进入遍历，删除key        
	return root;
    }
};