算法之二叉树的一些记录

简要的记录一下学习二叉树的知识

分类

• 没有数值的树
  • 满二叉树
  • 完全二叉树
• 有数值的树
  • 二叉搜索树
  • 平衡二叉搜索树

存储方式

链式存储（指针）、 顺序存储（数组）

遍历方式

• 深度优先遍历
  • 前序遍历（递归法、迭代法）【中左右】
  • 中序遍历（递归法、迭代法）【左中右】
  • 后序遍历（递归法、迭代法）【左右中】
• 广度优先遍历
  • 层次遍历（迭代法）
    

二叉树定义

主要是两个指针，分别指向树的左节点和右节点，还有其数值

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

递归写法

三要素：

1. 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
2. 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
3. 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。

前序遍历

class Solution{
public:
// 这里的vec是用来存储最后的结果的，且是引用的形式，会改变被引用的变量，cur是树的指针
    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(TreeNode* root){
        vector<int> result;
        traversal(root, result); // 从根节点开始
        return result;
    }
}

接下来的中序和后续也很简单，只要改变traversal的函数中的次序就行了。

中序遍历

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);    // 中
}

二叉树的迭代遍历

前序遍历

1. 中间节点入栈，出栈
2. 右节点入栈，左节点入栈
3. 依次出栈（先进后出)

class Solution {
public:
    vector<int> preorderTraversal(TreeNode* root) {
        stack<TreeNode*> st;// 表示的是栈里面存放的格式是TreeNode的指针
        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); // 将中节点对应的值放到result里面去
            if (node->right) st.push(node->right);  // 右（空节点不入栈）// 如果存在右节点的话，将右节点推入栈中，先进后出
            if (node->left) st.push(node->left); // 左（空节点不入栈）
        }
        return result;
    }
};

中序遍历

前序遍历的处理和访问顺序一致，都是中间节点开始，但是中序遍历不是的
左中右，是底层的左结点开始的，然后每一层左中右的顺序

class Solution {
public:
    vector<int> inorderTraversal(TreeNode* root) {
        vector<int> result;
        stack<TreeNode*> st;
        TreeNode* cur = root;
        while (cur != NULL || !st.empty()) {
        // 就是会一直向下访问左节点，直到空节点
            if (cur != NULL) { // 指针来访问节点，访问到最底层
                st.push(cur); // 将访问的节点放进栈
                cur = cur->left;                // 左
            } else {
            // 这里先弹出的是左边的，然后左边的节点没有右节点，就往上走（中节点),然后中节点的右节点
                cur = st.top(); // 从栈里弹出的数据，就是要处理的数据（放进result数组里的数据）
                st.pop();
                result.push_back(cur->val);     // 中
                cur = cur->right;               // 右
            }
        }
        return result;
    }
};

后序遍历

左右中=reverse（中右左）
就相当于对前序遍历的中左右改成中右左

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<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(); // 如果是根节点的话，size=1，然后第二层是2，第三层是4，一次while生成一个vector
			// 最后就是多少层有多少个vector，然后result是二维数组。
			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;
	}
};

// 递归法
class Solution{
public:
	void order(TreeNode* cur, vector<vector<int>>& result, int depth){
		if (cur == nullptr) return;
		// 这里的result.size() 和深度是相等的，然后就插入一个新的vector，存放下一层的节点值
		// 不相等的话，就说明是同一层，那就直接插入吧？
		// result的索引从0开始，所以result[depth]表示的就是新的那一层。
		// 然后如果存在左右节点的话，就放在下一层（depth+1）
		if (result.size() == depth) result.push_back(vector<int>()); 
		result[depth].push_back(cur->val);
		order(cur->left, result, depth+1);
		order(cur->right, result, depth+1);
	}
	vector<vector<int> > levelOrder(TreeNode* root){
		vector<vector<int>> result;
		int depth = 0; // 所以 虽然深度从1开始，但是如果作为索引的话，从0开始
		order(root,result,depth);
		return result;
	}
};