二叉树基础知识&力扣题构造二叉树总结

二叉树

如何理解二叉树,This is a question!

作者在去年被布置要求学习二叉树时对二叉树的理解并不是很深刻,甚至可以说是绕道走,但是Luck of the draw only draws the unlucky,在学期初考核时,作者三道二叉树题都没做出来,连最简单的创建都忘记了,当时想着提升,却拖到了现在;

这篇文章可以说是作者二叉树算法实战经验总结

基础知识

先来回顾一下二叉树的基本知识;但还是请读者曾经是见过二叉树的

一颗很普通的二叉树,他的定义是:是n(n>=0)个结点的有限集合,该集合或者为空集(称为空二叉树),或者由一个根结点和两棵互不相交的、分别称为根结点的左子树和右子树组成;

其余的基本知识,还是请自行搜索一下;现在来了解几种遍历手法

二叉树基础知识&力扣题构造二叉树总结_第1张图片

二叉树的前序遍历

 int len;
//DLR
void DFS(int*arr,struct TreeNode*root) {
     if(root == NULL) return;
     arr[len] = root->val;
     len++;
     DFS(arr,root->left);
     DFS(arr,root->right);

 }

int* preorderTraversal(struct TreeNode* root, int* returnSize){
    int*arr = (int*)malloc(sizeof(int)*100);
    len = 0;
    if(root != NULL)
        DFS(arr,root);
    *returnSize = len;
    return arr;
}

二叉树的后序遍历

int len;
//LRD
void DFS(int*arr,struct TreeNode*root) {
     if(root == NULL) return;
     DFS(arr,root->left);
     DFS(arr,root->right);
     arr[len] = root->val;
     len++;

 }

int* postorderTraversal(struct TreeNode* root, int* returnSize){
   int*arr = (int*)malloc(sizeof(int)*100);
    len = 0;
    if(root != NULL)
        DFS(arr,root);
    *returnSize = len;
    return arr;
}

二叉树的中序遍历

int len;
//LDR
void DFS(int*arr,struct TreeNode* root) {
    if(root == NULL) return;
    DFS(arr,root->left);
    arr[len] = root->val;
    len++;
    DFS(arr,root->right);
}

int* inorderTraversal(struct TreeNode* root, int* returnSize){
    len = 0;
    int*arr = (int*)malloc(sizeof(int)*100);
    if(root != NULL) {
        DFS(arr,root);
    }
    *returnSize = len;
    return arr;
}

在三种遍历方法中,我们都采用了递归的方法,而仔细观察也会发现,这三段代码的区别,从字面上仅是递归函数的位置不同,也就是遍历时的顺序不同,这个也就是我们在解决二叉树算法题时要注意的点,不同的遍历方式对应着不同的类型的解决方案

在这三种遍历代码前,都标注了三个大写字母,D、L、R 分别代表遍历根结点、遍历左子树、遍历右子树,会发现字母的顺序也就代表着优先级也就是代码呈现的顺序;

如何理解这种遍历手法,以前序遍历为例,他的三个字母顺序为DLR,也就是根节点最优先,自然就是A,之后就到B,C这两个在这里判断的条件就成了谁左谁优先,也就是B先行,B的底下还有子树,坚持D最优先原则,由于他们有一个优秀的父结点,因为所有都可以得到先行一步的遍历权利,等到遍历完了也就是在轮到C和C的子树;

总结就是:坚持大方向,父结点优先,子结点也继承了优先权

那么基础知识就讲到这里,接下来实战演练

实战演练

104.二叉树的最大深度

这是一道非常基础的题目,也就是再问一根树枝最长能有多长,也就是遍历出奇迹

第一种方法:回溯

(探索与回溯法)是一种选优搜索法,又称为试探法,按选优条件向前搜索,以达到目标。但当探索到某一步时,发现原先选择并不优或达不到目标,就退回一步重新选择,这种走不通就退回再走的技术为回溯法,而满足回溯条件的某个状态的点称为“回溯点”

对这种算法的解释就是:一条道走到黑,且要走完每条道

先看代码:

class Solution {
    int depth = 0;
    int res = 0;

    public int maxDepth(TreeNode root) {
        traverse(root);
        return res;
    }

