二叉树(js实现)

二叉树

  • 基本概念
    • 基本术语
    • 二叉树类型
    • 性质
  • 遍历
    • 前序遍历
    • 中序遍历
    • 后序遍历
    • 层序遍历
  • 二叉搜索树
  • 镜像二叉树
  • 重建二叉树
  • 其它常见算法题
    • 求二叉树深度
    • 二叉树结点总数
    • 叶子结点数
    • 判断二叉树子结构
    • 将二叉搜索树转换成一个排序的双向链表


基本概念

二叉树是n个有限元素的集合,该集合或者为空、或由一个称为(root)的元素及两个不相交的、被分别称为左子树右子树的二叉树组成


基本术语

  • 结点之间的关系
    • 若一个结点有子树,那么该结点称为子树根的双亲,子树的根称为该结点的孩子
    • 有相同双亲的结点互为兄弟
    • 一个结点的所有子树上的任何结点都是该结点的后裔
    • 从根结点到某个结点的路径上的所有结点都是该结点的祖先
  • 结点层:根结点的层定义为第一层,根的孩子为第二层,依此类推
  • 树的深度:树中最大的结点层
  • 结点的度:结点拥有的子树的个数
  • 树的度: 树中最大的结点度
  • 叶子结点:也叫终端结点,是度为 0 的结点
  • 分枝结点:度不为0的结点

二叉树类型

  • 完全二叉树
    一棵二叉树中,只有最下面两层结点的度可以小于2,并且最下层的叶结点集中在靠左的若干位置上
    二叉树(js实现)_第1张图片

    • 判断
      思路:一棵完全二叉树,其某结点如果没有左孩子就一定不能有右孩子,且某结点没有左孩子或右孩子则它后面就不能有孩子
      function isCompleteTree(root)
      {
               
      	if(!root)
      		return true;
      	var flag = 0;
      	var queue = [];
      	queue.push(root);
      	while(queue.length != 0)
      	{
               
      		var node = queue.shift();
      
      		if(!node.left)
          		flag = 1;//表示后面不能有节点了
      		else if(node.left && flag == 0)
          		queue.push(node.left);
      		else if(node.left && flag == 1)
          		return false;
      
      		if(!node.right)
          		flag = 1;
      		else if(node.right && flag == 0)
          		que.push(node.right);
      		else if(node.right && flag == 1)
          		return false;
      	}
      	return true;
      }
      
  • 满二叉树
    一棵满二叉树必定是一棵完全二叉树,而完全二叉树不一定是满二叉树
    二叉树(js实现)_第2张图片

  • 平衡二叉树
    是一棵空树,或它的左右两个子树的高度差的绝对值不超过1,并且左右两个子树都是一棵平衡二叉树

    • 判断一个树是否为平衡二叉树
      function maxDepthOfTree(node)
      {
               
      	if(!node)
      		return 0;
      	return Math.max(maxDepthOfTree(node.left),maxDepthOfTree(node.right))+1;
      }
      
      function isBalanced(node)
      {
               
      	if(!node)
      		return true;
      	var left = maxDepthOfTree(node.left);
      	var right = maxDepthOfTree(node.right);
      	if(Math.abs(left-right) > 1)
      		return false;
      	return isBalanced(node.left) && isBalanced(node.right);
      }
      

性质

  • 在二叉树的第 i 层上最多有2^(i-1)个结点(i>=1)
  • 深度为h的二叉树,最多有2^h-1个结点,最少有h个结点(h>=1)
  • 包含n个结点的二叉树的高度至少为(log2n)+1
  • 在任意一棵二叉树中,若终端结点的个数为n0,度为2的结点数为n2,则n0=n2+1

遍历

前序遍历

根结点 -> 左子树 -> 右子树

//递归
function preOrder(root)
{
     
    if(!root)
        return;
    console.log(root.val);
    preOrder(root.left);
    preOrder(root.right);
}

//非递归
function preOrder(root)
{
     
    var stack = [];
    var node = root;
    while(node || stack.length != 0){
     
        //循环访问节点的左子结点并入栈
        while(node){
     
            console.log(node.val);
            stack.push(node);
            node = node.left;
        }
        if(stack.length != 0){
     
            node = stack.pop();
            node = node.right();
        }
    }
}

中序遍历

左子树 -> 根结点 -> 右子树

//递归
function inOrder(root)
{
     
    if(!root)
        return;
    preOrder(root.left);
    console.log(root.val);
    preOrder(root.right);
}

//非递归
function inOrder(root)
{
     
    var stack = [];
    var node = root;
    while(node || stack.length != 0){
     
        while(node){
     
            stack.push(node);
            node = node.left;
        }
        if(stack.length != 0){
     
            node = stack.pop();
            console.log(node.val);
            node = node.right();
        }
    }
}

