二叉树我的爱

最新推荐文章于 2024-10-03 13:36:06 发布
最新推荐文章于 2024-10-03 13:36:06 发布
阅读量247 收藏 2
点赞数 1
分类专栏： 数据结构与算法 文章标签： 二叉树 算法 leetcode js
我的版权就是没有版权，能帮助到你就很开心啦~^_^
本文链接：https://blog.csdn.net/lanyao961220/article/details/105255075
版权

在这里插入图片描述

二叉树层次遍历(leetcode102)

https://leetcode-cn.com/problems/binary-tree-level-order-traversal/

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @return {number[][]}
 */
var levelOrder = function(root) {
    if(!root){
        return [];
    }
    let result = [];
    helper(root,0,result);
    return result;
}

var helper = function(node,level,result){
    if(!node){
        return;
    }
    if(!result[level]){
        result[level]=[node.val]
    }else{
        result[level].push(node.val)
    }
    helper(node.left,level+1,result);
    helper(node.right,level+1,result);
}
// 队列
// var levelOrder = function(root) {
//     if(!root){
//         return []
//     }
//     let queue = [root];
//     let result = [];
//     let level = 0;
//     while(queue.length !== 0){
//         let len = queue.length;
//         for(let i=0;i<len;i++){
//             let node = queue.shift();
//             if(!result[level]){
//                 result[level]=[node.val]
//             }else{
//                 result[level].push(node.val)
//             }
//             if(node.left)queue.push(node.left);
//             if(node.right)queue.push(node.right);
//         }
//         level++;
//     }
//     return result
// };

二叉树前序遍历(leetcode144)

/**
 * @param {TreeNode} root
 * @return {number[]}
 */
 // 非递归解法-栈
var preorderTraversal = function(root) {
    if(!root){
        return [];
    }
    let stack = [root];
    let result = [];
    while(stack.length){
        let node = stack.pop();
        result.push(node.val);
        
        if(node.right){
            stack.push(node.right);
        }
        if(node.left){
            stack.push(node.left);
        }
        
    }
    return result;
};

二叉树后序遍历(leetcode145)

//非递归实现
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var postorderTraversal = function(root) {
    if(!root){
        return [];
    }
    let result = [];
    let stack = [root];
    while(stack.length){
        let node = stack.pop();
        result.unshift(node.val);
        if(node.left){
            stack.push(node.left);
        }
        if(node.right){
            stack.push(node.right);
        }
    }
    return result;
};
//递归实现
/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var postorderTraversal = function(root) {
    if(!root){
        return [];
    }
    let result = [];
    traverse(root,result);
    return result;
};

var traverse = function(node, result){
    if(node.left){
        traverse(node.left, result);
    }
    if(node.right){
        traverse(node.right, result);
    }
    result.push(node.val);
    return;
}

二叉树中序遍历(leetcode94)

非递归解法

/**
 * @param {TreeNode} root
 * @return {number[]}
 */
var inorderTraversal = function(root) {
    if(!root){
        return [];
    }
    let stack = [];
    let result = [];
    let curr = root;
    while(stack.length || curr!==null ){
    	// 把左子节点都入栈
        while(curr !== null){
            stack.push(curr);
            curr = curr.left;
        }
        // 弹出最左的节点
        let top = stack.pop();
        result.push(top.val);
        // 如果有右子树，遍历右子树
        curr = top.right;
    }
    return result;
};

二叉树路径总和(leetcode113)

给定一个二叉树和一个目标和，找到所有从根节点到叶子节点路径总和等于给定目标和的路径。

/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {TreeNode} root
 * @param {number} sum
 * @return {number[][]}
 */
//递归解法
var pathSum = function(root, sum) {
    var result = [];
    var traverse = function(node,total,arr){
        if(!node){
            return;
        }
        let path = [...arr,node.val];
        if(node.left===null&&node.right===null&&total+node.val===sum)        {
            result.push(path);
            return;
        }
        traverse(node.left,total+node.val,path);
        traverse(node.right,total+node.val,path);
    }
    traverse(root,0,[]);
    return result;
};
//栈解法
var hasPathSum = function(root, sum) {
    let stack = [];
    let result = false;
    if(root){
        stack.push([root,sum])
    }
    while(stack.length){
        let item = stack.pop();
        let node = item[0],remain = item[1];
        if(node.left===null && node.right===null && remain-node.val===0){
            result = true;
            break;
        }
        if(node.left){
            stack.push([node.left,remain-node.val]);
        }
        if(node.right){
            stack.push([node.right,remain-node.val]);
        }
    }
    return result;
};