    void traverse(TreeNode root) {
        if (root == null) {
            return;
        }

        depth++;
        // 遍历的过程中记录最大深度
        res = Math.max(res, depth);
        traverse(root.left);
        traverse(root.right);
        depth--;
    }
}

对代码的唯一不理解的地方应该是为何要先depth++之后又depth--,我们可以把整个函数理解为一个在四处游走的图钉,当图钉到这个点上了,depth++,现在我小图钉在这里一条道走到黑要离开去其他地方了,那么则先depth--,因为回到更上面一层去了;这跟前序遍历很像

至于res的取值,只要放在depth--之前就行了

第二种方法:动态规划

class Solution2 {
    // 定义:输入一个节点,返回以该节点为根的二叉树的最大深度
    public int maxDepth(TreeNode root) {
        if (root == null) {
            return 0;
        }
        int leftMax = maxDepth(root.left);
        int rightMax = maxDepth(root.right);
        // 根据左右子树的最大深度推出原二叉树的最大深度
        return 1 + Math.max(leftMax, rightMax); //+1的原因:算上根节点
    }
}

代码很好理解,但是作者自己想不出来;思想很简单,也是遍历然后最后得出最大值,这个顺序相当于在后序遍历

543.二叉树的直径

其实这道题跟上面一道题非常像,作者对这道题的解读就是:从根节点出发第一长的树枝和第二长的树枝长度和;那么这道题也就迎刃而解了,只要在上一题的第二种解法种稍加修改,添加一个max记录值,便可以做出该题

/**
 * 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 {
    int maxDiameter = 0;
    public int diameterOfBinaryTree(TreeNode root) {
        maxDepth(root);
        return maxDiameter;
    }
    
    int maxDepth(TreeNode root) {
        if(root == null) {
            return 0;
        }
        int leftMax = maxDepth(root.left);
        int rightMax = maxDepth(root.right);
        int myDiameter = leftMax + rightMax;
        maxDiameter = Math.max(myDiameter, maxDiameter);
        return 1 + (Math.max(leftMax, rightMax));
    }
}

116.填充每个节点的下一个右侧指针节点

这道题的神奇之处就在于,把不是一个父结点,但是在同一层的联系在了一起,那么只要把相对位置是left&right的都链接在一起,也就是多加一条执行语句traverse(node1.right, node2.left)即可

class Solution {
    public Node connect(Node root) {
        if(root == null) {
            return null;
        }
        traverse(root.left, root.right);
        return root;
    }
    void traverse(Node node1, Node node2) {
        if(node1 == null || node2 == null) {
            return;
        }
        node1.next = node2;
        traverse(node1.left, node1.right);
        traverse(node2.left, node2.right);
        traverse(node1.right, node2.left);
    }
}

105.从前序与中序遍历序列构造二叉树

它使用HashMap来存储中序遍历数组中值到索引的映射关系,这有助于确定根节点并将数组划分为子树以进行递归构建。
buildTree 方法接受前序遍历和中序遍历数组作为输入,并通过将中序遍历数组中的值和索引存储在 valToIndex HashMap 中来进行初始化。然后,它调用 build 方法,传递必要的参数来构建二叉树。
build 方法是一个递归函数,用于构建二叉树。它检查子树是否为空(preStart > preEnd),如果是则返回null。否则,它从前序遍历数组中确定根节点的值(preorder[preStart]),并找到它在中序遍历数组中的索引。然后,它计算左子树的大小(index - inStart),并先构造当前根节点。接下来,它递归构建左子树和右子树,并将它们连接到根节点。最后,它返回根节点

class Solution {
    // 存储 inorder 中值到索引的映射
    HashMap<Integer, Integer> valToIndex = new HashMap<>();

    public TreeNode buildTree(int[] preorder, int[] inorder) {
        for (int i = 0; i < inorder.length; i++) {
            valToIndex.put(inorder[i], i);
        }
        return build(preorder, 0, preorder.length - 1, inorder, 0, inorder.length - 1);
    }

    /*
       定义:前序遍历数组为 preorder[preStart..preEnd],
       中序遍历数组为 inorder[inStart..inEnd],
       构造这个二叉树并返回该二叉树的根节点
    */
    TreeNode build(int[] preorder, int preStart, int preEnd, int[] inorder, int inStart, int inEnd) {
        if (preStart > preEnd) {
            return null;
        }

        // root 节点对应的值就是前序遍历数组的第一个元素
        int rootVal = preorder[preStart];
        // rootVal 在中序遍历数组中的索引
        int index = valToIndex.get(rootVal);
        int leftSize = index - inStart;

        // 先构造出当前根节点
        TreeNode root = new TreeNode(rootVal);
        // 递归构造左右子树
        root.left = build(preorder, preStart + 1, preStart + leftSize, inorder, inStart, index - 1);
        root.right = build(preorder, preStart + leftSize + 1, preEnd, inorder, index + 1, inEnd);
        return root;
    }
}