后序遍历

左子树 -> 右子树 -> 根结点

//递归
function postOrder(root)
{
     
    if(!root)
        return;
    preOrder(root.left);
    preOrder(root.right);
    console.log(root.val);
}

//非递归
function postOrder(root)
{
     
    var stack = [];
    var node = root;
    var lastVisit = null;   //标记每次遍历最后一次访问的结点
    while(node || stack.length != 0){
     
        while(node){
     
            stack.push(node);
            node = node.left;
        }
        if(stack.length != 0){
     
            node = stack.pop();
            //判断节点是否有右子结点,同时判断lastVisit避免重复输出右子结点)
            if(node.right == null || node.right == lastVisit){
     
                //如果没有则输出
                console.log(node.val);
                lastVisit = node;
                node = null;
            }
            else{
     
                //如果有则再次入栈,并访问节点的右子节点
                stack.push(node);
                node = node.right();
            }
        }
    }
}

层序遍历

用队列实现

function levelOrder(root)
{
     
    var queue = [], res = [];
    queue.push(root);
    while(queue.length != 0){
     
        let len = queue.length;  //一层结点个数
        let temp = [];
        for(let i = 0; i < len; i++){
     
            var node = queue.shift();
            temp.push(node.val);
            if(node.left)
                queue.push(node.left);
            if(node.right)
                queue.push(node.right);
        }
        res.push(temp);
    }
    return res;
}

二叉搜索树

又称二叉查找树、二叉排序树,其根节点的值大于其左子树中任意一个结点的值,小于其右子树中任意一结点的值,这一规则适用于二叉查找树中的每一个节点

  • 建立
    function insertTree(node, val)
    {
           
    	if(!node){
           
        	node = new TreeNode();
        	node.val = val;
        	node.left = null;
        	node.right = null;
        	return true;
    	}
    	if(node.val == val)
        	return false;
    	if(node.val > val)
        	return insertTree(node.left, val);
    	else
        	return insertTree(node.right, val)
    }
    
  • 查找
    function SearchTree(node, val)
    {
           
    	if(!node)
        	return null;
    	if(node.val == val)
        	return node;
    	if(node.val > val)
        	return SearchTree(node.left, val);
    	else
        	return SearchTree(node.right, val);
    }
    

镜像二叉树

        # 源二叉树 
    	    8
    	   /  \
    	  6   10
    	 / \  / \
    	5  7 9  11
    	
      # 镜像二叉树
    	    8
    	   /  \
    	  10   6
    	 / \  / \
    	11 9 7  5
  • 实现
    思想:改变根节点的左右指向即可。需要先知道左右孩子指针,再处理根节点,对应的遍历方式为后序遍历

    //递归:自下向上换
    function Mirror(root)
    {
           
    	if(!root)
        	return null;
    	var left = Mirror(root.left);   
    	var right = Mirror(root.right); 
    	root.left = right;              
    	root.right = left;              
    	/*
      	另一种写法:
      	Mirror(root.left);
      	Mirror(root.right);
      	[root.left, root.right] = [root.right, root.left];  
    	*/
    	return root;
    }
    
    //非递归:从上向下换
    function Mirror(root)
    {
           
        if(!root)   //不加这个root为null时会报错
     	   return root;  
    	var a = [];  //队列
    	a.push(root);
    	while(a.length != 0){
           
        	var l = a.length;
        	for(var i = 0; i < l; i++){
           
            	var node = a.shift();  //压出第一个元素
            	if(node.left)
                	a.push(node.left);
            	if(node.right)
                	a.push(node.right);
            	//左右指针交换
            	[node.left, node.right] = [node.right, node.left];
        	}
    	}
    	return root;
    }
    
  • 判断是否为镜像

    function isMirror(node1, node2)
    {
           
    	if(node1 == null && node2 == null)
        	return true;
    	if(node1 == null || node2 == null)
        	return false;
    	if(node1.val != node2.val)
        	return false;
    	return isMirror(node1.left, node2.right) && isMirror(node1.right, node2.left);
    }
    isMirror(root.left, root.right);	
    

重建二叉树

输入某二叉树的前序遍历和中序遍历的结果,请重建出该二叉树

  • 思路
    1. 确定根结点,前序遍历的第一个结点为根节点
    2. 确定两种遍历方式的左右子树顺序
    3. 在左子树中递归步骤1和2
    4. 在右子树中递归步骤1和2
    5. 打印当前根
