一、什么是树
树(tree)是一种经常用到的数据结构,用来模拟具有树状结构性质的数据集合。
树是n(n>=0)个结点和n-1条边的有限集。n=0时称为空树。在任意一棵非空树中:
- 有且仅有一个特定的称为根(root)的结点;
- 当n>1时,其余结点可分为m(m>0)个互不相交的有限集,其中每个集合本身又是一棵树,并且称为根的子树(subtree)。
二、什么是二叉树
二叉树(binary tree)是一种更为典型的树状结构。如它名字所描述的那样,二叉树是每个节点最多有两个子树的树结构,通常子树被称作“左子树”和“右子树”。
- 二叉树每个结点最多有两棵子树,没有子树或者有一棵子树都是可以的;
- 左子树和右子树是有顺序的,次序不能任意颠倒;
- 即使树中某个结点只有一棵子树,也要区分它是左子树还是右子树。
如下图就是一棵二叉树。
三、二叉树遍历
二叉树遍历(traversing binary tree)是指从根结点出发,按照某种次序依次访问二叉树中所有结点,使得每个结点被访问一次且仅被访问一次。
二叉树的遍历方式可以有很多种,如果限制了从左到右的遍历方式,则主要分为四种:
-
前序遍历
首先访问根结点,然后遍历左子树,最后遍历右子树。如下图,遍历的顺序为:ABDGHCEIF
-
中序遍历
先遍历左子树,然后访问根结点,最后遍历右子树。对于二叉搜索树,可以通过中序遍历得到一个递增的有序序列。如下图,遍历的顺序为:GDHBAEICF
-
后序遍历
先遍历左子树,然后遍历右子树,最后访问树的根结点。当删除树中的节点时,删除过程将按照后序遍历的顺序进行。也就是说,当删除一个结点时,将首先删除它的左结点和它的右结点,然后再删除结点本身。如下图,遍历的顺序为:GHDBIEFCA
-
层序遍历
从树的第一层,也就是根结点开始,从上而下逐层遍历,在同一层,按从左到右的顺序对结点逐个访问。如下图,遍历的顺序为:ABCDEFGHI
四、前序遍历
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:
// 二叉树前序遍历递归实现:根结点->左子树->右子树
vector<int> answer;
void preorder(TreeNode *root) {
if(root == nullptr){
return;
}
answer.push_back(root -> val);
preorder(root -> left);
preorder(root -> right);
}
vector<int> preorderTraversal(TreeNode *root) {
preorder(root);
return answer;
}
};
五、中序遍历
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:
// 二叉树中序遍历递归实现:左子树->根结点->右子树
vector<int> answer;
void inorder(TreeNode* root) {
if(root == nullptr) {
return;
}
inorder(root -> left);
answer.push_back(root -> val);
inorder(root -> right);
}
vector<int> inorderTraversal(TreeNode* root) {
inorder(root);
return answer;
}
};
六、后序遍历
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:
// 二叉树后序遍历递归实现:左子树->右子树->根结点
vector<int> answer;
void postorder(TreeNode* root) {
if(root == nullptr) {
return;
}
postorder(root -> left);
postorder(root -> right);
answer.push_back(root -> val);
}
vector<int> postorderTraversal(TreeNode* root) {
postorder(root);
return answer;
}
};
七、层序遍历
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:
// 层序遍历
vector<vector<int>> levelOrder(TreeNode* root) {
vector<vector<int>> answer;
if(root == nullptr) {
return answer;
}
queue<TreeNode*> q;
q.push(root);
while(!q.empty()) {
int size = q.size();
TreeNode* current;
vector<int> ans;
for(int i = 0; i < size; i ++) {
current = q.front();
ans.push_back(current -> val);
q.pop();
if(current -> left)
q.push(current -> left);
if(current -> right)
q.push(current -> right);
}
answer.push_back(ans);
}
return answer;
}
};
后续将更新使用非递归方法实现遍历,请持续关注。