二叉树Z字型遍历(leetcode103)

//队列方法
var zigzagLevelOrder = function(root) {
    
    let queue = [];
    let result = [];

    if(root){
        queue.push([root,0]);
    }
    while(queue.length){
        let item = queue.shift();
        let node = item[0],level=item[1];
        if(result[level]){
            if(level % 2 === 0){
                result[level].push(node.val);
            }else{
                result[level].unshift(node.val);
            }
        }else{
            result[level] = [node.val];
        }

        if(node.left){queue.push([node.left,level+1]);}
        if(node.right){queue.push([node.right,level+1]);}
        
    }
    return result;
};

从前序和中序遍历构造二叉树(leetcode105)

/**
 * @param {number[]} preorder
 * @param {number[]} inorder
 * @return {TreeNode}
 */
var buildTree = function(preorder, inorder) {
    var traverse = function(preorder, inorder){
        if(!preorder.length || !inorder.length){
            return null;
        }
        let t = preorder[0];
        let node = new TreeNode(t);
        let midIndex = inorder.indexOf(t);
        node.left = traverse(preorder.slice(1,midIndex+1),inorder.slice(0,midIndex));
        node.right = traverse(preorder.slice(midIndex+1),inorder.slice(midIndex+1));
        return node;
    }
    return traverse(preorder,inorder);
};

有序链表转换二叉搜索树（LeetCode 109）

/**
 * Definition for singly-linked list.
 * function ListNode(val) {
 *     this.val = val;
 *     this.next = null;
 * }
 */
/**
 * Definition for a binary tree node.
 * function TreeNode(val) {
 *     this.val = val;
 *     this.left = this.right = null;
 * }
 */
/**
 * @param {ListNode} head
 * @return {TreeNode}
 */
var sortedListToBST = function(head) {
    return createTree(head);
};
// 双指针解法
var createTree = function(head){
    // console.log(1,head);
    if(!head)return null;
    if(!head.next){
        return new TreeNode(head.val);
    }
    // p1指向中间节点的前一个节点，p2指向尾结点
    let p1 = head,p2 = head;
    let start = false;
    while(p2.next && p2.next.next){
        p2 = p2.next.next;
        if(!start){
            start = true;
            continue;
        }else{
            p1 = p1.next;
        }
    }
    // console.log('p1',p1);
    // console.log("=====")
    let node = new TreeNode(p1.next.val);
    let newH = p1.next;
    p1.next=null;
    node.left = head?createTree(head):null;
    node.right = newH.next?createTree(newH.next):null;
    return node;
}

判断二叉搜索树是否合理（leetcode98）

中序遍历递归解法

/**
 * @param {TreeNode} root
 * @return {boolean}
 */
var isValidBST = function(root) {
    if(!root){
        return true;
    }
    let result = true;
    let preValue = null;
    var traverse = function(node){
        if(node.left&&result){
            traverse(node.left);
        }
        if(preValue!==null){
            if(preValue>=node.val)result = false;
        }
        preValue = node.val;
        if(node.right&&result){
            traverse(node.right);
        }
    }
    traverse(root)
    return result;
};

官方解法
左右两个子树都是BST这个树才是BST，当前节点要满足在(lower,upper)区间内

var isValidBST = function(root) {
    if(!root){
        return true;
    }
    return helper(root,-Infinity,Infinity);
};

var helper = function(node,lower,upper){
    if(!node)return true;
    if(node.val<=lower || node.val>=upper){
        return false;
    }
    return helper(node.left,lower,node.val) && helper(node.right,node.val,upper)
}

二叉搜索树中第K小的元素

一般BST遍历==》中序遍历

/**
 * @param {TreeNode} root
 * @param {number} k
 * @return {number}
 */
var kthSmallest = function(root, k) {
    let stack = [];
    let curr = root;
    let count = 0;
    let result = null;
    while(stack.length || curr!==null){
        while(curr!==null){
            stack.push(curr);
            curr = curr.left;
        }

        let top = stack.pop();
        count++;
        if(count === k){
            result = top.val;
            break;
        }
        curr = top.right;
    }
    return result;
};

二叉树两个节点最近祖先（leetcode236）

//参考大佬的做法
/**
 * @param {TreeNode} root
 * @param {TreeNode} p
 * @param {TreeNode} q
 * @return {TreeNode}
 */
var lowestCommonAncestor = function(root, p, q) {
    //递归终止条件：节点为空，节点等于p或q
    if(!root || root === p || root === q)return root;
    //遍历左右子树
    let left = lowestCommonAncestor(root.left,p,q);
    let right = lowestCommonAncestor(root.right,p,q);
    //如果p和q在不同的子树，返回当前节点
    if(left && right) return root;
    //如果p和q在同一个子树，返回那个子树的节点
    return left?left:right;
};

