算法训练营 day 14 二叉树 二叉树理论基础 递归遍历 迭代遍历 统一遍历
二叉树理论基础
二叉树（Binary tree）是树形结构的一个重要类型。许多实际问题抽象出来的数据结构往往是二叉树形式，即使是一般的树也能简单地转换为二叉树，而且二叉树的存储结构及其算法都较为简单，因此二叉树显得特别重要。二叉树特点是每个节点最多只能有两棵子树，且有左右之分。
二叉树的种类
满二叉树
如果一棵二叉树只有度为0的节点和度为2的节点，并且度为0的节点在同一层上，则这棵二叉树为满二叉树。
这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。
完全二叉树
深度为k，有n个节点的二叉树当且仅当其每一个节点都与深度为k的满二叉树中编号从1到n的节点一一对应时，称为完全二叉树。
在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。
二叉搜索树
二叉搜索树是有数值的了，二叉搜索树是一个有序树。
- 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
- 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
- 它的左、右子树也分别为二叉排序树
平衡二叉搜索树
平衡二叉搜索树：又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。
二叉树的存储方式
二叉树可以链式存储，也可以顺序存储。
那么链式存储方式就用指针， 顺序存储的方式就是用数组。
顾名思义就是顺序存储的元素在内存是连续分布的，而链式存储则是通过指针把分布在各个地址的节点串联一起。
链式存储如图：
顺序存储的方式如图：
二叉树的遍历方式
二叉树主要有两种遍历方式：
- 深度优先遍历：先往深走，遇到叶子节点再往回走。
- 广度优先遍历：一层一层的去遍历。
这两种遍历是图论中最基本的两种遍历方式
那么从深度优先遍历和广度优先遍历进一步拓展，才有如下遍历方式：
- 深度优先遍历
- 前序遍历（递归法，迭代法）
- 中序遍历（递归法，迭代法）
- 后序遍历（递归法，迭代法）
- 广度优先遍历
- 层次遍历（迭代法）
二叉树的定义
ublic class TreeNode {
int val;
TreeNode left;
TreeNode right;
TreeNode() {}
TreeNode(int val) { this.val = val; }
TreeNode(int val, TreeNode left, TreeNode right) {
this.val = val;
this.left = left;
this.right = right;
}
}
递归遍历
每次写递归，都按照这三要素来写，可以保证大家写出正确的递归算法！
- 确定递归函数的参数和返回值： 确定哪些参数是递归的过程中需要处理的，那么就在递归函数里加上这个参数， 并且还要明确每次递归的返回值是什么进而确定递归函数的返回类型。
- 确定终止条件： 写完了递归算法, 运行的时候，经常会遇到栈溢出的错误，就是没写终止条件或者终止条件写的不对，操作系统也是用一个栈的结构来保存每一层递归的信息，如果递归没有终止，操作系统的内存栈必然就会溢出。
- 确定单层递归的逻辑： 确定每一层递归需要处理的信息。在这里也就会重复调用自己来实现递归的过程。
给你二叉树的根节点 root ，返回它节点值的 前序 遍历。
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
preorderTraversal(root,result);
return result;
}
public void preorderTraversal(TreeNode root, List<Integer> result){
if (root==null){
return;
}
result.add(root.val);
preorderTraversal(root.left,result);
preorderTraversal(root.right,result);
}
}
给你一棵二叉树的根节点 root ，返回其节点值的 后序遍历 。
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
preorderTraversal(root,result);
return result;
}
public void preorderTraversal(TreeNode root, List<Integer> result){
if (root==null){
return;
}
preorderTraversal(root.left,result);
preorderTraversal(root.right,result);
result.add(root.val);
}
}
给定一个二叉树的根节点 root ，返回 它的 中序 遍历 。
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
preorderTraversal(root,result);
return result;
}
public void preorderTraversal(TreeNode root, List<Integer> result){
if (root==null){
return;
}
preorderTraversal(root.left,result);
result.add(root.val);
preorderTraversal(root.right,result);
}
}
迭代遍历
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
Stack<TreeNode> st = new Stack<TreeNode>();
TreeNode node;
st.push(root);
while (!st.isEmpty()){
node = st.peek();
st.pop();
if (node!=null){
result.add(node.val);
}else continue;
st.push(node.right);
st.push(node.left);
}
return result;
}
}
先序遍历是中左右，后续遍历是左右中，那么我们只需要调整一下先序遍历的代码顺序，就变成中右左的遍历顺序，然后在反转result数组，输出的结果顺序就是左右中了，如下图：
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
Stack<TreeNode> st = new Stack<TreeNode>();
TreeNode node;
st.push(root);
while (!st.isEmpty()){
node = st.peek();
st.pop();
if (node!=null){
result.add(node.val);
}else continue;
st.push(node.left);
st.push(node.right);
}
Collections.reverse(result);
return result;
}
}
在使用迭代法写中序遍历，就需要借用指针的遍历来帮助访问节点，栈则用来处理节点上的元素。
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
Stack<TreeNode> st = new Stack<TreeNode>();
TreeNode node = root;
if (root==null){
return result;
}
while (node!=null||!st.isEmpty()){
if (node!=null){
st.push(node);
node = node.left;
}else {
node = st.pop();
result.add(node.val);
node = node.right;
}
}
return result;
}
}
统一遍历
那我们就将访问的节点放入栈中，把要处理的节点也放入栈中但是要做标记。
就是要处理的节点放入栈之后，紧接着放入一个空指针作为标记。 这种方法也可以叫做标记法。
中序遍历：
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
Stack<TreeNode> st = new Stack<TreeNode>();
TreeNode node ;
if (root!=null)st.push(root);
while (!st.isEmpty()){
node = st.peek();
if (node!=null){
st.pop();
if (node.right!=null) st.push(node.right);// 添加右节点（空节点不入栈）
st.push(node);// 添加中节点 并添加空值标记
st.push(null);
if (node.left!=null)st.push(node.left);// 添加左节点（空节点不入栈）
}else {
st.pop();//去除空值
node = st.pop();//获取元素
result.add(node.val);
}
}
return result;
}
}
前序遍历：
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
Stack<TreeNode> st = new Stack<TreeNode>();
TreeNode node ;
if (root!=null)st.push(root);
while (!st.isEmpty()){
node = st.peek();
if (node!=null){
st.pop();
if (node.right!=null) st.push(node.right);
if (node.left!=null)st.push(node.left);
st.push(node);
st.push(null);
}else {
st.pop();
node = st.pop();
result.add(node.val);
}
}
return result;
}
}
后序遍历：
class Solution {
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList<Integer>();
Stack<TreeNode> st = new Stack<TreeNode>();
TreeNode node ;
if (root!=null)st.push(root);
while (!st.isEmpty()){
node = st.peek();
if (node!=null){
st.pop();
st.push(node);
st.push(null);
if (node.right!=null) st.push(node.right);
if (node.left!=null)st.push(node.left);
}else {
st.pop();
node = st.pop();
result.add(node.val);
}
}
return result;
}
}
98
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
