JS实现二叉树算法

最新推荐文章于 2023-06-26 14:20:22 发布
最新推荐文章于 2023-06-26 14:20:22 发布
阅读量1k 收藏 4
点赞数
分类专栏： 数据结构及算法 文章标签： 二叉树 数据 结构 JavaScript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_28979467/article/details/90324050
版权

本文通过js来认识什么是二叉树、如何构建二叉树、二叉树有哪几种遍历算法及节点删除操作实现

什么是二叉树

二叉树是n个结点的有限集合，该集合或者为空集，或者由一个根结点和两颗互不相交的、分别称为根结点的左子树和右子树的二叉树组成。如下图1为二叉树：

JS构建二叉树

约定右子树的节点值都大于左子树节点的值（也可以是左子树节点值大于右子树节点值）。数组第一个元素作为根节点的值、根据数组元素的顺序构建二叉树。首先通过类来定义二叉树的，这个类具有节点的节点结构属性、根节点属性及节点插入方法。

//二叉树
function BinaryTree() {
    
    // 节点结构
	var Node = function(key){
		this.key = key;
		this.left = null;
		this.right = null;
	};

    //根节点
	var root = null;

    //新增节点
    var insertNode = function(node,newNode){
    	//约定右孩子都大于左孩子节点
    	if(newNode.key<node.key){
    		if(node.left === null){//没有左孩子，则新增左孩子
    			node.left = newNode;
    		}else{
    			//如果有左孩子则递归算法实现插入左孩子节点
    			insertNode(node.left,newNode);
    		}
    	}else {
    		//如果有孩子为null，则新增右孩子
    		if(node.right===null){
    			node.right = newNode;
    		}else{
    			//如果有左孩子则递归算法实现插入右孩子节点
    			insertNode(node.right,newNode);
    		}
    	}
    };
    // 插入新节点
	this.insert =function(key){
		//创建节点
       var node = new Node(key);
       if(root === null){//判断是否为根节点
       	 root = node;
       }else {
       	// 不是根节点则新增节点
       	 insertNode(root,node);
       }
	};
}

图1的二叉树的实现

//构建二叉树
var nodes = [6,2,3,4,9,8,7,12,1,22]
var binaryTree = new BinaryTree();
nodes.forEach(function(key){
    binaryTree.insert(key);
});

二叉树的几种遍历算法

  • 如图1中序遍历结果：1 2 3 4 6 7 8 9 12 22
  • 如图1前序遍历结果：6 2 1 3 4 9 8 7 12 22
  • 如图1后序遍历结果：1 4 3 2 7 8 22 12 9 6
中序遍历原理

先处理左节点，接着处理中节点最后处理右节点，递归遍历所有节点。
实现：在BinaryTree类添加中序遍历方法,callback为处理函数，主要是输出节点值（几种遍历算法涉及的callback都是统一个方法），在调用几种遍历算法作为参数转入。

// 中序遍历二叉树
var traverseNodesLDR = function(node,callback){
 if(node !== null){
    traverseNodesLDR(node.left,callback);
    callback(node.key);
    traverseNodesLDR(node.right,callback)
 }
}
// 中序遍历算法
this.LDR = function(callback){
   traverseNodesLDR(root,callback);
}
前序遍历原理

先处理中节点，接着处理左节点再处理右节点，递归遍历所有所有节点。
实现：在BinaryTree类中添加前序遍历方法

// 前序遍历二叉树
var traverseNodesDLR = function(node,callback){
	if(node!==null){
		callback(node.key);
		traverseNodesDLR(node.left,callback);
		traverseNodesDLR(node.right,callback);
	}
}
//前序遍历算法
this.DLR = function(callback) {
	traverseNodesDLR(root,callback);
}
后序遍历原理

先处理左点击（右节点），接着处理右节点（左节点）最后处理中节点
实现：在BinaryTree中添加后序遍历方法

//后序遍历二叉树
var traverseNodesLRD = function(node,callback){
   if(node!==null){
   	traverseNodesLRD(node.left,callback);
   	traverseNodesLRD(node.right,callback);
   	callback(node.key);
   }
}
//后序遍历算法
this.LRD = function(callback){
	traverseNodesLRD(root,callback);
}

二叉树查找

