js实现二叉树(先序遍历，中序遍历，后续遍历)，递归与非递归方式

js实现二叉树

• 1.递归方式
• • (1)创建数结构(类)，测试数据
  • 1.1 先序遍历
  • 1.1 中序遍历
  • 1.1 后序遍历
• 2.非递归方式
• • (2)创建数结构(类)，测试数据
  • 2.1 先序遍历
  • 2.2 中序遍历
  • 2.3 后序遍历
• 3.总结

1.递归方式

(1)创建数结构(类)，测试数据

//创建二叉树
  class tree{
      constructor(value,left,right){
        this.value = value;
        this.left = left;
        this.right = right;
      }      
  }
//模拟数据
let q7 ,q8,q9,q10,q11,q12,q13,q14 = null;
  let q6 = new tree(7,q13,q14);
  let q5 = new tree(6,q11,q12);
  let q4 = new tree(5,q9,q10);
  let q3 = new tree(4,q7,q8);
  let q2 = new tree(3,q5,q6);
  let q1 = new tree(2,q3,q4);
  let q = new tree(1,q1,q2);
//测试
   let p = preFunction(q);   //先序
   let p1 = orderFunction(q);//中序
   let p2 = endFunction(q);  //后续
      console.log(p,p1,p2)	

1.1 先序遍历

function preFunction(listNode){
  var arr = [];
  arr.push(listNode);
  tempPre(listNode.left,arr)
  tempPre(listNode.right,arr)    
  return arr;
}
function tempPre(node,arr){
    if(node==null){
        return;
    }    
    arr.push(node)
  tempPre(node.left,arr);
  tempPre(node.right,arr);
}

1.1 中序遍历

//中序遍历
function orderFunction(listNode){
    let arr = [];
    
    orderTempPre(listNode.left,arr)
    arr.push(listNode);
    orderTempPre(listNode.right,arr)    
    return arr;
  }
  function orderTempPre(node,arr){
      if(node==null){
          return;
      }      
      orderTempPre(node.left,arr);
      arr.push(node)
      orderTempPre(node.right,arr);
  }

1.1 后序遍历

//后序遍历
  function endFunction(listNode){
    let arr = [];
    
    endTempPre(listNode.left,arr)    
    endTempPre(listNode.right,arr)    
    arr.push(listNode);
    return arr;
  }
  function endTempPre(node,arr){
      if(node==null){
          return;
      }      
      endTempPre(node.left,arr);    
      endTempPre(node.right,arr);
      arr.push(node);
  }

2.非递归方式

(2)创建数结构(类)，测试数据

//创建二叉树
  class tree{
      constructor(value,left,right){
        this.value = value;
        this.left = left;
        this.right = right;
      }      
  }
//模拟数据
let q7 ,q8,q9,q10,q11,q12,q13,q14 = null;
  let q6 = new tree(7,q13,q14);
  let q5 = new tree(6,q11,q12);
  let q4 = new tree(5,q9,q10);
  let q3 = new tree(4,q7,q8);
  let q2 = new tree(3,q5,q6);
  let q1 = new tree(2,q3,q4);
  let q = new tree(1,q1,q2);
//测试
   let a = preDeep(q);  //先序
   let b = orderDeep(q);//中序
   let c = endDeep(q);  //后续
   console.log(a,b,c)  

2.1 先序遍历

 function preDeep(node){
        let arr = [], res = [];
        let head = node;
        arr.push(head);  
        while(arr.length){
            head = arr.pop();
            res.push(head);
            if(head.right){
                arr.push(head.right);
            }
            if(head.left){
                arr.push(head.left);
            }
        }
        return res
    }  

2.2 中序遍历

function orderDeep(node){
        let arr = [],res = [],head = node;
        arr.push(head);
        while(arr.length){
            if(head.left){
                arr.push(head.left);
                head = head.left;
            }else{
                head = arr.pop();
                res.push(head);
                if(head.right){
                    arr.push(head.right);                    
                    head = head.right;
                }
            }
        }
        return res
    }

2.3 后序遍历

function endDeep(node){
        let arr = [] , res = [] ,head = node;
            arr.push(head);
        while(arr.length){
             head= arr.pop();
             res.push(head)
            if(head.left){
                arr.push(head.left);                
            }
            if(head.right){
                arr.push(head.right)
            }
        }
        return res.reverse();
    }

3.总结

二叉树的遍历，无非就3种，使用递归的方式会稍微简单一些，3中遍历只需要更换处理数据的位置即可。
非递归的方式需要使用到 栈的数据结构