全排列

输入: [1,2,3]
输出:
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
DFS+回溯算法

/**
 * @param {number[]} nums
 * @return {number[][]}
 */
var permute = function(nums) {
    let result = [];
    let len = nums.length;
    if(!len){
        return [];
    }
    let path = [];
    let used = [];
    dfs(nums,len,0,path,used,result);
    return result
};

var dfs = function(nums,len,depth,path,used,result){
    if(depth === len){
        result.push(path.slice());
        return;
    }
    for(let i=0;i<len;i++){
        if(used[i]){
            continue;
        }
        path.push(nums[i]);
        used[i] = true;
        dfs(nums,len,depth+1,path,used,result);
        path.pop();
        used[i] = false;
    }
}

反转链表

/**
 * @param {ListNode} head
 * @return {ListNode}
 */
// 递归解法
var reverseList = function(head) {
    if(!head)return null;
    if(head.next === null)return head;
    let last = reverseList(head.next);
    head.next.next = head;
    head.next = null;
    return last;
};

// 迭代解法
var reverseList = function(head) {
    if(!head)return null;
    let pre = head, curr = head.next, newHead=head;
    while(curr!==null){
        newHead = curr;
        curr = curr.next;
        newHead.next = pre;
        if(pre===head)pre.next = null;
        pre = newHead;
    }
    return newHead;
};

对称二叉树（LeetCode101）

对称二叉树

/**
 * @param {TreeNode} root
 * @return {boolean}
 */
 // 非递归解法
var isSymmetric = function(root) {
    if(!root)return true;
    let queue = [root.left,root.right];
    while(queue.length!==0){
        let v1 = queue.shift();
        let v2 = queue.shift();
        if(v1 === null && v2 === null){
            continue;
        }
        if(v1 ===null || v2===null){
            return false;
        }
        if(v1.val !== v2.val){
            return false;
        }
        queue.push(v1.left);
        queue.push(v2.right);
        queue.push(v1.right);
        queue.push(v2.left);
    }
    return true;
};
// 递归解法
// var isSymmetric = function(root) {
//     if(!root)return true;
//     return isMirror(root.left,root.right)
// };

// var isMirror = function(p,q){
//     if(p === null && q === null)return true;
//     if(p === null || q === null)return false;
//     return p.val === q.val && isMirror(p.left,q.right)
//     && isMirror(p.right,q.left);
// }

平衡二叉树（LeetCode110）

/**
 * @param {TreeNode} root
 * @return {boolean}
 */
 // 递归解法
var isBalanced = function(root) {
    if(!root)return -1;
    return Math.abs(depth(root.left)-depth(root.right))<2 && isBalanced(root.left) && isBalanced(root.right);
};

var depth = function(root){
    if(!root)return 0;
    return Math.max(depth(root.left),depth(root.right))+1;
}

二叉树的最小深度（LeetCode 111）

/**
* 递归解法
* 当前节点的最小深度 = 左右子节点最小深度+1
*/
var minDepth = function(root){
    if(!root)return 0;
    if(root.left === null && root.right === null){
        return 1;
    }
    let min = Infinity;
    if(root.left)min = Math.min(minDepth(root.left),min);
    if(root.right)min = Math.min(minDepth(root.right),min);
    return min+1;
}

/**
* 层次遍历 遇到的第一个叶子节点所在深度就是最小深度
*/
var minDepth = function(root) {
    if(!root)return 0;
    let queue = [root];
    let level = 1;
    while(queue.length){
        let len = queue.length;
        for(let i = 0;i<len;i++){
            let node = queue.shift();
            if(node.left === null && node.right === null){
                return level;
            }
            if(node.left)queue.push(node.left);
            if(node.right)queue.push(node.right);
        }
        level++;
    }
};

二叉树路径总和（LeetCode 112）

给定二叉树和目标值，是否存在一条路径和为目标值

/**
 * @param {TreeNode} root
 * @param {number} sum
 * @return {boolean}
 */
 /**
  * 栈解法
  * 栈里存储节点和剩余的值
  */
var hasPathSum = function(root, sum) {
    let stack = [];
    let result = false;
    if(root){
        stack.push([root,sum])
    }
    while(stack.length){
        let item = stack.pop();
        let node = item[0],remain = item[1];
        if(node.left===null && node.right===null && remain-node.val===0){
            result = true;
            break;
        }
        if(node.left){
            stack.push([node.left,remain-node.val]);
        }
        if(node.right){
            stack.push([node.right,remain-node.val]);
        }
    }
    return result;
};
 /**
  * 递归解法
  */