首先需要理解什么是叶子：叶子即是没有左右孩子的节点，如图1叶子有 1 4 7 22；
叶子的父节点即是叶子节点上一层节点，如图1叶子父节点有2 3 8 12

查找最大值算法实现

原理：查找右子树（针对本案例）的右叶子或中节点（右叶子的父节点）

//遍历右子树
var traverseRight = function(node,callback){
	if(node!==null){
		if(node.right!==null){
           traverseRight(node.right,callback);
		}else{
			callback(node.key);
		}
	}else{
     throw new TypeError('空二叉树')
	}
}
//获取最大值
this.getMaxValue = function(callback){
	traverseRight(root,callback);
}
查找最小值算法实现

原理：在左子树中查找左叶子节点或中节点（左叶子的父节点）

//遍历左子树
var traverseLeft = function(node,callback){
	if(node!=null){

    	// 排序二叉树（本demo约定）右子树大于左子树
        if(node.left!==null){
        	traverseLeft(node.left,callback);
        }else
        {
        	// 返回最小值
        	callback(node.key)
        }
	} else{
     throw new TypeError('空二叉树')
	}
}
//获取最小值
this.getMinValue=function(callback){
	traverseLeft(root,callback);
}
判断一个值是否在二叉树中算法实现

原理：判断给定的值是否大于根节点，大于递归遍历右子树（本案例），小于小于遍历左子树，存在则返回true，否则false

// 遍历查找二叉树
var traverseNode= function(node,key){
	if(node === null){
		return false;
	}

	if(node.key<key){
		return traverseNode(node.right,key);
	}else if(node.key>key){
		return traverseNode(node.left,key)
	}else{
		return true;
	}
}
//查找指定的值是否在二叉树中
this.isExitInTree = function(key){
	return traverseNode(root,key);
}

节点删除算法实现

原理：

  1. 删除叶子节点（左右孩子节点都没有），直接把叶子节点设置为null接口
  2. 删除仅包含左子节点的中节点，把左孩子节点指向null
  3. 删除仅包含右节点的中节点，把有孩子节点设置为null
  4. 删除左右节点都有的中间节点，查找右子树的最小节点值，替换删除节点值，并把右子树最小的节点值删除
//删除节点
var removeNode = function(node,key){
  if(node ===null){
  	return null
  }
  if(key<node.key){
  	node.left=removeNode(node.left,key);
  	return node;
  }else if(key>node.key){
  	node.right = removeNode(node.right,key);
  	return node;
  }else{
  	//删除节点
  	//1、删除没有左右子树的节点
  	if(node.left ===null && node.right ===null){
  		node =null;
  		return node;
  	}
  	//2、删除只有右子树的节点
  	if(node.left === null){
  		node = node.right;
  		return node;
  	}
  	//3、删除只有左子树的节点
  	if(node.right === null){
  		node = node.left;
  		return node;
  	}
  	//4、删除左右子树都有的节点

  	//4.1查找右子树中最小的节点N，
    var minNode = getMinNode(node.right);
    //4.2用N替换需要删除的节点，
    node.key = minNode.key;
    //4.3删除右子树最小的节点
    node.right = removeNode(node.right,minNode.key);
    return node
  }
}

this.deleteNode = function(key){
   removeNode(root,key);
}

完整算法代码

