day14
day14-1 二叉树理论基础
种类:
- 满二叉树
- 完全二叉树
优先级队列是一个堆,堆是完全二叉树 - 二叉搜索树
有数值,是有序树
左子树的节点小于根结点,
右子树的节点大于根节点的值
左右子树分别为二叉排序树 - 平衡二叉搜索树(ALV)
左右子树的高度差绝对值不超过1
有意识去了解我们所熟悉的语言的容器的底层实现
set:
map:
存储:
顺序存储:数组
- 左孩子:i*2+1
- 右孩子:i*2+2
链式存储:指针(链表)
疑惑:构造传入二叉树
二叉树的遍历
- 深度优先搜索遍历:先往深处走,遇到叶子节点再往回走
- 前(迭代+递归)
- 中(迭代+递归)
- 后(迭代+递归)
广度优先搜索遍历:一层一层去遍历
- 层序遍历 队列 (迭代法)
栈是递归的一种实现结构
二叉树的定义
public 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;
}
}
day14-2 二叉树的递归遍历
递归的底层实现是用栈来实现的
三部曲:
- 确定递归函数的参数和返回值
- 确定终止条件—>没写好容易出现栈溢出
- 确定单层递归的逻辑
144. 二叉树的前序遍历
145. 二叉树的后序遍历
94.二叉树的中序遍历
/**
* Definition for a binary tree node.
* public 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;
* }
* }
*/
// 前
class Solution {
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList();
preorder(root, result);
return result;
}
void preorder(TreeNode root, List result){
if(root == null){
return;
}
// 前序遍历:中左右
result.add(root.val);
preorder(root.left,result);
preorder(root.right,result);
}
}
// 后
class Solution {
// 后序遍历 递归
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList();
postorder(root, result);
return result;
}
void postorder(TreeNode root, List result){
if(root == null){
return;
}
// 后序遍历:左右中
postorder(root.left, result);
postorder(root.right, result);
result.add(root.val);
}
}
// 中
class Solution {
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> res = new ArrayList();
inorder(root, res);
return res;
}
void inorder(TreeNode root, List res){
if(root == null){
return;
}
// 中序遍历:左中右
inorder(root.left, res);
res.add(root.val);
inorder(root.right, res);
}
}
day14-2 二叉树的非递归(迭代)遍历
中序遍历:
访问的节点(遍历的节点)和处理节点(将元素放入result数组中)不一样
前序遍历和后序遍历
访问的节点(遍历的节点)和处理节点(将元素放入result数组中)一样
144. 二叉树的前序遍历
145. 二叉树的后序遍历
94.二叉树的中序遍历
// 前
class Solution {
// 前序遍历 非递归实现 遍历顺序:中左右 入栈顺序:中右左
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList();
if(root == null){
return result;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while(!stack.isEmpty()){
TreeNode node = stack.pop();
// 中
result.add(node.val);
// 右
if(node.right !=null) {
stack.push(node.right);
}
// 左
if(node.left != null){
stack.push(node.left);
}
}
return result;
}
}
// 后
// 后序遍历 非递归实现 遍历顺序:左右中 入栈顺序:中左右 出栈顺序:中右左 返回顺序:左右中
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList();
if(root == null){
return result;
}
Stack<TreeNode> stack = new Stack<>();
stack.push(root);
while(!stack.isEmpty()){
TreeNode node = stack.pop();
// 中
result.add(node.val);
// 左
if(node.left != null){
stack.push(node.left);
}
// 右
if(node.right != null){
stack.push(node.right);
}
}
Collections.reverse(result);
return result;
}
// 中
// 中序遍历:左中右 非递归 指针+栈 指针用来记录访问遍历过的元素 栈用来记录遍历过的元素
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList();
if(root == null){
return result;
}
Stack<TreeNode> stack = new Stack<>();
TreeNode cur = root;
while(cur != null || !stack.isEmpty()){
// 左
if(cur != null){
stack.push(cur);
cur = cur.left;
}
// 中 右
else{
cur = stack.pop();
result.add(cur.val);
cur = cur.right;
}
}
return result;
}
day14-3 二叉树的统一迭代遍历
//标记法:在要处理的节点放入栈之后,紧接着放入一个空指针作为标记
// 前
// 前序遍历:中左右 统一迭代法(标记法):在要处理的节点放入栈之后,紧接着放入一个空指针作为标记
public List<Integer> preorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList();
Stack<TreeNode> stack = new Stack<>();
if(root != null){
stack.push(root);
}
while(!stack.isEmpty()){
TreeNode node = stack.peek();// 弹出结点,避免重复操作
if(node != null){
stack.pop(); // 弹出节点操作
// 右(空节点不如栈)
if(node.right != null){
stack.push(node.right);
}
// 左(空节点不如栈)
if(node.left != null){
stack.push(node.left);
}
// 中
stack.push(node);
stack.push(null);
}else{// 只有遇到空节点的时候,才将下一个节点放入结果集
stack.pop();// 将空节点弹出
node = stack.peek(); // 重新取出栈的元素
stack.pop();
result.add(node.val); // 加入到结果集
}
}
return result;
}
// 后
// 后序遍历:左右中 统一迭代法(标记法):在要处理的节点放入栈之后,紧接着放入一个空指针作为标记
public List<Integer> postorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList();
Stack<TreeNode> stack = new Stack<>();
if(root != null){
stack.push(root);
}
while(!stack.isEmpty()){
TreeNode node = stack.peek();
if(node != null){
stack.pop();// 弹出结点避免重复操作
// 中
stack.push(node);
stack.push(null);
// 右
if(node.right != null){
stack.push(node.right);
}
// 左
if(node.left != null){
stack.push(node.left);
}
}else{
stack.pop();
node = stack.peek();
stack.pop();
result.add(node.val);
}
}
return result;
}
// 中
// 中序遍历:左中右 统一迭代法(标记法):在要处理的节点放入栈之后,紧接着放入一个空指针作为标记
public List<Integer> inorderTraversal(TreeNode root) {
List<Integer> result = new ArrayList();
Stack<TreeNode> stack = new Stack<>();
if(root != null){
stack.push(root);
}
while(!stack.isEmpty()){
TreeNode node = stack.peek();
if(node!=null){
stack.pop();//将节点弹出,避免重复操作
// 右(空节点不如栈)
if(node.right != null){
stack.push(node.right);
}
// 中
stack.push(node);
stack.push(null); // 中节点访问过,但是还没有处理,加入空节点作为标记
// 左(空节点不如栈)
if(node.left != null){
stack.push(node.left);
}
}else{// 只有遇到空节点的时候,才进行下一个节点放入结果集
stack.pop(); // 弹出空指针
node = stack.peek();
stack.pop();
result.add(node.val);
}
}
return result;
}
sum
- 总耗时:3.5h