代码随想录算法训练营第十四天 ｜ 二叉树理论基础篇、二叉树的递归遍历、二叉树的迭代遍历、二叉树的统一迭代法

LeetCode 二叉树理论基础篇

1.二叉树的种类

• 满二叉树
  如果一棵二叉树只有度为0的结点和度为2的结点，并且度为0的结点在同一层上，则这棵二叉树为满二叉树。
  
  这棵二叉树为满二叉树，也可以说深度为k，有2^k-1个节点的二叉树。

• 完全二叉树
  在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^(h-1) 个节点。
  

• 二叉搜索树
  - 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值；
  - 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值；
  - 它的左、右子树也分别为二叉排序树
  

• 平衡二叉搜索树
  又被称为AVL（Adelson-Velsky and Landis）树，且具有以下性质：它是一棵空树或它的左右两个子树的高度差的绝对值不超过1，并且左右两个子树都是一棵平衡二叉树。

2. 二叉树的存储方式

二叉树可以链式存储，也可以顺序存储，前者使用指针，通过指针把分布在各个地址的节点串联在一起；后者使用数组，存储的元素在内存中是连续分布的。

数组存储二叉树的遍历方法是：如果父节点的数组下标为i，那么它的左孩子就是i * 2 + 1，右孩子就是i * 2 + 2

3.二叉树的遍历方式

• 深度优先遍历：先往深处走，遇到叶子节点再往回走
  - 前序遍历（递归法，迭代法）
  - 中序遍历（递归法，迭代法）
  - 后序遍历（递归法，迭代法）
• 广度优先遍历：一层一层去遍历
  - 层次遍历（迭代法）

深度优先遍历的前中后序指的是中间节点的遍历顺序：
- 前序遍历：中左右
- 中序遍历：左中右
- 后序遍历：左右中

深度优先遍历通常使用递归实现，同时也可以借助栈使用非递归的方式来实现
广度优先遍历通常使用队列来实现

4.二叉树的定义

function TreeNode(val, left, right) {
    this.val = (val===undefined ? 0 : val)
    this.left = (left===undefined ? null : left)
    this.right = (right===undefined ? null : right)
}

---

LeetCode 二叉树的递归遍历

1.递归算法的三个要素：

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

2.前序遍历

var preorderTraversal = function (root) {
    let res = [];
    const dfs = function (root) {
        if (root === null) return;
        //先序遍历所以从父节点开始
        res.push(root.val);
        //递归左子树
        dfs(root.left);
        //递归右子树
        dfs(root.right);
    }
    //只使用一个参数 使用闭包进行存储结果
    dfs(root);
    return res;
};

3. 中序遍历

var inorderTraversal = function(root) {
    let res=[];
    const dfs=function(root){
        if(root===null) return ;
        // 中序遍历，所以从左子树开始
        dfs(root.left);
        // 递归父节点
        res.push(root.val);
        // 递归右子树
        dfs(root.right);
    }
    dfs(root);
    return res;
};

4.后序遍历

var postorderTraversal = function(root) {
    let res=[];
    const dfs=function(root){
        if(root===null) return ;
        // 后序遍历，所以从左子树开始
        dfs(root.left);
        // 遍历右子树
        dfs(root.right);
        // 遍历父节点
        res.push(root.val);
    }
    dfs(root);
    return res;
};

---

LeetCode 二叉树的迭代遍历

前序遍历

将根节点放入栈中，然后依次放入右孩子、左孩子（出栈时才是中左右的顺序）

// 栈的作用是遍历节点（访问），res用来接收节点的值（处理）
// 入栈 右 -> 左
// 出栈 中 -> 左 -> 右
var preorderTraversal = function(root) {
	const res = [];
    if(!root) return res; // 根节点为空，返回空数组
    
    const stack = [root]; // 将跟节点放入栈
    let cur = null;
    
    while(stack.length) {
        cur = stack.pop(); // 弹出栈顶元素
        res.push(cur.val); // 栈顶元素（根节点）的值放入数组中
        cur.right && stack.push(cur.right); // 先放入右孩子放入栈中，值放入数组中，出栈时就是中左右
        cur.left && stack.push(cur.left); // 左孩子放入栈中，值放入数组中
    }
    return res;
};