//二叉树节点
function BinaryTree() {
    
    // 节点结构
	var Node = function(key){
		this.key = key;
		this.left = null;
		this.right = null;
	};

    //根节点
	var root = null;

    //新增节点
    var insertNode = function(node,newNode){
    	//约定右孩子都大于左孩子节点
    	if(newNode.key<node.key){
    		if(node.left === null){//没有左孩子，则新增左孩子
    			node.left = newNode;
    		}else{
    			//如果有左孩子则递归算法实现插入左孩子节点
    			insertNode(node.left,newNode);
    		}
    	}else {
    		//如果有孩子为null，则新增右孩子
    		if(node.right===null){
    			node.right = newNode;
    		}else{
    			//如果有左孩子则递归算法实现插入右孩子节点
    			insertNode(node.right,newNode);
    		}
    	}
    };
    // 插入新节点
	this.insert =function(key){
		//创建节点
       var node = new Node(key);
       if(root === null){//判断是否为根节点
       	 root = node;
       }else {
       	// 不是根节点则新增节点
       	 insertNode(root,node);
       }
	};

   // 中序遍历二叉树
    var traverseNodesLDR = function(node,callback){
     if(node !== null){
        traverseNodesLDR(node.left,callback);
        callback(node.key);
        traverseNodesLDR(node.right,callback)
     }
    }
    // 中序遍历算法
	this.LDR = function(callback){
       traverseNodesLDR(root,callback);
	}

    // 前序遍历二叉树
	var traverseNodesDLR = function(node,callback){
		if(node!==null){
			callback(node.key);
			traverseNodesDLR(node.left,callback);
			traverseNodesDLR(node.right,callback);
		}
	}
	//前序遍历算法
	this.DLR = function(callback) {
		traverseNodesDLR(root,callback);
	}

    //后序遍历二叉树
    var traverseNodesLRD = function(node,callback){
       if(node!==null){
       	traverseNodesLRD(node.left,callback);
       	traverseNodesLRD(node.right,callback);
       	callback(node.key);
       }
    }
    //后序遍历算法
	this.LRD = function(callback){
		traverseNodesLRD(root,callback);
	}

    //===================二叉树查找======================== 
    //遍历左子树
    var traverseLeft = function(node,callback){
    	if(node!=null){

	    	// 排序二叉树（本demo约定）右子树大于左子树
	        if(node.left!==null){
	        	traverseLeft(node.left,callback);
	        }else
	        {
	        	// 返回最小值
	        	callback(node.key)
	        }
    	} else{
         throw new TypeError('空二叉树')
    	}
    }
	//获取最小值
	this.getMinValue=function(callback){
		traverseLeft(root,callback);
	}
    
    //遍历右子树
    var traverseRight = function(node,callback){
    	if(node!==null){
    		if(node.right!==null){
               traverseRight(node.right,callback);
    		}else{
    			callback(node.key);
    		}
    	}else{
         throw new TypeError('空二叉树')
    	}
    }
    //获取最大值
	this.getMaxValue = function(callback){
		traverseRight(root,callback);
	}

    // 遍历查找二叉树
    var traverseNode= function(node,key){
    	if(node === null){
    		return false;
    	}

		if(node.key<key){
			return traverseNode(node.right,key);
		}else if(node.key>key){
			return traverseNode(node.left,key)
		}else{
			return true;
		}
    }
    //查找指定的值是否在二叉树中
	this.isExitInTree = function(key){
		return traverseNode(root,key);
	}

     //查询最小节点
     var getMinNode = function(node){
     	if(node!==null){
     		if(node.left !== null){
     			return getMinNode(node.left)
     		}else{
     			return node;
     		}
     	}
     }
     
	//删除节点
	var removeNode = function(node,key){
      if(node ===null){
      	return null
      }
      if(key<node.key){
      	node.left=removeNode(node.left,key);
      	return node;
      }else if(key>node.key){
      	node.right = removeNode(node.right,key);
      	return node;
      }else{
      	//删除节点
      	//1、删除没有左右子树的节点
      	if(node.left ===null && node.right ===null){
      		node =null;
      		return node;
      	}
      	//2、删除只有右子树的节点
      	if(node.left === null){
      		node = node.right;
      		return node;
      	}
      	//3、删除只有左子树的节点
      	if(node.right === null){
      		node = node.left;
      		return node;
      	}
      	//4、删除左右子树都有的节点

      	//4.1查找右子树中最小的节点N，
        var minNode = getMinNode(node.right);
        //4.2用N替换需要删除的节点，
        node.key = minNode.key;
        //4.3删除右子树最小的节点
        node.right = removeNode(node.right,minNode.key);
        return node
      }
	}
 
   this.deleteNode = function(key){
   	removeNode(root,key);
   }

}


//构建排序二叉树 
var nodes = [6,2,3,4,9,8,7,12,1,22]
var binaryTree = new BinaryTree();
nodes.forEach(function(key){
    binaryTree.insert(key);
});

//处理节点方法
var callback = function(key){
	console.log(key)
}
//中序遍历
console.log('中序遍历结果:')
binaryTree.LDR(callback)

//前序遍历
console.log('前序遍历结果：');
binaryTree.DLR(callback);

//后序遍历
console.log('后序遍历结果：');
binaryTree.LRD(callback);

console.log("最大值：");
binaryTree.getMaxValue(callback);

