二叉树理论基础篇

种类：

满二叉树
完全二叉树
满二叉搜索树
平衡二叉搜索树

二叉树的定义

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

二叉树的递归遍历
前序遍历：

class Solution{
	public:
		void traversal(TreeNode* cur, vector<int>& vec)
		{
			if(cur == NULL) return;
			vec.push_back(cur->val);  //中
			traversal(cur->left, vec);  //左
			traversal(cur->right, vec); //右 
		}
		vector<int>preorderTraversal(TrerNode* root){
			vector<int>result;
			traversal(root, result);
			return result;
		} 
}; 

中序遍历：

void traversal(TreeNode* cur, vector<int>& vec) {
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    vec.push_back(cur->val);    // 中
    traversal(cur->right, vec); // 右
}

后序遍历：

void traversal(TreeNode* cur, vector<int>& vec) {
    if (cur == NULL) return;
    traversal(cur->left, vec);  // 左
    traversal(cur->right, vec); // 右
    vec.push_back(cur->val);    // 中
}

前序遍历（迭代法）

class Solution{
	public:
		vector<int>preorderTraversal(TreeNode* root)
		{
			stack<TreeNode*>st;
			vector<int>result;
			if(root ==NULL)return result;
			st.push(root);
			while(!st.empty())
			{
				TreeNode* node =st.top();
				st.pop();
				result.push_back(node->val);
				if(node->right) st.push(node->right);
				if(node->left)st.push(node->left);
				
			 } 
			 return result;
		} 
};

中序遍历（迭代法）

class Solution{
	public:
		vector<int> preorderTraversal(TreeNode* root)
		{
			stack<TreeNode*> st;
			vector<int>result;
			if(root == NULL) return result;
			st.push(root);
			while(!st.empty()){
				TreeNode* node = st.top();
				st.pop();
				result.push_back(node->val);
				if(node->right) st.push(node->right);
				if(node->left) st.push(node->left);
			}
			return result;
		}
}; 

后序遍历（迭代法）

class Solution{
	public:
		vector<int>postorderTraversal(TreeNode* root)
		{
			stack<TreeNode*>st;
			vector<int>result;
			if(root==NULL) return result;
			st.push(root);
			while(!st.empty())
			{
				TreeNode* node = st.top();
				st.pop();
				result.push_back(node->val);
				if(node->left) st.push(node->left);
				if(node->right)st.push(node->right);
			 } 
			 reverse(result.begin(), result.end());
			 return result;
		}
};

迭代法中序遍历

class Solution{
	public:
		vector<int>inorderTraversal(TreeNode* root)
		{
			vector<int>result;
			stack<TreeNode*>st;
			if(root! =NULL) st。push(root);
			while(!st.empty())
			{
				TreeNode* node = st.top();
				if(node != NULL)
				{
				   st.pop();
				   if(node->right) st.push(node->right);
				   st.push(node);
				   st.push(NULL);
				   if(node->left) st.push(node->left); 
				}
				else
				{
					st.pop();
					node  = st.top();
					st.pop();
					result.push_back(node->val);
				}
			 } 
			 return result;
		}
};

迭代法前序遍历

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左
                st.push(node);                          // 中
                st.push(NULL);
            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

迭代法后序遍历

class Solution {
public:
    vector<int> postorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        if (root != NULL) st.push(root);
        while (!st.empty()) {
            TreeNode* node = st.top();
            if (node != NULL) {
                st.pop();
                st.push(node);                          // 中
                st.push(NULL);

                if (node->right) st.push(node->right);  // 右
                if (node->left) st.push(node->left);    // 左

            } else {
                st.pop();
                node = st.top();
                st.pop();
                result.push_back(node->val);
            }
        }
        return result;
    }
};

二叉树的层序遍历

class Solution {
public:
    vector<vector<int>> levelOrder(TreeNode* root) {
        queue<TreeNode*> que;
        if (root != NULL) que.push(root);
        vector<vector<int>> result;
        while (!que.empty()) {
            int size = que.size();
            vector<int> vec;
            // 这里一定要使用固定大小size，不要使用que.size()，因为que.size是不断变化的
            for (int i = 0; i < size; i++) {
                TreeNode* node = que.front();
                que.pop();
                vec.push_back(node->val);
                if (node->left) que.push(node->left);
                if (node->right) que.push(node->right);
            }
            result.push_back(vec);
        }
        return result;
    }
};