算法-二叉树

一、知识点介绍

二叉树的遍历

1. 先序遍历

遍历顺序：根节点->左子树->右子树

	void preorder(node* root) {
		if(root == NULL) {
			return;//到达空树，递归边界
		}
		//访问根节点root，例如将根节点的数据输出
		printf("%d\n", root->data);
		//访问左子树
		preorder(root->lchild);
		//访问右子树
		preorder(root->rchild);
	}

2. 中序遍历

遍历顺序：左子树->根节点->右子树

	void inorder(node* root) {
		if(root->NULL) {
			return;//到达空树，递归边界
		}
		//访问左子树
		inorder(root->lchild);
		//访问根节点root，例如将根节点的数据输出
		printf("%d\n", root->data);
		//访问右子树
		inorder(root->rchild);
	}

后序遍历

遍历顺序：左子树->右子树->根节点

void postorder(node* root) {
	if(root == NULL) {
		return;//到达空树，递归边界
	}
	//访问左子树
	postorder(root->lchild);
	//访问右子树
	postorder(root->rchild);
	//访问根节点root，例如将根节点的数据输出
	printf("%d\n", root->data);
}

层序遍历

遍历顺序：按照层次的顺序从根节点向下逐层进行遍历，且对同一层的结点为从左到右遍历。
这个过程和BFS很想，因为BFS进行搜索总是以广度作为第一关键词，而对应到二叉树中，广度又恰好体现在层次上，因此层次遍历就相当于是对二叉树从根节点开始的广度优先搜索。

	struct node {
		int data;//数据域
		int layer;//层次
		node* lchild;//左指针域
		node* rchild;//右指针域
	};

	void LayerOrder(node* root) {
		queue<node*> q;//这里存在队列的是地址，因为要改变元素的值
		root->layer = 1; //根节点的层号为1
		q.push(root); //将根节点地址入队
		while(!q.empty()){
			node* now = q.front();//取出队首元素
			q.pop();
			printf("%d", now->data); //访问队首元素
			if(now->lchild != NULL) { //左子树非空
				now->lchild->layer = now->layer+1; //左孩子的层号加1
				q.push(now->lchild);
			}
			if(now->rchild != NULL) { //右子树非空
				now->rchild->layer = now->layer + 1; //右孩子的层号加1
				q.push(now->rchild);
			}
		}
	}

基本思路如下：

1. 将根节点root加入队列q
2. 取出队首结点，访问它
3. 如果该结点存在左孩子，左孩子入队，并更新左孩子的层数
4. 如果该结点存在右孩子，右孩子入队，并更新右孩子的层数
5. 返回第二步，直到队列为空

二、练习题目

        (1) 144. 二叉树的前序遍历
        (2) 94. 二叉树的中序遍历
        (3) 145. 二叉树的后序遍历
        (4) 104. 二叉树的最大深度

1. 二叉树的前序遍历

        (1) 深度优先搜索，先遍历根节点，再遍历左右子树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    vector<int> res;
    void dfs(TreeNode* root) {
        if(root) {
            res.push_back(root->val);
            dfs(root->left);
            dfs(root->right);
        }
    }
public:
    vector<int> preorderTraversal(TreeNode* root) {
        dfs(root);
        return res;

    }
};

2. 二叉树的中序遍历

        (1) 深度优先搜索，先遍历左子树，再遍历根节点，最后遍历右子树。

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    vector<int> res;
    void dfs(TreeNode* root) {
        if(root) {
            dfs(root->left);
            res.push_back(root->val);
            dfs(root->right);
        }
    }
public:
    vector<int> inorderTraversal(TreeNode* root) {
       res.clear();
       dfs(root);
       return res;
    }
};

3. 二叉树的后序遍历

        (1) 深度优先搜索，先遍历左右子树，再遍历根节点

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
    vector<int> res;
    void dfs(TreeNode* root) {
        if(root) {
            dfs(root->left);
            dfs(root->right);
            res.push_back(root->val);
        }
    }
public:
    vector<int> postorderTraversal(TreeNode* root) {
        res.clear();
        dfs(root);
        return res;
    }
};

4. 二叉树的最大深度

        (1)访问左右子树，返回最大深度

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    int maxDepth(TreeNode* root) {
        if(root == nullptr) return 0;
        return max(maxDepth(root->left), maxDepth(root->right)) +1;
    }
};

四、 总结

这几道是基础基础的题目，一定要掌握