console.log("最小值：");
binaryTree.getMinValue(callback);

console.log('22是否存在二叉树中：'+binaryTree.isExitInTree(22))

console.log('删除节点')
binaryTree.deleteNode(4);
binaryTree.deleteNode(9);

更多分享请关注

Star_Fire5
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JavaScript数据结构之二叉树常见算法
The_upside_of_down的博客
11-27 277
一、二叉树层级遍历 // 初始化二叉树 function TreeNode(val){ this.val = val; this.left = this.right =null; } function levelOrder(root) { var res = []; if(!root) return re...
js实现二叉树常见算法操作
weixin_43601554的博客
08-04 555
1. 二叉树的中序遍历 leetcode94 方法一：递归 var inorderTraversal = function(root) { let result = []; let inorder = function(node){ node.left && inorderTraversal(node.left); result.push(node.val); node.right
JS算法之二叉树、二叉搜索树
weixin_52884694的博客
09-22 262
❝ 杠杆的本质，是一种以小博大的模型 ❞ 大家好，我是「柒八九」。 今天，我们继续探索JS算法相关的知识点。我们来谈谈关于树Tree 的相关知识点和具体的算法。 如果，想了解其他数据结构的算法介绍，可以参考我们已经发布的文章。如下是算法系列的往期文章。 文章list 整数常规排序算法数组字符串链表栈队列 好了，天不早了，干点正事哇。 你能所学到的知识点 ❝ 知识点简讲 树在前端开发中的应用场景「二叉树深度优先遍历 递归和迭代的JS版本」 二叉树相关算法二叉搜索树（BST）相关算法 ❞ 知识点简讲
关于二叉树的算法（JavaScript）
fish_dream
06-28 853
关于二叉树的高频算法题
JavaScript二叉树及各种遍历算法详情
百创科技
06-26 572
二叉树是每个节点最多只能有两个子节点的树，如下图所示：第i层的节点最有只有2^(i-1)个；如果这颗二叉树的深度为k，那二叉树最多有2^k-1个节点；在一个非空的二叉树中，若使用n0表示叶子节点的个数，n2是度为2的非叶子节点的个数，那么两者满足关系。
js实现二叉树的遍历
程序媛的梦工厂
08-21 953
前序 递归 非递归 中序 递归 非递归 后序 递归 非递归
JS构造二叉树
a777756的博客
05-29 896
方式1： class Node { // 定义节点 constructor(data){ this.data = data this.leftChild = null this.rightChild = null } } const createTree = (arr) => { // 创建二叉树 let tree = new Node(arr[0]) let Nodes = [tree] let i = 1 for (let node of Node
JS实现的二叉树算法完整实例
10-20
总结来说，JS实现的二叉树算法实例涵盖了二叉树的基本概念、节点定义、树的构建以及遍历方法。这个实例通过递归和栈来演示了如何操作二叉树，这对于理解二叉树的逻辑和结构非常有帮助。通过掌握这些基本操作，开发者...
javascript实现二叉树的代码
10-19
在本文中，我们将深入探讨如何使用JavaScript实现二叉搜索树（Binary Search Tree，简称BST）。二叉搜索树是一种特殊的二叉树，它的每个节点都遵循特定的规则：左子节点的值小于父节点的值，而右子节点的值大于或...
js实现搜索二叉树.rar
06-08
在JavaScript中实现二叉树是一种常见且重要的编程技巧，它涉及到数据结构和算法的理解。二叉树是一种非线性数据结构，每个节点最多有两个子节点，通常分为左子节点和右子节点。在这个主题中，我们将深入探讨如何使用...
js二叉树数据结构实现
08-01
js二叉树数据结构实现，可帮助快速项目开发，nodejs调试
javascript实现二叉树遍历的代码
10-19
在本文中，我们将深入探讨JavaScript实现二叉树遍历的方法。首先，二叉树是一种数据结构，其中每个节点最多有两个子节点，通常称为左子节点和右子节点。我们通过创建一个`Node`构造函数和一个`BST`（二叉搜索树）...
js实现二叉搜索树
混世小妲己
02-28 135
二叉搜索树
javascript-二叉树
qq_43368682的博客
09-25 328
二叉树 二叉树（Binary Tree）也称为二分树、二元树或对分树等。它是n（n≥0）个有限元素的集合，该集合或者为空，或者由一个称为根（root）的元素及两个不相交的、被分别称为左子树和右子树的二叉树组成。当集合为空时，称该二叉树为空二叉树。 重要性质 性质1：一棵非空二叉树的第i层上最多有2i-1个结点（i≥1）。 性质2：一棵深度为k的二叉树中，最多具有2k-1个结点，最少有k个结点。 性质3：对于一棵非空的二叉树，度为0的结点（即叶子结点）总是比度为2的结点多一个，即如果叶子结点数为n0，度数为2
js通过数组创建二叉树
Maximus_ckp的博客
06-01 1643
js通过数组生成二叉树
js数组层序建立二叉树
乔路非
01-26 6734
将数组[‘A’,‘B’,‘C’,‘D’,‘E’,‘F’,‘G’,‘H’]层序建立为二叉树，如下图所示。 建立二叉树 class Node { // 定义节点 constructor(data){ this.data = data this.leftChild = null this.rightChild = null } } const createTree = (arr) => { // 创建二叉树 let tree =
数据结构笔记（四）
ziyu_one的博客
02-24 624
  数据结构——栈和队列 1、第四章：栈和队列 通过下面的思维导图来依次分享「栈和队列」里面重要知识点的笔记。 2、第一节：树的基本特点 1.  树的定义：树是N(N≥0)个结点的有限集合，N=0时，称为空树，在任意一棵非空树中应满足： ①有且仅有一个特定的称为根的结点； ②当N&gt;1时，其余结点可分为m(m&gt;0)个互不相交的有限集合T1，T2，……，Tm，其中每一个集...
javascript 二叉树(Trees)算法与说明
rth362147773的博客
09-15 2651
二叉树的介绍树是一个非顺序数据结构，它对于存储需要快速查找的数据非常有用。现实例子就是公司的组织架构，总裁为树的最顶端叫根节点，各部门按照领导人区分为子树。 二叉树术语概念整个二叉树结构中，每个点叫作节点，每个节点都有父节点，而最上面的为根节点，根节点是没有父节点的。 节点另外一个属性为深度，是根据父节点有多少个来算的。 由根节点向下分的2个节点为子树，子树下面节点也是子树。 如图：
利用JavaScript实现二叉树（Binary Tree）算法
Heisenfang的博客
03-14 490
学习前端已经有段时间了，也开始想写点什么了。今天是第一篇文章，用JS写一个二叉树算法。首先介绍一下二叉树，完整定义可以去维基百科，我这里粗略介绍一下主要内容。二叉树作为树的一种，是一种重要的数据结构，常见的二叉树有:满二叉树：除叶子结点外，所有结点都有两个结点，叶子结点的left，right为NULL哈夫曼树：又称为最优二叉数，是一种带权路径最短的树。哈夫曼编码就是哈夫曼树的应用,可以用来进行编码...
给我一段使用js写的反转二叉树算法
最新发布
07-15
当然！以下是使用 JavaScript 编写的反转二叉树（翻转二叉树）的算法示例代码： ```javascript function TreeNode(val, left, right) { this.val = val; this.left = left; this.right = right; } function invertTree(root) { if (root === null) { return null; } var temp = root.left; root.left = root.right; root.right = temp; invertTree(root.left); invertTree(root.right); return root; } // 示例用法: var tree = new TreeNode(4); tree.left = new TreeNode(2); tree.right = new TreeNode(7); tree.left.left = new TreeNode(1); tree.left.right = new TreeNode(3); tree.right.left = new TreeNode(6); tree.right.right = new TreeNode(9); console.log(invertTree(tree)); ``` 以上代码定义了一个名为 `TreeNode` 的构造函数，用于创建二叉树的节点。然后，定义了一个名为 `invertTree` 的函数，它接受一个二叉树的根节点作为参数，并返回反转后的二叉树的根节点。 在 `invertTree` 函数中，首先判断根节点是否为空，如果为空则直接返回 null。然后，通过交换根节点的左右子节点，实现对当前节点的翻转。接着，递归调用 `invertTree` 函数对当前节点的左子树和右子树进行翻转。最后，返回翻转后的根节点。 示例用法中创建了一个二叉树，并打印出反转后的二叉树的结构。你可以根据实际需求和二叉树的结构来使用这段代码。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值