中序遍历

因为处理顺序和访问顺序不一致，需要借助指针的遍历来访问节点，栈则用来处理节点上的元素

// 入栈 左 -> 右
// 出栈 左 -> 中 -> 右
var inorderTraversal = function(root) {
	const res = [];
    const stack = [];
    let cur = root; // 指针指向根节点
    
    while(stack.length || cur) {
        if(cur) { // 指针遍历到树的最底部，将访问的节点压入栈中
            stack.push(cur);
            cur = cur.left; // 左子树
        } else {
            cur = stack.pop(); // 弹出的就是要放入res中的数据
            res.push(cur.val); // 中
            cur = cur.right; // 右
        }
    };
    return res;
};

后序遍历

调整一下先序遍历的代码顺序，使其变为中右左的遍历顺序，然后反转result数组，输出的结果就是左右中。

// 入栈 左 -> 右
// 出栈 中 -> 右 -> 左 结果翻转
var postorderTraversal = function(root) {
	const res = [];
    if (!root) return res;
    
    const stack = [root];
    let cur = null;
    
    while(stack.length) {
    	cur = stack.pop();
    	res.push(cur.val);
    	cur.left && stack.push(cir.left); // 先放入左孩子，出栈时就是中右左
    	cur.right && stack.push(cur.right);
    };

    return res.reverse(); //反转，变为左右中
};

---

LeetCode 二叉树的统一迭代法

为了解决迭代遍历的中序法访问与处理不一致的问题，可以将访问与处理同时放入栈中，处理的节点用一个空指针进行标记

中序遍历

//  入栈顺序：右 -> 中 -> 左
//  出栈顺序：左 -> 中 -> 右
 
var inorderTraversal = function(root) {
	const  res = [];
    const stack = [];
    if (root) stack.push(root);
    
    while(stack.length) {
        const node = stack.pop();
        // 未遇到空节点
        if(node) {
       		stack.pop();
            if (node.right) stack.push(node.right); // 右
        	stack.push(node); // 中
        	stack.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
        	if (node.left) stack.push(node.left); // 左
        } else { // 遇到空节点
	        stack.pop();
	        node = stack.pop();
	        stack.pop();
        	res.push(node.val);
        }
    };
    return res;
};

前序遍历

// 入栈顺序：中 -> 左 -> 右
// 出栈顺序：右 -> 中 -> 左
var preorderTraversal = function(root) {
	const res = [];
    const stack = [];
    if (root) stack.push(root);
    
    while(stack.length) {
        const node = stack.pop();
        if(!node) {
            res.push(stack.pop().val);
            continue;
        } 
        if (node.right) stack.push(node.right); // 右
        if (node.left) stack.push(node.left); // 左
        stack.push(node); // 中
        stack.push(null);
    };
    return res;
};

后序遍历

// 入栈顺序：中 -> 右 -> 左
// 出栈顺序：左 -> 右 -> 中
var postorderTraversal = function(root) {
	const res = [];
    const stack = [];
    if (root) stack.push(root);
    
    while(stack.length) {
        const node = stack.pop();
        if(!node) {
            res.push(stack.pop().val);
            continue;
        }
        stack.push(node); // 中
        stack.push(null);
        if (node.right) stack.push(node.right); // 右
        if (node.left) stack.push(node.left); // 左
    };
    return res;
};

---

今日收获

1. 梳理了二叉树的相关知识
2. 递归遍历：处理父节点，然后左右子节点
3. 迭代遍历：中序遍历的问题在于访问与处理不能同步处理。解决方案：借助指针的遍历来访问节点，栈则用来处理节点上的元素
4. 统一迭代遍历：

• 将访问节点、处理节点都压入栈，在处理节点后面添加一个空指针null
• 遇到null节点弹出其之前的节点（即为处理节点）并将其值放入res