var hasPathSum = function(root, sum) {
    return trans(root,0,sum);
};

var trans = function(node, total, sum){
    if(!node){
        return false;
    }
    if(node.left===null&&node.right===null){
        return total + node.val === sum;
    }

    return trans(node.left, total+node.val, sum) || trans(node.right, total+node.val, sum);
    
}

旋转数组（LeetCode 189）

给定一个数组，将数组中的元素向右移动 k 个位置，其中 k 是非负数。
输入: [1,2,3,4,5,6,7] 和 k = 3
输出: [5,6,7,1,2,3,4]
思路：
[1,2,3,4,5,6,7]
[7,6,5,4,3,2,1] 反转数组
[5,6,7|1,2,3,4] 从第k个位置两边分别反转

/**
 * @param {number[]} nums
 * @param {number} k
 * @return {void} Do not return anything, modify nums in-place instead.
 */
var rotate = function(nums, k) {
    let len = nums.length;
    let forward = k % len;

    reverse(nums,0,len-1);
    reverse(nums,0,forward-1);
    reverse(nums,forward,len-1);
};

var reverse = function(nums,start,end){
    while(start<end){
        let temp = nums[start];
        nums[start]=nums[end];
        nums[end] = temp;
        start++;
        end--;
    }
}
欲语含羞
关注
专栏目录
力扣二叉树专题Ⅰ
BlingBling_An_的博客
08-08 210
二叉树基础理论 满二叉树 只有度数为零和度数为二的结点，且度数为零的结点在同一层上。 深度为k，有2^k-1个结点的二叉树 完全二叉树 从满二叉树而来，从右下角水平向左去掉结点而形成的树。 若最底层为第h层，则该层包含[1, 2^h-1]个结点。 用完全二叉树实现优先队列（堆排序）—— 把优先值最大的元素(根结点)出列，可分为如下步骤： 1.交换首尾两个元素的位置，这样尾元素将会成为根结点，堆有序被打破； 2.剪掉被交换到末尾的原根元素； 3.把交换到根结点的元素下沉到合适位置，重新调整为大顶堆；.
二叉树的基本操作的实现
linlinlin45的博客
04-06 1541
树 树的定义 树(Tree)是n(n>=0)个结点的有限集。当有限集T为空时称为空树； 当T不为空时，它满足两个条件： 有且仅有一个特定的称为根(root)的结点； 其余的结点可分为m(m>=0)个互不相交的子集T1,T2,T3…Tm，其中每个子集又是一棵树，并称其为子树(Subtree)。 基本术语 树的结点包含一个数据元素及若干指向其子树的分支 度为0的结点称为叶子结点（le...
110.平衡二叉树
爱吃草莓蛋糕的猴博客
08-17 330
目录1.题目2.题目分析3.代码实现4.代码改进 1.题目 给定一个二叉树，判断它是否是高度平衡的二叉树。 本题中，一棵高度平衡二叉树定义为： 一个二叉树每个节点 的左右两个子树的高度差的绝对值不超过1。 示例 1: 给定二叉树 [3,9,20,null,null,15,7] 3 / \ 9 20 / \ 15 7 返回 true 。 示例 2: 给定二叉树 [1,2,2,3,3,null,null,4,4] 1 / \ 2
二叉树翻转
贪婪的君子
08-27 1118
二叉树翻转是一道比较简单，但是又非常有意思的算法问题。
二叉树进阶
cefler的博客
10-24 265
二叉树进阶
二叉树给我的人生感悟
阅读修身
06-16 1115
人生的意义到底是什么呢？ 我们活着到底是为了找寻什么呢？ 有的人说活着就是为了寻找一个目标，然后为之奋斗。但是这样是不是太过于单调呢？生命就像一个无限分支的二叉树，向下，直到生命终结。而咱们人生的选择只能算是其中的一个分支，如果人生就像是刚才所说那样，找一个目标然后奋斗一生，这样是不是太过于单调了呢？二叉树如下图所示（可以继续往下一直分叉）。 但是作为好奇心极其强烈的人类来说
C语言——二叉树的遍历
qq_43556680的博客
07-19 1027
如果你是一个开发人员，或多或少对树型结构都有一定的认识，我个人对树型数据结构是又爱又恨。二叉树作为树的一种,是一种重要的数据结构,也是面试官经常考的东西。这篇文章主要分享下关于二叉树相关的知识点，并用go语言实现一个二叉树和对二叉树进行遍历。
详解二叉树之堆
forever的博客
07-25 2855
二叉树和堆的相关概念和结构的介绍和学习到这里就结束啦~但是数据结构的学习之路远没有结束哈！这是非线性结构的开端，后面还有大力输出学习非线性结构。但是在这里，希望大家能够将前面的树的基础概念以及之前的线性结构知识进行回顾复习，使整个纯C数据结构学习是连贯的，这样更加利于我们的学习和理解以及继续拓展。。学习数据结构当然离不开大量操作练习，因此在这里🌷给爱学习的小伙伴们推荐个学习、刷题的网站——牛客网，其中面试题应有尽有，真的能够给你带来很好的学习体验。👇👇👇爱学习的亲们！🎉🎉🎉请点击我开始注册！...
java二叉树建立二叉树_用java先序创建二叉树的问题
weixin_28706923的博客
02-12 159
import java.io.*;class Node{Node left;Node right;char str;public Node(){this.right=null;this.left=null;}public Node(char str){this(str,null,null);}public Node(char str, Node left, Node right){this.str...
算术表达式和二叉树-数据结构课设
05-25
我需要写一个程序，实现基于二叉树表示的算术表达式的操作。 1.2这个算法的要求 假设算术表达式Expression内可以含有变量(a~z)、常量(0~9)和二元运算符(+，，*，/, ^(乘幂)。实现以下操作: (1) ReadExpre(E)- _以...
数据结构（十九） -- C语言版 -- 树 - 树、森林、二叉树的江湖爱恨情仇、相互转换
青椒*^_^*凤爪爪的博客
06-28 6244
在满足树的条件下，树可以是任意形状，一个节点可以有任意多个孩子。在前面的存储结构中，提到了树的孩子兄弟方法可以将一个树用二叉链表进行存储，所以借助二叉链表，树和二叉树可以进行相互转换，从物理结构来看，他们的二叉链表是相同的。因此，只要我们设定一定的规则，用二叉树来表示树甚至森林是可以，森林与二叉树也可以相互转换。
数据结构|二叉树的三种遍历方式，你掌握了几种？
热门推荐
我的主页
04-15 1万+
本期讲解二叉树的三种遍历方式：前序遍历、中序遍历、后序遍历的详细讲解，图文并茂通俗易懂。
＜使用生成式AI对四种冒泡排序实现形式分析解释的探讨整理＞
m0_57859086的博客
10-01 1149
/冒泡排序实现1——不常用（这个版本两层for循环分别是i++、j++）// 声明三个整型变量i、j和temp用于循环控制和交换元素for (i = 0;i < n - 1;i++) { // 外层循环，从数组的第一个元素开始遍历到倒数第二个元素j < n;j++) { // 内层循环，从当前外层循环位置的下一个元素开始遍历到最后一个元素if (A[i] > A[j]) { // 如果当前元素大于下一个元素// 将当前元素存储到临时变量temp中// 将下一个元素赋值给当前元素。
【理论科学与实践技术】数学与经济管理中的学科与实用算法
wnm23的专栏
10-02 759
在现代商业环境中，数学与经济管理的结合为企业提供了强大的决策支持。本文将介绍几个主要学科，包括数学基础、经济学模型、管理学及风险管理，并探讨相关的实用算法和这些算法在中国及全球知名企业中的实际应用。
算法：按既定顺序创建目标数组
AWSDN的博客
09-29 255
本文主要介绍按既定顺序创建目标数组问题
DAY17||654.最大二叉树 |617.合并二叉树 |700.二叉搜索树中的搜索 |
2301_79865280的博客
09-29 1320
给定一个不含重复元素的整数数组。通过给定的数组构建最大二叉树，并且输出这个树的根节点。示例 ：构造二叉树一定要，因为要先找到中，才能分割左右子树。本题图解思路：本题做过上一题构建数组确实变得容易很多。代码优化方向有，不用每次找左右子树的时候构建新的数组的话效率就会高很多。（即直接用下标索引直接在原数组上操作）关于加不加if的问题，如果允许空节点进入递归，就不加。
【韩顺平Java笔记】第6章：数组、排序和查找
随手写写
10-02 728
排序是将多个数据，依指定的顺序进行排列的过程。
【算法】---归并排序（递归非递归实现）
最新发布
何春秋的博客
10-03 1085
归并排序 in Java
二叉树遍历与线索二叉树详解
"树和二叉树是数据结构中的重要概念，主要讨论在计算机科学中用于组织和存储数据的非线性数据结构。二叉树由根节点、左子树和右子树三个基本单元构成，其特性使得遍历成为关键操作。本节关注于二叉树的遍历方式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值