function reConstructBinaryTree(pre, vin)
{
     
    // write code herepre
    if(pre.length == 0 || vin.length == 0)
        return null;
    var index = vin.indexOf(pre[0]);  //根结点在中序遍历中的位置
    var vinLeft = vin.slice(0, index);  //中序左子树
    var vinRight = vin.slice(index+1);  //中序右子树
    var preLeft = pre.slice(1, index+1);  //前序右子树
    var preRight = pre.slice(index+1);    //前序左子树
    var root = new TreeNode(pre[0]);
    root.left = reConstructBinaryTree(preLeft, vinLeft);
    root.right = reConstructBinaryTree(preRight, vinRight);
    return root;
}

其它常见算法题

求二叉树深度

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

二叉树结点总数

function getNodeNumber(node)
{
     
    if(!node)
        return 0;
    return getNodeNumber(node.left)+node(node.right)+1;
}

叶子结点数

function getLeafNum(node)
{
     
    if(!node)
        return 0;
    if(!node.left && !node.right)
        return 1;
    return getLeafNum(node.left)+getLeafNum(node.right);
}

判断二叉树子结构

输入两棵二叉树A和B,判断B是不是A的子结构。(ps:约定空树不是任意一个树的子结构)

  • 思路
    • 判断步骤
      • 在树A中找到和B的根结点的值一样的结点R
      • 判断树A中以R为根结点的子树是不是包含和树B一样的结点
    • 递归终止条件
      • 如果树B为空,返回true,此时,不管树A是否为空,都为true
      • 如果树B不为空,但是树A为空,返回false
function dfs(pRoot1, pRoot2)  //先序遍历判断子树结构
{
     
    if(!pRoot2)   //B树空了不管A树为不为空都返回true
        return true;
    if(!pRoot1)   //A树空了B树没空返回false
        return false;
    if(pRoot1.val !== pRoot2.val)
        return false;
    return dfs(pRoot1.left, pRoot2.left) && dfs(pRoot1.right, pRoot2.right);
}

function HasSubtree(pRoot1, pRoot2)
{
     
    var flag = false;
    if (pRoot1 == null || pRoot2 == null) 
        return false;
    if (pRoot1.val == pRoot2.val)   //如果根结构相等,判断子树结构
        flag = dfs(pRoot1, pRoot2);
    /*
      如果当前A树根结点与B树根结点不相等或根节点相等但子树结构不同,
      先序遍历A树其它节点作为根结点与B树进行比较
    */
    if(!flag)  
        flag = HasSubtree(pRoot1.left, pRoot2);
    if(!flag)
        flag = HasSubtree(pRoot1.right, pRoot2);
    return flag;
}

将二叉搜索树转换成一个排序的双向链表

  • 思路
    因为二叉搜索树是左子树的所有节点比根节点小,右子树的所有节点比根节点大,所以如果要转换成一个有序的双向链表应该以中序遍历:左子树 -> 根节点 -> 右子树的顺序遍历二叉树,进行递归
  • 解法1
    1. 先用递归中序遍历二叉树并将结果保存在list中
    2. 遍历list修改指针指向
  • 解法2
    1. 递归,先将左子树调整为双向链表,并用变量pLast指向最后一个节点
    2. 再将中间节点和pLast连起来
    3. 再去调整右子树
    4. 最后返回最后一个节点,再向前移到第一个节点并返回
//1.
function Convert(pRootOfTree)
{
     
    // write code here
    if(!pRootOfTree)
        return null;
    var list = new Array();
    ConvertNode(pRootOfTree, list);  //中序遍历
    for(let i = 0; i < list.length - 1; i++){
      //注意是list.length-1
        list[i].right = list[i+1];
        list[i+1].left = list[i];
    }
    return list[0];
}

function ConvertNode(root, list)
{
     
    if(root.left)
        ConvertNode(root.left, list);
    list.push(root);
    if(root.right)
        ConvertNode(root.right, list);
}

//2.
function Convert(pRootOfTree) {
     
  // write code here
  if(!pRootOfTree) 
      return null;
  var pLast = null;
  pLast = ConvertNode(pRootOfTree, pLast);  //最后一个节点
  var pHead = pLast;
  while (pHead.left) {
       //移到第一个节点
    pHead = pHead.left;
  }
  return pHead;
}

function ConvertNode(pNode, pLast) {
     
  if(pNode.left){
       
    pLast = ConvertNode(pNode.left, pLast);
  }
  pNode.left = pLast;  //该节点的left指针指向上一个节点
  if (pLast) {
       //上一个节点的right指针指向下一个节点
    pLast.right = pNode;
  }
  pLast = pNode;
  if (pNode.right) {
     
    pLast = ConvertNode(pNode.right, pLast);
  }
  return pLast;
}

参考:
① https://blog.csdn.net/qq_36332184/article/details/102775099
② https://blog.csdn.net/xiaoquantouer/article/details/65631708
③ https://www.cnblogs.com/chenrencun/p/13569596.html
④ https://blog.csdn.net/weixin_39318565/article/details/111594445

你可能感兴趣的:(算法,算法,二叉树)