106.从中序与后序遍历序列构造二叉树

class Solution {
    // 存储 inorder 中值到索引的映射
    HashMap<Integer, Integer> valToIndex = new HashMap<>();

    public TreeNode buildTree(int[] inorder, int[] postorder) {
        for (int i = 0; i < inorder.length; i++) {
            valToIndex.put(inorder[i], i);
        }
        return build(inorder, 0, inorder.length - 1, postorder, 0, postorder.length - 1);
    }

    /*
       定义:
       中序遍历数组为 inorder[inStart..inEnd],
       后序遍历数组为 postorder[postStart..postEnd],
       构造这个二叉树并返回该二叉树的根节点
    */
    TreeNode build(int[] inorder, int inStart, int inEnd, int[] postorder, int postStart, int postEnd) {

        if (inStart > inEnd) {
            return null;
        }
        // root 节点对应的值就是后序遍历数组的最后一个元素
        int rootVal = postorder[postEnd];
        // rootVal 在中序遍历数组中的索引
        int index = valToIndex.get(rootVal);
        // 左子树的节点个数
        int leftSize = index - inStart;
        TreeNode root = new TreeNode(rootVal);
        // 递归构造左右子树
        root.left = build(inorder, inStart, index - 1, postorder, postStart, postStart + leftSize - 1);
        root.right = build(inorder, index + 1, inEnd, postorder, postStart + leftSize, postEnd - 1);
        return root;
    }
}

889.根据前序与后序遍历构造二叉树

class Solution {
    // 存储 postorder 中值到索引的映射
    HashMap<Integer, Integer> valToIndex = new HashMap<>();

    public TreeNode constructFromPrePost(int[] preorder, int[] postorder) {
        for (int i = 0; i < postorder.length; i++) {
            valToIndex.put(postorder[i], i);
        }
        return build(preorder, 0, preorder.length - 1, postorder, 0, postorder.length - 1);
    }

    // 定义:根据 preorder[preStart..preEnd] 和 postorder[postStart..postEnd]
    // 构建二叉树,并返回根节点。
    TreeNode build(int[] preorder, int preStart, int preEnd, int[] postorder, int postStart, int postEnd) {
        if (preStart > preEnd) {
            return null;
        }
        if (preStart == preEnd) {
            return new TreeNode(preorder[preStart]);
        }

        // root 节点对应的值就是前序遍历数组的第一个元素
        int rootVal = preorder[preStart];
        // root.left 的值是前序遍历第二个元素
        // 通过前序和后序遍历构造二叉树的关键在于通过左子树的根节点
        // 确定 preorder 和 postorder 中左右子树的元素区间
        int leftRootVal = preorder[preStart + 1];
        // leftRootVal 在后序遍历数组中的索引
        int index = valToIndex.get(leftRootVal);
        // 左子树的元素个数
        int leftSize = index - postStart + 1;

        // 先构造出当前根节点
        TreeNode root = new TreeNode(rootVal);
        // 递归构造左右子树
        // 根据左子树的根节点索引和元素个数推导左右子树的索引边界
        root.left = build(preorder, preStart + 1, preStart + leftSize, postorder, postStart, index);
        root.right = build(preorder, preStart + leftSize + 1, preEnd, postorder, index + 1, postEnd - 1);

        return root;
    }
}

你可能感兴趣的:(算法做题记录,leetcode,数据结构)